Submitted by : Estrella Eisenberg Yair Kaufman Ohad Lipsky Riva Gonen Shalom

P/Poly P/Poly is the class of Turing machines that accept external “advice” in computation. Formally - L  P/Poly if there exists a polynomial time two- input machine M and a sequence {a n } of “advice” strings |a n |  p(n) s.t

An alternative definition: For L in P/Poly there is a sequence of circuits {C n }, where C n has n inputs and 1 output, its size is bounded by p(n), and: This is called a non-uniform family of circuits.

There is not necessarily a connection between the different circuits.

Proof:  Circuit  TM with advice: – – There exists a family of circuits {Cn} deciding L and |C n | is poly- bounded. –Given an input x, use a standard circuit encoding for C |x| as advice. –The TM simulates the circuit and accepts/rejects accordingly. Theorem:P/Poly definitions equivalence

 TM with advice  circuit: –Similar to proof of Cook’s theorem build from M(a n,) a circuit which for input x of length n outputs M(a n,x). – – There exists a TM taking advice {a n }. –By running over all n’s a family of circuits is created from the advice strings.

Using P/Poly to decide P=NP Claim: P  P/poly - just use an empty advice. If we find a language L  NP and L  P/Poly then we prove P  NP. P/Poly and NP both use an external string for computation. How are they different?

The different between P/poly & NP a n 1.For a given n, P/poly has a universal witness a n as opposed to NP where every x of length n may have a different witness. 2.In NP, for every x  L, for every witness w M(x,w)=0. This is not true for P/poly. 3.P/poly=co-P/poly, but we do not know if NP=co-NP.

The power of P/Poly Theorem: BPP  P/Poly Proof: By simple amplification on BPP we get that for any x  {0,1} n, the probability for M to incorrectly decide x is < 2 -n. Reminder: In BPP, the computation uses a series r of poly(n) coin tosses.

P/poly includes non-recursive languages Example: All unary languages (subsets of {1}*) are in P/Poly - the advice string can be exactly  L (1 n ) and the machine checks if the input is unary.

There are non-recursive unary languages: Take {1 index(1) | x  L} where L is non-recursive.

Sparse Languages & Question Definition: A language S is sparse if there exists a polynomial p(.) such that for every n, |S  {0,1} n |  p(n) Theorem: NP  P/Poly for every L  NP, L is Cook reducible to a sparse language.

In other words a language is sparse when there is a “small” number of words in each length, p(n) words of length n. Example: Every unary language is sparse (p(n)=1)

Proof: It is enough to prove that SAT  P/Poly  SAT is Cook reducible to a sparse language. By P/Poly definition, SAT  P/Poly says that there exists a series of advice strings {a n } s.t.  n |a n |  q(n). q(.)  Poly and a polynomial Turing Machine M s.t. M( ,a n )=χ SAT (  ). Definition: S i n =0 i-1 10 q(n)-I S = {1 n 0S i n | n>0 where bit i of a n is 1} S is sparse since for every n |S  {0,1} n+q(n)+1 |  |a n |  q(n)

S is a list that have an element for each ‘1’ in the advices. For each length we have maximum of all 1’s, so we’ll get |a n | elements of length n+q(n)+1.

Cook-Reduction of SAT to S: Input:  of length n Reconstruct a n by q(n) queries to S. [The queries are: 1 n 0S i n for 1  i  q(n)]. Run M( ,a n ) thereby solving SAT in polynomial time. We solved SAT with a polynomial number of queries to an S-oracle means that it is Cook-reducible to the sparse language S.

Reconstruction is done bit by bit. if 1 n 0S i n  S then bit i of a n is 1.

[SAT  P/Poly  SAT is Cook reducible to a sparse language.]  In order to prove that SAT  P/Poly we will construct a series of advice strings {a n } and a deterministic polynomial time M that solves SAT using {a n }. SAT is Cook-reducible to sparse language S. Therefore, there exists an oracle machine M S which solves SAT in polynomial time t(.).   M S makes at most t(|  |) oracle queries of size t(|  |).

Construct a n by concatenating all strings of length t(|  |) in S. S is sparse  There exists p(.)  Poly s.t.  n |S  {0,1} n |  p(n). For every i there are at most p(i) elements of length i in S  |a n |  so a n is polynomial in length. Now, given a n the oracle queries will be simulated by scanning a n. M will act as same as M S except that the oracle queries will be answered by a n. M is a deterministic polynomial time machine that using a n solves SAT, therefore SAT  P/Poly. 

