Neither reading few bits twice nor reading illegally helps much

We first consider so-called (1, +s)-branching programs in which along every consistent path at most s variables are tested more than once. We prove that any such program computing a characteristic function of a linear code C has size at least 2 Ω(min{d 1, d 2/s}), where d1 and d 2 are the minimal distances of C and its dual C ⊥. We apply this criterion to explicit linear codes and obtain a super-polynomial lower bound for s = o(n / log n). Then we introduce a natural generalization of read-k-times and (1, +s)-branching programs that we call semantic branching programs. These programs correspond to corrupting Turing machines which, unlike eraser machines, are allowed to read input bits even illegally, i.e. in excess of their quota on multiple readings, but in that case they receive in response an unpredictably corrupted value. We generalize the above-mentioned bound to the semantic case, and also prove exponential lower bounds for semantic read-once nondeterministic branching programs

Neither Reading Few Bits Twice nor Reading Illegally Helps Much

We first consider so-called (1; +s)-branching programs in which along every consistent path at most s variables are tested more than once. We prove that any such program computing a characteristic function of a linear code C has size at least 2\Omega\Gamma2/1 fd 1 ; d 2 =sg) , where d 1 and d 2 are the minimal distances of C and its dual C ? : We apply this criterion to explicit linear codes and obtain a super-polynomial lower bound for s = o(n= log n): Then we introduce a natural generalization of read-k-times and (1; +s)- branching programs that we call semantic branching programs. These programs correspond to corrupting Turing machines which, unlike eraser machines, are allowed to read input bits even illegally, i.e. in excess of their quota on multiple readings, but in that case they receive in response an unpredictably corrupted value. We generalize the above-mentioned bound to the semantic case, and also prove exponential lower bounds for semantic read-once nondeterministic..

A lower bound on branching programs reading some bits twice

AbstractBy (1, + k(n))-branching programs (b.p.'s) we mean those b.p.'s which during each of their computations are allowed to test at most k(n) input bits repeatedly. For a Boolean function computable within polynomial time a trade-off is presented between the size and the number of repeatedly tested input bits of any b.p. P computing the function. Namely, if at most k(n) repeated tests are allowed, where log2 n ⩽ k(n) ⩽ n(1000 log2 n), then the size of P is at least exp(Ω(n(k(n)log2 n))12). This is exponential whenever k(n) ⩽ nα for a fixed α < 1 and superpolynomial whenever k(n) = o(nlog32 n).The presented result is a step towards a superpolynomial lower bound for 2-b.p.'s which is an open problem since 1984 when the first superpolynomial lower bounds for 1-b.p.'s were proven (Wegener, 1988; Žák, 1984). The present result is an improvement on (Žák, 1995)

Yet harder knapsack problems

AbstractAlready 30 years ago, Chvátal has shown that some instances of the zero-one knapsack problem cannot be solved in polynomial time using a particular type of branch-and-bound algorithms based on relaxations of linear programs together with some rudimentary cutting-plane arguments as bounding rules. We extend this result by proving an exponential lower bound in a more general class of branch-and-bound and dynamic programming algorithms which are allowed to use memoization and arbitrarily powerful bound rules to detect and remove subproblems leading to no optimal solution

On uncertainty versus size in branching programs

AbstractWe propose an information-theoretic approach to proving lower bounds on the size of branching programs. The argument is based on Kraft type inequalities for the average amount of uncertainty about (or entropy of) a given input during the various stages of computation. The uncertainty is measured by the average depth of so-called ‘splitting trees’ for sets of inputs reaching particular nodes of the program.We first demonstrate the approach for read-once branching programs. Then, we introduce a strictly larger class of so-called ‘balanced’ branching programs and, using the suggested approach, prove that some explicit Boolean functions cannot be computed by balanced programs of polynomial size. These lower bounds are new since some explicit functions, which are known to be hard for most previously considered restricted classes of branching programs, can be easily computed by balanced branching programs of polynomial size