Straight-line Programs Research Articles

Strong bias of group generators: an obstacle to the “product replacement algorithm”

Let G be a finite group. Efficient generation of nearly uniformly distributed random elements in G, starting from a given set of generators of G, is a central problem in computational group theory. In this paper we demonstrate a weakness in the popular “product replacement algorithm,” widely used for this purpose. The main results are the following. Let N k(G) be the set of generating k-tuples of elements of G. Consider the distribution of the first components of the k-tuples in N k(G) induced by the uniform distribution over N k(G) . We show that there exist infinite sequences of groups G such that this distribution is very far from uniform in two different senses: (1) its variation distance from uniform is >1− ϵ; and (2) there exists a short word (of length (loglog| G|) O( k) ) which separates the two distributions with probability 1− ϵ. The class of groups we analyze is direct powers of alternating groups. The methods used include statistical analysis of permutation groups, the theory of random walks, the AKS sorting network, and a randomized simulation of monotone Boolean operations by group operations, inspired by Barrington's work on bounded-width branching programs. The problem is motivated by the product replacement algorithm which was introduced in [Comm. Algebra 23 (1995) 4931–4948] and is widely used. Our results show that for certain groups the probability distribution obtained by the product replacement algorithm has a bias which can be detected by a short straight line program.

Two Linear Correlation Coefficients

In fitting data to a straight line, many calculators and computer programs display a ’linear correlation coefficient’. Two types of linear correlation coefficients are discussed, one often useful in chemical calculations, the other usually not.

On the Complexity of Pattern Matching for Highly Compressed Two-Dimensional Texts

We consider the complexity of problems related to two-dimensional texts (2D-texts) described succinctly. In a succinct description, larger rectangular subtexts are defined in terms of smaller parts in a way similar to that of Lempel–Ziv compression for 1D-texts, or in strings with shortened descriptions as in ( Nordic J. Comput. 4 (1997) 172–186), or in hierarchical graphs described by context-free graph grammars. A given 2D-text T with many internal repetitions can have a hierarchical description which may be exponentially smaller and which can be given as an input for a pattern-matching algorithm which gives information about T. Such a hierarchical description is given in terms of a straight-line program, or SLP (see Nordic J. Comput. 4 (1997) 172–186) or, equivalently, of a 2D grammar. We consider compressed pattern matching, where the input consists of a 2D-pattern P and a hierarchical description of a 2D-text T, and fully compressed pattern matching, where the input consists of hierarchical descriptions of both the pattern P and the text T. For 1D strings, there exist polynomial-time deterministic algorithms for these problems for similar types of succinct text descriptions ( J. Comput. System Sci. 52 (2) (1996) 299–307; “Proceedings of the 27th Annual Symposium on the Theory of Computing,” pp. 703–712; “Proceedings of the 5th Scandinavian Workshop on Algorithm Theory,” Springer-Verlag, Berlin, 1996; Nordic J. Comput. 4(2) (1997), 172–186). We show that the complexity dramatically increases in a 2D setting. For example, compressed 2D-matching is NP-complete, fully compressed 2D-matching is Σ P 2-complete, and testing a given occurrence of a 2D compressed pattern is co- NP-complete. On the other hand, we give efficient algorithms for the related problems of randomized equality testing and testing for a given occurrence of an uncompressed pattern. We also show the surprising fact that the compressed size of a subrectangle of a compressed 2D array can grow exponentially, unlike the 1D case.

Computation of Boolean functions by randomized programs

The average time of computing Boolean functions by straight-line programs with random number generators is studied. Reliable programs, which always compute the correct value of the function in question, and programs computing the desired value with some probability are considered. In both cases, it is shown that random number generators do not lead to a noticeable reduction in the average execution time for a large portion of the inputs. More exactly, for any Boolean function of n arguments whose circuit size is L, there exists a domain for which the ratio of L to the average time of computing the function by reliable programs does not exceed n. For randomized programs with a probability different from 1, this ratio may be only slightly greater than n.