P=NP using the Karp-reduction Theorem P=NP iff for every language L  NP, L is Karp-reducible to a sparse language. Proof: (  ) P=NP  Any L in NP is Karp-reducible to a sparse language. L  NP, we reduce it (Karp reduction) to {1} using the function :

{1} is obviously a sparse language. The reduction function f is polynomial, since it computes x  L. L  NP and we assume that P = NP, so computing L takes polynomial time. The reduction is correct because x  L iff f(x)  {1}

(  ) SAT is Karp-reducible to a sparse language  P=NP We prove a weaker claim ( even though this claim holds) SAT is Karp-reducible to a guarded sparse language  P=NP Definition : A sparse language S is guarded if there exists a sparse language G, such that S  G and G is in P. For example, S= {1 n 0s n i | n >0,where bit i of a n is 1} is guarded sparse by G= {1 n 0s n i | n >0 and 0<i<=q(n) }.

Obviously, we can prove the theorem for SAT instead of proving it for every L in NP. (SAT is NP-complete)

As Claimed, we have a Karp reduction from SAT to a guarded sparse language S by f. Input: A boolean formula  =  (x 1,…,x n ). We build the assignment tree of  by assigning at each level another variable both ways (0,1). Each node is labeled by its assignment. Thus the leaves are labeled with n-bit string of all possible assignments to .

the leaves have a full assignment, thus a boolean constant value.

The tree assignment  1 =  (1,x 2,…,x n )  0 =  (0,x 2,…,x n )

We will solve  by DFS search on the tree using branch and bound. The algorithm will backtrack from a node only if there is no satisfying assignment in its entire subtree. At each node  it will calculate x .: S is the guarded sparse language of the reduction and G is the polynomial sparse language which S is guarded by. We also define :B  G – S.

x  is computed in polynomial time because Karp reduction is polynomial time reduction. B is well defined since S  G.

Algorithm: Input  =  (x 1, …,x n ). 1. B =  2. Tree-Search( ) 3. In case the above call was not halted, reject  as non satisfiable.

At first B is empty, we have no information on the part of S in G. We call the procedure Tree-Search for the first time with the empty assignment.

Tree-Search (  ) if |  |=n //we’ve reached a leaf  a full assignment if    True then output the assignment  and halt. else return. if |  | < n a.compute x  =f(   ) b.if x   G then return // x   G (  x   S     SAT) c.if x   B then return //x   B (  x   G-S     SAT) d.Tree-Search(  1) e.if x   G add x  to B //We backtracked from both sons f.Tree-Search(  0) g.return

x   G Can be computed in poly-time because G is in P. We backtrack (return in the recursion) when we know that x   S [ x   B or x   G ] hence there is no assignment that starts with the partial assignment , so there is no use expanding and building this assignment. If we backtrack from both sons of  we add x  to the set B  G - S

Correctness If  is satisfiable we will find some satisfying assignment, since for all nodes  on the path from the root to a leaf x   S and we continue developing its sons. When finding an assignment it is first checked to give TRUE and only then returned. The algorithm returns “no” if it has not found a satisfying assignment and has backtracked from all possible sons.

Complexity analysis: If we visit a number of nodes equal to the number of strings in G, the algorithm is polynomial, due to G’s sparseness. It is needed to show that only a polynomial part of the tree is developed. Claim: Let  and  be different nodes in the tree such that neither is an ancestor of the other and x  = x . Then it is not possible that the sons of both nodes were developed.

To prevent developing a certain part of the tree that does not lead to a truth assignment over and over by different x  s, we maintain the set B which keeps x  from which we have backtracked.We do not develop a node whose x is in B.

Proof: W.l.o.g. we assume that we reach  before . Since  is not an ancestor of , we arrive at  after backtracking from . If x   G then x   G since x  = x  and we will not develop them both. Otherwise, after backtracking from , x   B thus x   B so we will not develop its sons.

Last point : Only polynomial part of the tree is developed. Proof : G is sparse thus at each level of the tree there are at most p(n) different  such that x   G, moreover every two different nodes on this level are not ancestors of each other. Therefore by the previous claim the number of x  developed from this level is bounded by p(n).  The overall number of nodes developed is bounded by n p(n).

Each level of the tree represents a different number of variable needed to be assigned in the formula. In this length there are polynomial number of items belonging to G since it is a sparse language.

We have shown that with this algorithm, knowing that SAT is Karp reducible to a guarded sparse language, we can solve SAT in polynomial time  SAT  P  P=NP