Computer Science

Root separation bounds play an important role as a complexity measure in understanding the behaviour of various algorithms in computational algebra, e.g., root isolation algorithms. A classic result in the univariate setting is the Davenport-Mahler-Mignotte (DMM) bound. One way to state the bound is to consider a directed acyclic graph (V,E) on a subset of roots of a degree d polynomial f(z)∈C[z] , where the edges point from a root of smaller absolute value to one of larger absolute, and the in-degrees of all vertices is at most one. Then the DMM bound is an amortized lower bound on the following product: ∏ (α,β)∈E |α−β| . However, the lower bound involves the discriminant of the polynomial f , and becomes trivial if the polynomial is not square-free. This was resolved by Eigenwillig, (2008), by using a suitable subdiscriminant instead of the discriminant. Escorcielo-Perrucci, 2016, further dropped the in-degree constraint on the graph by using the theory of finite differences. Emiris et al., 2019, have generalized their result to handle the case where the exponent of the term |α−β| in the product is at most the multiplicity of either of the roots. In this paper, we generalize these results by allowing arbitrary positive integer weights on the edges of the graph, i.e., for a weight function w:E→ Z >0 , we derive an amortized lower bound on ∏ (α,β)∈E |α−β | w(α,β) . Such a product occurs in the complexity estimates of some recent algorithms for root clustering (e.g., Becker et al., 2016), where the weights are usually some function of the multiplicity of the roots. Because of its amortized nature, our bound is arguably better than the bounds obtained by manipulating existing results to accommodate the weights.

Suppose K is a large enough field and P⊂ K 2 is a fixed, generic set of points which is available for precomputation. We introduce a technique called \emph{reshaping} which allows us to design quasi-linear algorithms for both: computing the evaluations of an input polynomial f∈K[x,y] at all points of P ; and computing an interpolant f∈K[x,y] which takes prescribed values on P and satisfies an input y -degree bound. Our genericity assumption is explicit and we prove that it holds for most point sets over a large enough field. If P violates the assumption, our algorithms still work and the performance degrades smoothly according to a distance from being generic. To show that the reshaping technique may have an impact on other related problems, we apply it to modular composition: suppose generic polynomials M∈K[x] and A∈K[x] are available for precomputation, then given an input f∈K[x,y] we show how to compute f(x,A(x))remM(x) in quasi-linear time.

The polynomial multiplication problem has attracted considerable attention since the early days of computer algebra, and several algorithms have been designed to achieve the best possible time complexity. More recently, efforts have been made to improve the space complexity, developing modified versions of a few specific algorithms to use no extra space while keeping the same asymptotic running time. In this work, we broaden the scope in two regards. First, we ask whether an arbitrary multiplication algorithm can be performed in-place generically. Second, we consider two important variants which produce only part of the result (and hence have less space to work with), the so-called middle and short products, and ask whether these operations can also be performed in-place. To answer both questions in (mostly) the affirmative, we provide a series of reductions starting with any linear-space multiplication algorithm. For full and short product algorithms these reductions yield in-place versions with the same asymptotic time complexity as the out-of-place version. For the middle product, the reduction incurs an extra logarithmic factor in the time complexity only when the algorithm is quasi-linear.

For sparse matrices up to size 8×8 , we determine optimal choices for pivot selection in Gaussian elimination. It turns out that they are slightly better than the pivots chosen by a popular pivot selection strategy, so there is some room for improvement. We then create a pivot selection strategy using machine learning and find that it indeed leads to a small improvement compared to the classical strategy.

In this work we consider the computation of Groebner bases of the steady state ideal of reaction networks equipped with mass-action kinetics. Specifically, we focus on the role of intermediate species and the relation between the extended network (with intermediate species) and the core network (without intermediate species). We show that a Groebner basis of the steady state ideal of the core network always lifts to a Groebner basis of the steady state ideal of the extended network by means of linear algebra, with a suitable choice of monomial order. As illustrated with examples, this contributes to a substantial reduction of the computation time, due mainly to the reduction in the number of variables and polynomials. We further show that if the steady state ideal of the core network is binomial, then so is the case for the extended network, as long as an extra condition is fulfilled. For standard networks, this extra condition can be visually explored from the network structure alone.

We give an example where the number of elements of a Groebner basis in a Boolean ring is not polynomially bounded in terms of the bitsize and degrees of the input.

We study the relationship between certain Groebner bases for zero dimensional ideals, and the interpolation condition functionals of ideal interpolation. Ideal interpolation is defined by a linear idempotent projector whose kernel is a polynomial ideal. In this paper, we propose the notion of "reverse" complete reduced basis. Based on the notion, we present a fast algorithm to compute the reduced Groebner basis for the kernel of ideal projector under an arbitrary compatible ordering. As an application, we show that knowing the affine variety makes available information concerning the reduced Groebner basis.

Gr{ö}bner bases is one the most powerful tools in algorithmic non-linear algebra. Their computation is an intrinsically hard problem with a complexity at least single exponential in the number of variables. However, in most of the cases, the polynomial systems coming from applications have some kind of structure. For example , several problems in computer-aided design, robotics, vision, biology , kinematics, cryptography, and optimization involve sparse systems where the input polynomials have a few non-zero terms. Our approach to exploit sparsity is to embed the systems in a semigroup algebra and to compute Gr{ö}bner bases over this algebra. Up to now, the algorithms that follow this approach benefit from the sparsity only in the case where all the polynomials have the same sparsity structure, that is the same Newton polytope. We introduce the first algorithm that overcomes this restriction. Under regularity assumptions, it performs no redundant computations. Further, we extend this algorithm to compute Gr{ö}bner basis in the standard algebra and solve sparse polynomials systems over the torus (C∗ ) n . The complexity of the algorithm depends on the Newton polytopes.

In this work we develop the theory of Gröbner bases for modules over the ring of univariate linearized polynomials with coefficients from a finite field.

In this paper, we make a contribution to the computation of Gröbner bases. For polynomial reduction, instead of choosing the leading monomial of a polynomial as the monomial with respect to which the reduction process is carried out, we investigate what happens if we make that choice arbitrarily. It turns out not only this is possible (the fact that this produces a normal form being already known in the literature), but, for a fixed choice of reductors, the obtained normal form is the same no matter the order in which we reduce the monomials. To prove this, we introduce reduction machines, which work by reducing each monomial independently and then collecting the result. We show that such a machine can simulate any such reduction. We then discuss different implementations of these machines. Some of these implementations address inherent inefficiencies in reduction machines (repeating the same computations). We describe a first implementation and look at some experimental results.