Average time of computing Boolean operators

The average time of computing Boolean operators by straight-line programs of two types is studied. Upper and lower bounds for the corresponding Shannon functions are obtained. Asymptotically exact formulas for Shannon functions are derived in the case when the number of components of the operators to be computed increases with the number of their arguments.

Functional programming concepts and straight-line programs in computer algebra

In this paper we present MILONGA, a language based on functional programming concepts, which was designed for the implementation of a new generation of nonterm-rewriting elimination algorithms for multivariate polynomial solving [J. Pure Appl. Alg. 124 (1998) 101–146; J. Pure Appl. Alg. 117/118 (1997) 277–317; Appl. Alg. Eng. Commun. Comput. 11 (4) (2001) 239–296; J. Complex. 17 (1) (2001) 154–211]. These new algorithms profit from an alternative representation of multivariate polynomials by means of straight-line programs [Algebraic complexity theory, in: Handbook of Theoretical Computer Science, Elsevier, Amsterdam, 1990, pp. 634–671 (Chapter 11); Algebraic complexity theory, in: Grundlehren der mathematischen Wissenschaften, Vol. 315, Springer, Berlin, 1997] allowing an exponential improvement of theoretical complexity—with respect to computing time and memory space—upon traditional, term-rewriting procedures. There is a strong analogy between the way how these algorithms employ straight-line programs and the way how functional programming languages treat functions as first-class citizens. Taking advantage of this circumstance, the MILONGA language enables us to analyze the relevance of the functional programming paradigm for the particular kind of task of polynomial equation solving. The paper contains an exhaustive do-it-yourself description of the programming philosophy of MILONGA, of the development of its compiler, of the operational semantics of its run-time system and of the implementation of a couple of fundamental computer algebra procedures in this language. The practical efficiency of this philosophy and implementation is outlined by comparative benchmarking on significant test examples.

Adjoining Strategies for Multi-layered Programs

Some papers present the rules to apply to a straight line program to differentiate it in reverse mode, as well as theoretical complexity measures. This paper recalls these rules, but also summarises the different possible strategies for the differentiation of a multi-level program in reverse mode. We focus on the reverse mode, because the computation of derivatives in reverse order (w.r.t. the computation of original variables) makes the problem much more complicated. A lot of strategies can be applied to generate an adjoint code: these strategies are applied within hand-coded discrete adjoints or within automatically generated adjoints. But they are not necessarily known by both communities, this is why we describe several of them in this paper. Until now, the comparison of these strategies on a code is difficult because no complexity measure has been associated to them. This paper presents complexity measures of the adjoint codes generated using these strategies in terms of execution time and memory requirement. These complexities are based on some elementary measures such as execution time and memory requirement of their sub-programs. For sake of simplicity, in a first phase we neglect the memory management within time costs. In a second phase, we explain how the extra cost first neglected can be accommodated for in the complexity measures.

Lower Bounds for Dynamic Algebraic Problems

We consider dynamic evaluation of algebraic functions (matrix multiplication, determinant, convolution, Fourier transform, etc.) in the model of Reif and Tate; i.e., if f(x1,…, xn)=(y1, …, ym) is an algebraic problem, we consider serving online requests of the form “change input xi to value v” or “what is the value of output yi?” We present techniques for showing lower bounds on the worst case time complexity per operation for such problems. The first gives lower bounds in a wide range of rather powerful models (for instance, history dependent algebraic computation trees over any infinite subset of a field, the integer RAM, and the generalized real RAM model of Ben-Amram and Galil). Using this technique, we show optimal Ω(n) bounds for dynamic matrix–vector product, dynamic matrix multiplication, and dynamic discriminant and an Ω(n) lower bound for dynamic polynomial multiplication (convolution), providing a good match with Reif and Tate's O(n log n) upper bound. We also show linear lower bounds for dynamic determinant, matrix adjoint, and matrix inverse and an Ω(n) lower bound for the elementary symmetric functions. The second technique is the communication complexity technique of Miltersen, Nisan, Safra, and Wigderson which we apply to the setting of dynamic algebraic problems, obtaining similar lower bounds in the word RAM model. The third technique gives lower bounds in the weaker straight line program model. Using this technique, we show an Ω((log n)2/log log n) lower bound for dynamic discrete Fourier transform. Technical ingredients of our techniques are the incompressibility technique of Ben-Amram and Galil and the lower bound for depth-two superconcentrators of Radhakrishnan and Ta-Shma. The incompressibility technique is extended to arithmetic computation in arbitrary fields.

