Outline

• Meyer's Theorem
• Shannon's Theorem
• Size Hierarchy
• Classes within P/poly
• In-Class Exercise

Meyer's Theorem

Theorem (K-L 80). If `EXP subseteq P``/poly` then `EXP = Sigma_2^p`.

Remark. The result is in Karp-Lipton 1980, but attributed to Albert R. Meyer. This theorem actually served as one of the inspirations behind the result (2010) of Williams that `A \C \C` does not contain `NEXP`.

Proof. Let `L in EXP`. Then `L` is computable by a `2^(p(n))` time oblivious TM `M` where p is some polynomial. Let `x in {0, 1}^n` be some input string. For every `i in [2^(p(n))]` we denote by `z_i` the encoding of the `i`th snapshot of `M`'s execution on `x`. If `M` has `k` tapes, then there are at most k+1 distinct last previous times where the tape head of at least one of tapes was in the same position as in time `i`. Denote these `i`, `i_1`, ..., `i_k`. Now `x in L` iff for every `k+1` indices `i`, `i_1`, ..., `i_k`, the snapshots `z_i`, `z_(i_1)`, ..., `z_(i_k)` satisfy some easily checkable criteria: If `z_i` is the last snapshot, then it should encode `M` outputting `1`, and if `i_1`, .., `i_k` are the last indices where `M`'s heads were in the same locations as in `i`, then the values in `z_i` should be consistent with the values in the `z_(i_j)`'s. As `L in EXP` we can certainly compute given a time `j` less than the runtime of `M` the bits of `z_j` in `EXP`. So if `EXP subseteq P``/poly` then there is a `q(n)`-sized circuit `C` that computes `z_j` from `j`. The correctness of this transcript can be computed by a `coNP` machine (one that checks that the transcript satisfies all local criteria). Hence `x in L` iff
`exists C in {0,1}^(q(n))forall i, i_1, ..., i_k in {0, 1}^{p(n)} T(x, C(i), C(i_1), ... C(i_k)) = 1`.
where `T` is some p-time TM checking these conditions. Hence `L in Sigma_2^p`.

Corollary. If `P=NP`, then `EXP` is not contained in `P``/poly`.

Proof. `P=NP` implies `P=Sigma_2^p`. But `P != EXP` by the deterministic time hierarchy theorem.

A Counting Argument

Theorem (Shannon 1949). For any `n ge 2` there is an n-ary Boolean function `f` such that no Boolean circuit with `2^n/(2n)` or fewer gates can compute it.

Proof. We know there are `2^(2^n)` n-ary boolean functions. Let `m = 2^n/(2n)`. Let's get an upper bound on how many circuits there are with at most this many gates. For each gate in such a circuit we have at most `(n+5)` choices for the gate type and at most `m^2` choices for the gate inputs. As there are at most `m` gates in the circuit, we get at most `((n+5)m^2)^m` possible circuits of size `m`. Let's compare this with `2^(2^n)` by taking the `log` of both functions and recalling `m= 2^n/(2n)`. The `log` of the number of n-ary Boolean functions is `2^n`, on the hand the `log` of the number of circuits is `2^n [1- (log([4n^2/(n+5)]))/(2n)]`. So some function must have been missed.

Remark. (Lupanov 1958) gets an almost matching upper bound by showing any boolean function can be represented by a depth 4 circuit of size `(2^n)/n + o(2^n/n)`. (See Wegener 87 for proof). Upper and lower bounds of this kind for various variants of circuits such as monotone circuits, circuits without negation, are known as the "Shannon Effect".

Size Hierarchy

Theorem. For every functions `T`, `T': NN -> NN` with `2^n/n > T'(n) > 10T(n) > n`,
`SIZE(T(n)) stackrel(subseteq)(ne) SIZE(T'(n))`.

Proof. More general results of this kind proven via diagonalization can be found in Pollett 2005. To show the idea, we prove that `SIZE(n) stackrel(subseteq)(ne) SIZE(n^2)`. By the Shannon's Theorem for every `l` there is a function `f:{0,1}^l -> {0,1}` that is not computable by `2^l/(2 \cdot l)` sized circuits. On the other hand, we know every Boolean function from `{0,1}^l` to `{0,1}` is computable by a `2^l 10 cdot l`-sized formula/circuit.

Therefore, if we set `l = 1.1 log n` and let `g:{0,1}^n -> {0,1}` be the function that applies `f` on the first `l` bits of the input, we get
`g in SIZE(2^l 10 cdot l) = SIZE(1.1n^(11) log n) subseteq SIZE(n^2)`
`g !in SIZE(2^l/{2 \cdot l}) =SIZE(n^(1.1)/ (1.1 log n)) supseteq SIZE(n)`.

