63 research outputs found
Identity Testing and Lower Bounds for Read-k Oblivious Algebraic Branching Programs
Read-k oblivious algebraic branching programs are a natural generalization of the well-studied model of read-once oblivious algebraic branching program (ROABPs). In this work, we give an exponential lower bound of exp(n/k^{O(k)}) on the width of any read-k oblivious ABP computing some explicit multilinear polynomial f that is computed by a polynomial size depth-3 circuit. We also study the polynomial identity testing (PIT) problem for this model and obtain a white-box subexponential-time PIT algorithm. The algorithm runs in time 2^{~O(n^{1-1/2^{k-1}})} and needs white box access only to know the order in which the variables appear in the ABP
Pseudorandom Bits for Oblivious Branching Programs
We construct a pseudorandom generator that fools known-order read-k oblivious branching programs and, more generally, any linear length oblivious branching program. For polynomial width branching programs, the seed lengths in our constructions are O(n^(1−1/2^(k−1))) (for the read-k case) and O(n/log log n) (for the linear length case). Previously, the best construction for these models required seed length (1 − Ω(1))n
Progress on Polynomial Identity Testing - II
We survey the area of algebraic complexity theory; with the focus being on
the problem of polynomial identity testing (PIT). We discuss the key ideas that
have gone into the results of the last few years.Comment: 17 pages, 1 figure, surve
Identity Testing for Constant-Width, and Commutative, Read-Once Oblivious ABPs
We give improved hitting-sets for two special cases of Read-once Oblivious Arithmetic Branching Programs (ROABP). First is the case of an ROABP with known variable order. The best hitting-set known for this case had cost (nw)^{O(log(n))}, where n is the number of variables and w is the width of the ROABP. Even for a constant-width ROABP, nothing better than a quasi-polynomial bound was known. We improve the hitting-set complexity for the known-order case to n^{O(log(w))}. In particular, this gives the first polynomial time hitting-set for constant-width ROABP (known-order). However, our hitting-set works only over those fields whose characteristic is zero or large enough. To construct the hitting-set, we use the concept of the rank of partial derivative matrix. Unlike previous approaches whose starting point is a monomial map, we use a polynomial map directly.
The second case we consider is that of commutative ROABP. The best known hitting-set for this case had cost d^{O(log(w))}(nw)^{O(log(log(w)))}, where d is the individual degree. We improve this hitting-set complexity to (ndw)^{O(log(log(w)))}. We get this by achieving rank concentration more efficiently
Deterministic Black-Box Identity Testing -Ordered Algebraic Branching Programs
In this paper we study algebraic branching programs (ABPs) with restrictions
on the order and the number of reads of variables in the program. Given a
permutation of variables, for a -ordered ABP (-OABP), for
any directed path from source to sink, a variable can appear at most once
on , and the order in which variables appear on must respect . An
ABP is said to be of read , if any variable appears at most times in
. Our main result pertains to the identity testing problem. Over any field
and in the black-box model, i.e. given only query access to the polynomial,
we have the following result: read -OABP computable polynomials can be
tested in \DTIME[2^{O(r\log r \cdot \log^2 n \log\log n)}].
Our next set of results investigates the computational limitations of OABPs.
It is shown that any OABP computing the determinant or permanent requires size
and read . We give a multilinear polynomial
in variables over some specifically selected field , such that
any OABP computing must read some variable at least times. We show
that the elementary symmetric polynomial of degree in variables can be
computed by a size read OABP, but not by a read OABP, for
any . Finally, we give an example of a polynomial and two
variables orders , such that can be computed by a read-once
-OABP, but where any -OABP computing must read some variable at
least $2^n
Matrix PRFs: Constructions, Attacks, and Applications to Obfuscation
We initiate a systematic study of pseudorandom functions (PRFs) that are
computable by simple matrix branching programs; we refer to these objects as
“matrix PRFs”. Matrix PRFs are attractive due to their simplicity, strong
connections to complexity theory and group theory, and recent applications in
program obfuscation.
Our main results are:
* We present constructions of matrix PRFs based on the conjectured hardness of
some simple computational problems pertaining to matrix products.
* We show that any matrix PRF that is computable by a read-c, width w
branching program can be broken in time poly(w^c); this means that any matrix
PRF based on constant-width matrices must read each input bit omega(log
lambda) times. Along the way, we simplify the “tensor switching lemmas”
introduced in previous IO attacks.
* We show that a subclass of the candidate local-PRG proposed by Barak et al.
[Eurocrypt 2018] can be broken using simple matrix algebra.
* We show that augmenting the CVW18 IO candidate with a matrix PRF provably
immunizes the candidate against all known algebraic and statistical zeroizing
attacks, as captured by a new and simple adversarial model
- …