14 research outputs found
The Space Complexity of Mirror Games
We consider the following game between two players Alice and Bob, which we call the mirror game. Alice and Bob take turns saying numbers belonging to the set {1, 2, ...,N}. A player loses if they repeat a number that has already been said. Otherwise, after N turns, when all the numbers have been spoken, both players win. When N is even, Bob, who goes second, has a very simple (and memoryless) strategy to avoid losing: whenever Alice says x, respond with N+1-x. The question is: does Alice have a similarly simple strategy to win that avoids remembering all the numbers said by Bob?
The answer is no. We prove a linear lower bound on the space complexity of any deterministic winning strategy of Alice. Interestingly, this follows as a consequence of the Eventown-Oddtown theorem from extremal combinatorics. We additionally demonstrate a randomized strategy for Alice that wins with high probability that requires only O~(sqrt N) space (provided that Alice has access to a random matching on K_N).
We also investigate lower bounds for a generalized mirror game where Alice and Bob alternate saying 1 number and b numbers each turn (respectively). When 1+b is a prime, our linear lower bounds continue to hold, but when 1+b is composite, we show that the existence of a o(N) space strategy for Bob (when N != 0 mod (1+b)) implies the existence of exponential-sized matching vector families over Z^N_{1+b}
Faster space-efficient algorithms for Subset Sum, k -Sum, and related problems
We present randomized algorithms that solve subset sum and knapsack instances with n items in O∗ (20.86n) time, where the O∗ (∙ ) notation suppresses factors polynomial in the input size, and polynomial space, assuming random read-only access to exponentially many random bits. These results can be extended to solve binary integer programming on n variables with few constraints in a similar running time. We also show that for any constant k ≥ 2, random instances of k-Sum can be solved using O(nk -0.5polylog(n)) time and O(log n) space, without the assumption of random access to random bits.Underlying these results is an algorithm that determines whether two given lists of length n with integers bounded by a polynomial in n share a common value. Assuming random read-only access to random bits, we show that this problem can be solved using O(log n) space significantly faster than the trivial O(n2) time algorithm if no value occurs too often in the same list.</p
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
Faster Space-Efficient Algorithms for Subset Sum, k-Sum and Related Problems
We present space efficient Monte Carlo algorithms that solve Subset Sum and Knapsack instances with items using time and polynomial space, where the notation suppresses factors polynomial in the input size. Both algorithms assume random read-only access to random bits. Modulo this mild assumption, this resolves a long-standing open problem in exact algorithms for NP-hard problems. These results can be extended to solve Binary Linear Programming on variables with few constraints in a similar running time. We also show that for any constant , random instances of -Sum can be solved using time and space, without the assumption of random access to random bits. Underlying these results is an algorithm that determines whether two given lists of length with integers bounded by a polynomial in share a common value. Assuming random read-only access to random bits, we show that this problem can be solved using space significantly faster than the trivial time algorithm if no value occurs too often in the same list
On Read-Once vs. Multiple Access to Randomness in Logspace
In the "correct" definition of randomized space-bounded computation, the machine has access to a random coin. The coin can be flipped at will, but outcomes of previous coin flips cannot be recalled unless they are saved in the machine's limited memory. In contrast to this read-once mechanism of accessing the random source, one may consider Turing machines which have access to a random tape. Here, the random bits may be multiply accessed by the machine. In this note we show a very concrete sense in which multiple access to the random bits is better than read-once access to them: Every language accepted with bounded 2-sided error by a read-once-randomized Logspace machine, can be accepted with zero error by a randomized Logspace machine having multiple access to the random bits. Finally we characterize the class of languages that can be accepted with two-sided error by randomized Logspace machines with multiple access to the random bits as exactly the class of languages tha..
Typically-Correct Derandomization for Small Time and Space
Suppose a language L can be decided by a bounded-error randomized algorithm that runs in space S and time n * poly(S). We give a randomized algorithm for L that still runs in space O(S) and time n * poly(S) that uses only O(S) random bits; our algorithm has a low failure probability on all but a negligible fraction of inputs of each length. As an immediate corollary, there is a deterministic algorithm for L that runs in space O(S) and succeeds on all but a negligible fraction of inputs of each length. We also give several other complexity-theoretic applications of our technique