10 research outputs found
Sparse multivariate polynomial interpolation in the basis of Schubert polynomials
Schubert polynomials were discovered by A. Lascoux and M. Sch\"utzenberger in
the study of cohomology rings of flag manifolds in 1980's. These polynomials
generalize Schur polynomials, and form a linear basis of multivariate
polynomials. In 2003, Lenart and Sottile introduced skew Schubert polynomials,
which generalize skew Schur polynomials, and expand in the Schubert basis with
the generalized Littlewood-Richardson coefficients.
In this paper we initiate the study of these two families of polynomials from
the perspective of computational complexity theory. We first observe that skew
Schubert polynomials, and therefore Schubert polynomials, are in \CountP
(when evaluating on non-negative integral inputs) and \VNP.
Our main result is a deterministic algorithm that computes the expansion of a
polynomial of degree in in the basis of Schubert
polynomials, assuming an oracle computing Schubert polynomials. This algorithm
runs in time polynomial in , , and the bit size of the expansion. This
generalizes, and derandomizes, the sparse interpolation algorithm of symmetric
polynomials in the Schur basis by Barvinok and Fomin (Advances in Applied
Mathematics, 18(3):271--285). In fact, our interpolation algorithm is general
enough to accommodate any linear basis satisfying certain natural properties.
Applications of the above results include a new algorithm that computes the
generalized Littlewood-Richardson coefficients.Comment: 20 pages; some typos correcte
Complete Derandomization of Identity Testing and Reconstruction of Read-Once Formulas
In this paper we study the identity testing problem of arithmetic read-once formulas (ROF) and some related models. A read-once formula is formula (a circuit whose underlying graph is a tree) in which the operations are {+,x} and such that every input variable labels at most one leaf. We obtain the first polynomial-time deterministic identity testing algorithm that operates in the black-box setting for read-once formulas, as well as some other related models. As an application, we obtain the first polynomial-time deterministic reconstruction algorithm for such formulas. Our results are obtained by improving and extending the analysis of the algorithm of [Shpilka-Volkovich, 2015
Isomorphism testing of read-once functions and polynomials
In this paper, we study the isomorphism testing problem of formulas in
the Boolean and arithmetic settings. We show that isomorphism testing
of Boolean formulas in which a variable is read at most once (known as
read-once formulas) is complete for log-space. In contrast, we observe
that the problem becomes polynomial time equivalent to the graph
isomorphism problem, when the input formulas can be represented as OR
of two or more monotone read-once formulas. This classifies the
complexity of the problem in terms of the number of reads, as read-3
formula isomorphism problem is hard for coNP.
We address the polynomial isomorphism problem, a special case of
polynomial equivalence problem which in turn is important from a
cryptographic perspective[Patarin EUROCRYPT\u2796, and Kayal SODA\u2711]. As our main result, we propose a deterministic polynomial time
canonization scheme for polynomials computed by constant-free
read-once arithmetic formulas. In contrast, we show that when the
arithmetic formula is allowed to read a variable twice, this problem
is as hard as the graph isomorphism problem
On Some Computations on Sparse Polynomials
In arithmetic circuit complexity the standard operations are +,x. Yet, in some scenarios exponentiation gates are considered as well. In this paper we study the question of efficiently evaluating a polynomial given an oracle access to its power. Among applications, we show that:
* A reconstruction algorithm for a circuit class c can be extended to handle f^e for f in C.
* There exists an efficient deterministic algorithm for factoring sparse multiquadratic polynomials.
* There is a deterministic algorithm for testing a factorization of sparse polynomials, with constant individual degrees, into sparse irreducible factors. That is, testing if f = g_1 x ... x g_m when f has constant individual degrees and g_i-s are irreducible.
* There is a deterministic reconstruction algorithm for multilinear depth-4 circuits with two multiplication gates.
* There exists an efficient deterministic algorithm for testing whether two powers of sparse polynomials are equal. That is, f^d = g^e when f and g are sparse
INTERPOLATING ARITHMETIC READ-ONCE FORMULAS IN PARALLEL
A formula is read-once if each variable appears at most once in it. An
artithmetic read-once formula is one in which the operations are
addition, subtraction, multiplication, and division (and constants are
allowed). We present a randomized (Las Vegas) parallel algorithm for the
exact interpolation of arithmetic read-once formulas over sufficiently
large fields. More specifically, for n-variable read-once formulas,
and fields of size at least , our algorithm
runs in parallel steps using
processors (where the field operations are charged unit cost). This
complements other results which imply that other classes of read-once
formulas cannot be interpolated-or even learned with membership
and equivalence queries-in poly-logarithmic-time with polynomially many
processors (even though they can be learned sequentially in
polynomial-time). These classes include boolean read-once formulas and
arithmetic read-once formulas over fields of size o(n/log n)
(for n variable read-once formulas).We are currently acquiring citations for the work deposited into this collection. We recognize the distribution rights of this item may have been assigned to another entity, other than the author(s) of the work.If you can provide the citation for this work or you think you own the distribution rights to this work please contact the Institutional Repository Administrator at [email protected]
Interpolation of depth-3 arithmetic circuits with two multiplication gates
In this paper we consider the problem of constructing a small arithmetic circuit for a polynomial for which we have oracle access. Our focus is on n-variate polynomials, over a finite field F, that have depth-3 arithmetic circuits with two multiplication gates of degree d. We obtain the following results: 1. Multilinear case: When the circuit is multilinear (multiplication gates compute multilinear polynomials) we give an algorithm that outputs, with probability 1 − o(1), all the depth-3 circuits with two multiplication gates computing the same polynomial. The running time of the algorithm is poly(n, |F|). 2. General case: When the circuit is not multilinear we give a quasi-polynomial (in n, d, |F|) time algorithm that outputs, with probability 1 − o(1), a succinct representation of the polynomial. In particular, if the depth-3 circuit for the polynomial is not of small depth-3 rank (namely, after removing the g.c.d. of the two multiplication gates, the remaining linear functions span a not too small linear space) then we output the depth-3 circuit itself. In case that the rank is small we output a depth-3 circuit with a quasi-polynomial number of multiplication gates. Our proof technique is new and relies on the factorization algorithm for multivariate black-box polynomials, on lower bounds on the length of linear locally decodable codes with 2 queries, and on a theorem regarding the structure of identically zero depth-3 circuits with four multiplication gates