60 research outputs found
(The) political career of Elisha Cooke, Jr., 1715-1737.
Typewritten sheets in cover.
Thesis (M.A.)--Boston University
This item was digitized by the Internet Archive
Pseudorandom Linear Codes are List Decodable to Capacity
We introduce a novel family of expander-based error correcting codes. These
codes can be sampled with randomness linear in the block-length, and achieve
list-decoding capacity (among other local properties). Our expander-based codes
can be made starting from any family of sufficiently low-bias codes, and as a
consequence, we give the first construction of a family of algebraic codes that
can be sampled with linear randomness and achieve list-decoding capacity. We
achieve this by introducing the notion of a pseudorandom puncturing of a code,
where we select indices of a base code via an
expander random walk on a graph on . Concretely, whereas a random linear
code (i.e. a truly random puncturing of the Hadamard code) requires
random bits to sample, we sample a pseudorandom linear code with random
bits. We show that pseudorandom puncturings satisfy several desirable
properties exhibited by truly random puncturings. In particular, we extend a
result of (Guruswami Mosheiff FOCS 2022) and show that a pseudorandom
puncturing of a small-bias code satisfies the same local properties as a random
linear code with high probability. As a further application of our techniques,
we also show that pseudorandom puncturings of Reed Solomon codes are
list-recoverable beyond the Johnson bound, extending a result of (Lund
Potukuchi RANDOM 2020). We do this by instead analyzing properties of codes
with large distance, and show that pseudorandom puncturings still work well in
this regime.Comment: Fixed author nam
Certified Hardness vs. Randomness for Log-Space
Let be a language that can be decided in linear space and let
be any constant. Let be the exponential hardness
assumption that for every , membership in for inputs of
length~ cannot be decided by circuits of size smaller than .
We prove that for every function , computable
by a randomized logspace algorithm , there exists a deterministic logspace
algorithm (attempting to compute ), such that on every input of
length , the algorithm outputs one of the following:
1: The correct value .
2: The string: ``I am unable to compute because the hardness
assumption is false'', followed by a (provenly correct) circuit
of size smaller than for membership in for
inputs of length~, for some ; that is, a circuit that
refutes .
Our next result is a universal derandomizer for : We give a
deterministic algorithm that takes as an input a randomized logspace
algorithm and an input and simulates the computation of on ,
deteriministically. Under the widely believed assumption , the space
used by is at most (where is a constant depending
on~). Moreover, for every constant , if then the space used by is at most .
Finally, we prove that if optimal hitting sets for ordered branching programs
exist then there is a deterministic logspace algorithm that, given a black-box
access to an ordered branching program of size , estimates the
probability that accepts on a uniformly random input. This extends the
result of (Cheng and Hoza CCC 2020), who proved that an optimal hitting set
implies a white-box two-sided derandomization.Comment: Abstract shortened to fit arXiv requirement
Local Access to Random Walks
For a graph G on n vertices, naively sampling the position of a random walk of at time t requires work ?(t). We desire local access algorithms supporting position_G(t) queries, which return the position of a random walk from some fixed start vertex s at time t, where the joint distribution of returned positions is 1/poly(n) close to those of a uniformly random walk in ?? distance.
We first give an algorithm for local access to random walks on a given undirected d-regular graph with O?(1/(1-?)?n) runtime per query, where ? is the second-largest eigenvalue of the random walk matrix of the graph in absolute value. Since random d-regular graphs G(n,d) are expanders with high probability, this gives an O?(?n) algorithm for a graph drawn from G(n,d) whp, which improves on the naive method for small numbers of queries.
We then prove that no algorithm with subconstant error given probe access to an input d-regular graph can have runtime better than ?(?n/log(n)) per query in expectation when the input graph is drawn from G(n,d), obtaining a nearly matching lower bound. We further show an ?(n^{1/4}) runtime per query lower bound even with an oblivious adversary (i.e. when the query sequence is fixed in advance).
We then show that for families of graphs with additional group theoretic structure, dramatically better results can be achieved. We give local access to walks on small-degree abelian Cayley graphs, including cycles and hypercubes, with runtime polylog(n) per query. This also allows for efficient local access to walks on polylog degree expanders. We show that our techniques apply to graphs with high degree by extending or results to graphs constructed using the tensor product (giving fast local access to walks on degree n^? graphs for any ? ? (0,1]) and Cartesian product
Fourier Growth of Regular Branching Programs
We analyze the Fourier growth, i.e. the L? Fourier weight at level k (denoted L_{1,k}), of read-once regular branching programs. We prove that every read-once regular branching program B of width w ? [1,?] with s accepting states on n-bit inputs must have its L_{1,k} bounded by min{Pr[B(U_n) = 1](w-1)^k, s ? O((n log n)/k)^{(k-1)/2}}. For any constant k, our result is tight up to constant factors for the AND function on w-1 bits, and is tight up to polylogarithmic factors for unbounded width programs. In particular, for k = 1 we have L_{1,1}(B) ? s, with no dependence on the width w of the program.
Our result gives new bounds on the coin problem and new pseudorandom generators (PRGs). Furthermore, we obtain an explicit generator for unordered permutation branching programs of unbounded width with a constant factor stretch, where no PRG was previously known.
Applying a composition theorem of B?asiok, Ivanov, Jin, Lee, Servedio and Viola (RANDOM 2021), we extend our results to "generalized group products," a generalization of modular sums and product tests
On the Power of Regular and Permutation Branching Programs
We give new upper and lower bounds on the power of several restricted classes of arbitrary-order read-once branching programs (ROBPs) and standard-order ROBPs (SOBPs) that have received significant attention in the literature on pseudorandomness for space-bounded computation.
- Regular SOBPs of length n and width ?w(n+1)/2? can exactly simulate general SOBPs of length n and width w, and moreover an n/2-o(n) blow-up in width is necessary for such a simulation. Our result extends and simplifies prior average-case simulations (Reingold, Trevisan, and Vadhan (STOC 2006), Bogdanov, Hoza, Prakriya, and Pyne (CCC 2022)), in particular implying that weighted pseudorandom generators (Braverman, Cohen, and Garg (SICOMP 2020)) for regular SOBPs of width poly(n) or larger automatically extend to general SOBPs. Furthermore, our simulation also extends to general (even read-many) oblivious branching programs.
- There exist natural functions computable by regular SOBPs of constant width that are average-case hard for permutation SOBPs of exponential width. Indeed, we show that Inner-Product mod 2 is average-case hard for arbitrary-order permutation ROBPs of exponential width.
- There exist functions computable by constant-width arbitrary-order permutation ROBPs that are worst-case hard for exponential-width SOBPs.
- Read-twice permutation branching programs of subexponential width can simulate polynomial-width arbitrary-order ROBPs
Improved Local Computation Algorithms for Constructing Spanners
A spanner of a graph is a subgraph that preserves lengths of shortest paths
up to a multiplicative distortion. For every , a spanner with size
and stretch can be constructed by a simple centralized
greedy algorithm, and this is tight assuming Erd\H{o}s girth conjecture.
In this paper we study the problem of constructing spanners in a local
manner, specifically in the Local Computation Model proposed by Rubinfeld et
al. (ICS 2011).
We provide a randomized Local Computation Agorithm (LCA) for constructing
-spanners with edges and probe complexity of
for , where denotes the number of
vertices in the input graph. Up to polylogarithmic factors, in both cases, the
stretch factor is optimal (for the respective number of edges). In addition,
our probe complexity for , i.e., for constructing a -spanner, is
optimal up to polylogarithmic factors. Our result improves over the probe
complexity of Parter et al. (ITCS 2019) that is for . Both our algorithms and the algorithms of Parter et al. use a
combination of neighbor-probes and pair-probes in the above-mentioned LCAs.
For general , we provide an LCA for constructing -spanners
with edges using neighbor-probes,
improving over the algorithm of Parter et al.
By developing a new randomized LCA for graph decomposition, we further
improve the probe complexity of the latter task to be
, for any constant . This latter
LCA may be of independent interest.Comment: RANDOM 202
- …