Average case complexity for finite Boolean functions

The average time of computing Boolean functions by straight-line programs with a conditional stop is considered. A straight-line program consists of operators of two types. Every operator of the first type computes a binary Boolean function whose arguments are either the values computed by preceding operators or the values of the input variables. Every operator of the second type either terminates execution of the program or commands that the next operator is executed. A measure of the complexity of such programs is the average execution time over all tuples of the input variables. The complexity of computing almost all complete Boolean functions and almost all partial Boolean functions by such programs is proved to coincide (up to a multiplicative constant) with conventional circuit complexity. Moreover, these complexities are proved to differ (up to a multiplicative constant) by a factor of n for almost all n-place Boolean functions that are equal to 1 on n c tuples. It is proved that there exist Boolean functions of n variables whose average execution time is less (up to a multiplicative constant) by a factor of (2 n / n) 1/2 than the time required to compute them by conventional straight-line programs.

Computing Chow Forms and Some Applications

We prove the existence of an algorithm that, from a finite set of polynomials defining an algebraic projective variety, computes the Chow form of its equidimensional component of the greatest dimension. Applying this algorithm, a finite set of polynomials defining the equidimensional component of the greatest dimension of an algebraic (projective or affine) variety can be computed. The complexities of the algorithms involved are lower than the complexities of the known algorithms solving the same tasks. This is due to a special way of coding output polynomials, called straight-line programs.

Branching Program Size Is Almost Linear in Formula Size

Circuit size, formula size, and branching program size are the most important complexity measures for boolean functions. Although the corresponding computation models and the relations between these complexity measures have been investigated quite well in the past, we are still lacking a tight upper bound for the branching program size in terms of formula size. The best previously known simulation of B2-formulas of size ℓ by branching programs achieves a branching program size of O(ℓ1.195) (1999, M. Sauerhoff, I. Wegener, and R. Werchner, Lecture Notes in Computer Science, Vol. 1563, pp. 57–67, Springer-Verlag, Berlin/New York). This work presents a proof showing that every B2-formula of size ℓ can be transformed into a branching program of size O(ℓ1+ε) for an arbitrary ε>0. The proof is based on three major steps. First, a given formula is balanced appropriately. Then, a technique due to R. Cleve (1991, Comput. Complexity1, 91–105) to simulate balanced algebraic formulas of size s by algebraic straight-line programs that employ a constant number of registers and have length O(s1+ε) is applied. Finally, it is shown how branching programs of the stated size can be obtained from the constructed straight-line programs.

Computing bases of complete intersection rings in Noether position

Let k be an effective infinite perfect field, k[ x 1,…, x n ] the polynomial ring in n variables and F∈ k[ x 1,…, x n ] M× M a square polynomial matrix verifying F 2= F. Suppose that the entries of F are polynomials given by a straight-line program of size L and their total degrees are bounded by an integer D. We show that there exists a well parallelizable algorithm which computes bases of the kernel and the image of F in time ( nL) O(1)( MD) O( n) . By means of this result we obtain a single exponential algorithm to compute a basis of a complete intersection ring in Noether position. More precisely, let f 1,…, f n− r ∈ k[ x 1,…, x n ] be a regular sequence of polynomials given by a slp of size ℓ, whose degrees are bounded by d. Let R≔ k[ x 1,…, x r ] and S≔ k[ x 1,…, x n ]/( f 1,…, f n− r ) such that S is integral over R; we show that there exists an algorithm running in time O( n)ℓ d O( n 2) which computes a basis of S over R. Also, as a consequence of our techniques, we show a single exponential well parallelizable algorithm which decides the freeness of a finite k[ x 1,…, x n ]-module given by a presentation matrix, and in the affirmative case it computes a basis.

