Abstract. New probabilistic algorithms are presented for factoring univariate polynomials over finite fields. The algorithms factor a polynomial of degree n over a finite field of constant cardinality in time O(n 1.815). Previous algorithms required time Θ(n 2+o(1)). The new algorithms rely on fast matrix multiplication techniques. More generally, to factor a polynomial of degree n over the finite field Fq with q elements, the algorithms use O(n 1.815 log q) arithmetic operations in Fq. The new “baby step/giant step ” techniques used in our algorithms also yield new fast practical algorithms at super-quadratic asymptotic running time, and subquadratic-time methods for manipulating normal bases of finite fields. 1.

Abstract not found

A probabilistic algorithm is presented to find the determinant of a nonsingular, integer matrix. For a matrix A ¡£ ¢ n ¤ n the algorithm requires O ¥ n 3 ¦ 5 ¥ logn § 4 ¦ 5 § bit operations (assuming for now that entries in A have constant size) using standard matrix and integer arithmetic. Using asymptotically fast matrix arithmetic, a variant is described which requires O ¥ n 2 ¨ θ © 2 � log 2 nloglogn § bit operations, where two n � n matrices can be multiplied with O ¥ n θ § operations. The determinant is found by computing the Smith form of the integer matrix, an extremely useful canonical form in itself. Our algorithm is probabilistic of the Monte Carlo type. That is, it assumes a source of random bits and on any invocation of the algorithm there is a small probability of error. 1

For a polynomial matrix P(z) of degree d in M~,~(K[z]) where K is a commutative field, a reduction to the Hermite normal form can be computed in O (ndM(n) + M(nd)) arithmetic operations if M(n) is the time required to multiply two n x n matrices over K. Further, a reduction can be computed using O(log~+ ’ (ml)) pamlel arithmetic steps and O(L(nd) ) processors if the same processor bound holds with time O (logX (rid)) for determining the lexicographically first maximal linearly independent subset of the set of the columns of an nd x nd matrix over K. These results are obtamed by applying in the matrix case, the techniques used in the scalar case of the gcd of polynomials.

We analyse a randomized block algorithm proposed by Coppersmith for solving large sparse systems of linear equations, Aw = 0, over a finite field K =GF(q). It is a modification of an algorithm of Wiedemann. Coppersmith has given heuristic arguments to understand why the algorithm works. But it was an open question to prove that it may produce a solution, with positive probability, for small finite fields e.g. for K =GF(2). We answer this question nearly completely. The algorithm uses two random matrices X and Y of dimensions m \Theta N and N \Theta n. Over any finite field, we show how the parameters m and n of the algorithm may be tuned so that, for any input system, a solution is computed with high probability. Conversely, for certain particular input systems, we show that the conditions on the input parameters may be relaxed to ensure the success. We also improve the probability bound of Kaltofen in the case of large cardinality fields. Lastly, for the sake of completeness of the...

We describe an O(n³) field operations algorithm for computing the Frobenius normal form of an n \Theta n matrix. As applications we get O(n³) algorithms for two other classical problems: computing the minimal polynomial of a matrix and testing two matrices for similarity. Assuming standard matrix multiplication, the previously best known deterministic complexity bound for all three problems is O(n^4).

We present two new probabilistic algorithms for computing the Smith normal form of an A 2 Z m\Thetan . The first requires an expected number of O(m 2 n \Delta M(m log kAk)) bit operations (ignoring logarithmic factors) and is of the Las Vegas type; that is, it never produces an incorrect answer. Here kAk = max ij jA ij j and M(l) bit operations are sufficient to multiply two l-bit integers (M(l) = l 2 using standard arithmetic) . This improves on the previously best known (deterministic) algorithm of Hafner and McCurley, which requires about O(m 3 n log kAk \Delta M(m log kAk)) bit operations. We also present an even faster, more space efficient algorithm which requires an expected number of O((m 3 n log kAk + m 3 log 2 kAk) \Delta log(1=ffl)) bit operations using standard integer arithmetic. This algorithm is of the Monte Carlo type: it returns the correct result with probability at least 1 \Gamma ffl for a user specified tolerance ffl ? 0. This algorithm also require...

We present a new iterative algorithm for solving large sparse systems of linear Diophantine equations which is fast, provably exploits sparsity, and allows an efficient parallel implementation. This is accomplished by reducing the problem of finding an integer solution to that of finding a very small number of rational solutions of random Toeplitz preconditionings of the original system. We then employ the Block-Wiedemann algorithm to solve these preconditioned systems efficiently in parallel. Solutions produced are small and space required is essentially linear in the output size.

. We probabilistically determine the Frobenius form and thus the characteristic polynomial of a matrix A 2 F nn by O(n log(n)) multiplications of A by vectors and O n 2 log 2 (n) log log(n) arithmetic operations in the eld F. The parameter is the number of distinct invariant factors of A, it is less than 3 p n=2 in the worst case. The method requires O(n) storage space in addition to that needed for the matrix A. 1 Introduction The known complexity estimates of the computation of the characteristic polynomial and a fortiori, of the Frobenius normal form of special { sparse or black box { square matrices A over a eld F, seem to not be satisfactory. We refer to Kaltofen [8, Open Problem 3] and to Pan et al. [16, 15] for discussions on this subject and survey of current solutions. We denote by M(n) the number of operations in F required for nn matrix multiplications. The characteristic polynomial of a general matrix A can be computed at cost of O(n 3 ) or O(M(n) log...

The well known L³-reduction algorithm of Lov'asz transforms a given integer lattice basis b1 ; b2 ; : : : ; bn 2 ZZ n into a reduced basis. The cost of L 3 -reduction is O(n 4 log Bo) arithmetic operations with integers bounded in length by O(n log Bo) bits. Here, Bo bounds the Euclidean length of the input vectors, that is, Bo jb1 j 2 ; jb2 j 2 ; : : : ; jbn j 2 . We present a simple modification of the L³-reduction algorithm that requires only O(n³ log Bo) arithmetic operations with integers of the same length. We gain a further speedup by combining our new approach with Schonhage's modification of the L³-reduction algorithm and incorporating fast matrix mutliplication techniques. The result is an algorithm for semi-reduction that requires O(n 2:381 log Bo ) arithmetic operations with integers of the same length.