Separating Complexity Classes - Take 2

• The last slide shows Shannon's counting argument can be used to separate complexity classes.
• So counting arguments join our earlier in the semester repertoire of techniques to separate classes.
• These earlier techniques were: (1) Diagonalization, (2) Closure Properties under Boolean operations such as complement, and (3) Closure under reduction.
• We also saw that we can combine diagonalization with timespace trade-offs to get a lower bound for SAT.

Circuit classes Within P/poly

• The depth of a circuit is the length of the longest directed path from an input node to the output node.
  Definition. For every `d`, a language `L in NC^d` if `L` can be decided by a family of circuits `{C_n}` where `C_n` has poly(n) size and depth `O(log^d n)`. The class `NC` is `cup_(i ge 1) NC^i`.
• NC is short for Nick (Pippenger)'s Class.
• The graph of multiplication, addition, and division of `n`-bit integers can be shown to be in `NC^1`.
• For `d > 1`, one can look at logspace-uniform `NC^d` circuit families. For `d=1`, one needs to look at more restrictive versions of uniformity.
• Uniform `NC` can be shown to capture those algorithms which can be solved with `n^(O(1))` processors in `log^(O(1)) n` time -- one notion of efficiently parallelizible algorithms.

More Circuit classes Within P/poly and Relationships

• We can imagine allowing AND and OR gates to take more than `2` inputs. i.e., being of unbounded fan-in. An unbounded OR outputs 1 if any of its inputs are 1, an unbounded And outputs 1 if all of its inputs are 1.
• The class `AC^d` is defined in the same way as above except allowing circuits unbounded fan-in ORs and ANDs. Here the letters "AC" means alternating circuits.
• The class `AC^d[q]` is defined in the same way as above except allowing circuits unbounded fan-in ORs, ANDs and `MOD_q` gates for some fixed number `q`, say 3. `MOD_q(y_1,...,y_m) =1` iff the number of 1 inputs is divisible by `q`. If we allow `MOD_q` for any `q`, so for example we could have a `MOD_6` and a `MOD_{87}` gate in the same circuit, we call the class `A\C\C^d`.
• The class `TC^d` is defined in the same way except gates compute threshold functions `T_m^k` of `m < n` variables which are 1 iff more than `k` inputs are 1.
• It turns out `NC^d \subseteq AC^d \subseteq AC^d[q]\subseteq A\C\C^d \subseteq TC^d \subseteq NC^{d+1}`. So `cup_k AC^k = AC=AC[q]=A\C\C=TC=NC = cup_k NC^k`.
• It can be shown that parity is not in `AC^0` (Furst, Saks, Sipser, 1984), (Razborov 1987) showed for primes `p` and `q`, `AC^0[q]` does not contain `MOD_p`.
• `NC^1` also corresponds to what can be computed by polynomial size boolean formula families.
• Using the random access TMs of HW1, time classes like DLOGTIME actually make sense. One can show that "DLOGTIME-uniform" `NC^1` is the same as ALOGTIME and this is contained in logspace.

In-Class Exercise - Branching Programs

• Besides circuits, branching program (aka binary decision programs) are another common non-uniform model of computation.
• A branching program is a labeled, directed acyclic graph with at most one node without incoming edges and where all nodes have at most two outgoing edges, where nodes except those without outgoing edges are labeled with the input variables, and where nodes without outgoing edges are labeled with 0 or 1.
• If the branching program's graph is a tree, then it is called a binary decision tree.
• It is legal to have the same variable multiple times in the program, even multiple times along the same path.
• A branching program computes a 0-1 function by following the path from the root node, the node without incoming edges, to either 0 or 1 according to the values assigned to each of the variables.
• The size of a program `f`, denoted, `size(f)`, is the number of nodes in its graph.
• Suppose `f(\vec{x})` and `g(\vec{y})` are functions computed by branching program, show `f(\vec{x}) ^^ g(vec{y})` can be computed by a branching program of size `size(f(\vec{x})) + size(g(\vec{y}))`.
• Post your solution to the Apr 19 In-Class Exercise Thread.

Remarks on Branching Programs

• The class of languages recognized by family of polynomial size branching programs corresponds to `L`/`poly` (Cobham 1966).
• If in the family of program you restrict the number of nodes that are allowed to be at the same distance from the root to a constant (constant-width) for all members of a program, and you don't allow requerying the same variable on a path (read-once), you get a non-uniform model of finite automata.
• Such programs are often used in formal verificaton of protocols and circuits.
• Dropping the read-once condition, for any fixed-width constant restriction greater than or equal to 5, the languages recognized by these "width" restricted programs exactly correspond to `NC^1` (Barrington 1989). His work connects word problems in group theory with computational complexity.