The Projective Noether Maple Package: Computing the Dimension of a Projective Variety

Recent theoretical advances in elimination theory use straight-line programs as a data structure to represent multivariate polynomials. We present here the Projective Noether Package which is a Maple implementation of one of these new algorithms, yielding as a byproduct a computation of the dimension of a projective variety. Comparative results on benchmarks for time and space of several families of multivariate polynomial equation systems are given and we point out both weaknesses and advantages of different approaches.

Some Speed-Ups and Speed Limits for Real Algebraic Geometry

We give new positive and negative results, some conditional, on speeding up computational algebraic geometry over the reals: 1.A new and sharper upper bound on the number of connected components of a semi-algebraic set. Our bound is novel in that it is stated in terms of the volumes of certain polytopes and, for a large class of inputs, beats the best previous bounds by a factor exponential in the number of variables. 2.A new algorithm for approximating the real roots of certain sparse polynomial systems. Two features of our algorithm are (a) arithmetic complexity polylogarithmic in the degree of the underlying complex variety (as opposed to the super-linear dependence in earlier algorithms) and (b) a simple and efficient generalization to certain univariate exponential sums. 3.Detecting whether a real algebraic surface (given as the common zero set of some input straight-line programs) is not smooth can be done in polynomial time within the classical Turing model (resp. BSS model over C) only if P=NP (resp. NP⊆BPP). The last result follows easily from an unpublished observation of S. Smale.

Time-Space Tradeoffs in Algebraic Complexity Theory

We exhibit a new method for showing lower bounds for time-space tradeoffs of polynomial evaluation procedures given by straight-line programs. From the tradeoff results obtained by this method we deduce lower space bounds for polynomial evaluation procedures running in optimal nonscalar time. Time, denoted by L, is measured in terms of nonscalar arithmetic operations and space, denoted by S, is measured by the maximal number of pebbles (registers) used during the given evaluation procedure. The time-space tradeoff function considered in this paper is LS2. We show that for “almost all” univariate polynomials of degree at most d our time-space tradeoff functions satisfy the inequality LS2⩾d8. From this we conclude that for “almost all” degree d univariate polynomials, any nonscalar time optimal evaluation procedure requires space at least S⩾cd, where c>0 is a suitable universal constant. The main part of this paper is devoted to the exhibition of specific families of univariate polynomials which are “hard to compute” in the sense of time-space tradeoff (this means that our tradeoff function increases linearly in the degree).

On the intrinsic complexity of the arithmetic Nullstellensatz

We show several arithmetic estimates for Hilbert's Nullstellensatz. This includes an algorithmic procedure computing the polynomials and constants occurring in a Bézout identity, whose complexity is polynomial in the geometric degree of the system. Moreover, we show for the first time height estimates of intrinsic type for the polynomials and constants appearing, again polynomial in the geometric degree and linear in the height of the system. These results are based on a suitable representation of polynomials by straight-line programs and duality techniques using the Trace Formula for Gorenstein algebras. As an application we show more precise upper bounds for the function π S(x) counting the number of primes yielding an inconsistent modular polynomial equation system. We also give a computationally interesting lower bound for the density of small prime numbers of controlled bit length for the reduction to positive characteristic of inconsistent systems. Again, this bound is given in terms of intrinsic parameters.

On the data structure straight-line program and its implementation in symbolic computation

