Arithmetic Read-once Formula Research Articles

Complete Derandomization of Identity Testing and Reconstruction of Read-Once Formulas

In this article, we study the identity testing problem of arithmetic read-once formulas (ROFs) and some related models. An ROF is a formula (a circuit whose underlying graph is a tree) in which the operations are { +, × } 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 ROFs, 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 and Yolkovich [51].

Sums of read-once formulas: How many summands are necessary?

An arithmetic read-once formula (ROF) is a formula (circuit of fan-out 1) over +,× where each variable labels at most one leaf. Every multilinear polynomial can be expressed as the sum of (possibly exponentially many) ROFs. In this work, we prove, for certain multilinear polynomials, a tight lower bound on the number of summands in such an expression.

Read-once polynomial identity testing

An arithmetic read-once formula (ROF for short) is a formula (a circuit whose underlying graph is a tree) in which the operations are $${\left\{+, \times \right\}}$$+, and such that every input var...

On Reconstruction and Testing of Read-Once Formulas

An arithmetic read-once formula (ROF for short) is a formula (a circuit whose underlying graph is a tree) in which the operations aref+;g and each input variable labels at most one leaf. A preprocessed ROF (PROF for short) is a ROF in which we are allowed to replace each variable xi with a univariate polynomial Ti(xi). We obtain a deterministic non-adaptive reconstruction algorithm for PROFs, that is, an algorithm that, given black-box access to a PROF, constructs a PROF computing the same polynomial. The running time of the algorithm is (nd) O(log n) for PROFs of individual degrees at most d. To the best of our knowledge our results give the first subexponential-time deterministic reconstruction algorithms for ROFs. Another question that we study is the following generalization of the polynomial identity testing (PIT) problem. Given an arithmetic circuit computing a polynomial P( ¯ x), decide whether there is a PROF computing P( ¯ x), and find one if one exists. We call this question the read-once testing problem (ROT for short). Previous (randomized) algorithms for reconstruction of ROFs imply that there exists a randomized algorithm for the ROT problem.

Interpolating Arithmetic Read-Once Formulas in Parallel

A formula is read-once if each variable appears in it at most once. An arithmetic 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 3(n2+3n-2), our algorithm runs in $O(\log^2 n)$ parallel steps using O(n4) processors (where the field operations are charged unit cost). This complements some results from [N. H. Bshouty and R. Cleve, Proc. 33rd Annual Symposium on the Foundations of Computer Science, IEEE Computer Science Press, Los Alamitos, CA, 1992, pp. 24--27] which imply that other classes of read-once formulas cannot be interpolated---or even learned with membership and equivalence queries---in polylogarithmic 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).

On Interpolating Arithmetic Read-Once Formulas with Exponentiation

A formula is a read-once formula if each variable appears at most once in it. An arithmetic read-once formula (AROF) with exponentiation is one in which the operations are addition, substraction, multiplication, division and exponentiation to an arbitrary integer. We present a polynomial time algorithm for interpolating AROF withexponentiationusing randomized substitutions. Interpolating AROF without exponentiation is studied in (Bshouty, Hancock, and Hellerstein,SIAM J. Comput.24, No. 4, 1995). To add the exponentiation operation to the basis we develop a new technique.

Learning Arithmetic Read-Once Formulas

A formula is read-once if each variable appears at most once in it. An arithmetic read-once formula is one in which the operators are addition, subtraction, multiplication, and division. We present polynomial time algorithms for exact learning of arithmetic read-once formulas over a field. We present a membership and equivalence query algorithm that identifies arithmetic read-once formulas over an arbitrary field. We present a randomized membership query algorithm (i.e., a randomized black box interpolation algorithm) that identifies such formulas over finite fields with at least $2n + 5$ elements (where n is the number of variables) and over infinite fields. We also show the existence of nonuniform deterministic membership query algorithms for arbitrary read-once formulas over fields of characteristic 0, and division-free read-once formulas over fields that have at least $2n^{3} + 1$ elements. For our algorithms, we assume we are able to perform efficiently arithmetic operations on field elements and compute square roots in the field. It is shown that the ability to compute square roots is necessary in the sense that the problem of computing $n - 1$ square roots in a field can be reduced to the problem of identifying an arithmetic formula over n variables in that field. Our equivalence queries are of a slightly nonstandard form, in which counterexamples are required not to be inputs on which the formula evaluates to $0/0$. This assumption is shown to be necessary for fields of size $o(n/ \log n)$ in the sense that we prove there exists no polynomial time identification algorithm that uses only membership and standard equivalence queries.