In this paper we describe a recent computer implementation (the PASCAL program TERA) of a well known Computer Algebra algorithm. The particularity of this implementation consists in the fact that it is based on a special abstract data type, namely that of a directed acyclic graph (DAG) which is of seldom use in Computer Algebra packages. This data type is particularly adapted to the algorithmic problem which we are considering in this paper: the computation of the of two multivariate polynomials. This task is solved by an algorithmic approach based on linear recurring sequences (see [F.R. Gantmacher, The Theory of Matrices, vol. 1/2, Chelsea, New York, 1959; R. Sendra, J. Llovet, Journal of Symbolic Computation 13 (1992) 25–39; J. Llovet, R. Sendra, J.A. Jaén, R. Martínez, Computer Science, 1992, pp. 159–165; R. Martínez, Procedimientos de Recurrencia Lineal en Algebra Computacional, PhD Thesis, Depto. de Matemáticas, Universidad de Alcalá de Henares, España, 1992; J. Llovet, R. Martínez, J.A. Jaén, Journal of Computational and Applied Mathematics 49 (1993) 145–152]). An experimental study shows that the time and memory space performance of the TERA program improves significantly upon that of traditional Computer Algebra Systems (MAPLE and MAGMA in our case).

On the realization of linear Boolean operators by straight-line programs with a conditional stop

Article On the realization of linear Boolean operators by straight-line programs with a conditional stop was published on January 1, 1999 in the journal Discrete Mathematics and Applications (volume 9, issue 2).

Le rapport entre le temps et l'espace pour l'évaluation des polynômes

We develop a new method for showing lower bounds for the time-space tradeoff of polynomial evaluation procedures given by straight-line programs. By means of this method we prove an asymptotically sharp lower bound for the time-space tradeoff of general procedures of polynomial evaluation and exhibit specific families of univariate polynomials where this bound is reached.

An effective algorithm for quantifier elimination over algebraically closed fields using straight line programs

In this paper we obtain an effective algorithm for quantifier elimination over algebraically closed fields: For every effective infinite integral domain k, closed under the extraction of pth roots when the characteristic p of k is positive, and every prenex formula ϑ with r blocks of quantifiers involving s polynomials F 1, h., F s ϵ k[ X 1, h., X n ] encoded in dense form, there exists a well-parallelizable algorithm without divisions whose output is a quantifier-free formula equivalent to ϑ. The sequential complexity of this algorithm is bounded by O(¦ϑ¦) + D (O(n)) r , where ¦ϑ¦ is the length of ϑ and D ≥ n is an upper bound for 1 + bE i = 1 s deg F i , and the polynomials in the output are encoded by means of a straight line program. The complexity bound obtained is better than the bounds of the known elimination algorithms, which are of the type ¦ϑ¦.D n cr , where c ≥ 2 is a constant. This becomes notorious when r = 1 (i.e., when there is only one block of quantifiers): the complexity bounds known up to now are not less than D n 2 , while our bound is D O( n) . Moreover, in the particular case that there is only one block of existential quantifiers and the input polynomials are given by a straight line program, we construct an elimination algorithm with even better bounds which depend on the length of this straight line program: Given a formula of the type ∃X n−m+…,∃X n:F 1(X 1,…,X n=0 ∧ … ∧ F s(X 1,…,X n) =0 ∧G 1(X 1,…,X n)≠0 ∧ … ∧ G s ′ (X 1,…,X n)≠0, where F 1, h., F s ϵ k[ X 1, h., X n ] are polynomials whose degrees in the m variables X − m + 1 , h., X n are bounded by an integer d ≥ m and G 1, h., G s′ ϵ k[ X 1, h., X n ] are polynomials whose degrees in the same variables are bounded by an integer δ, this algorithm eliminates quantifiers in time L 2.( s. s′. δ) O(1) . d O( m) , where L is the length of the straight line program that encodes F 1, h., F s , G 1, h., G s′ . Finally, we construct a fast algorithm to compute the Chow Form of an irreducible projective variety. The construction of all the algorithms mentioned above relies on a preprocessing whose cost exceedes the complexity classes considered (they are based on the construction of correct test sequences). In this sense, our algorithms are non-uniform but may be considered uniform as randomized algorithms (choosing the correct test sequences randomly).