Submitted by Estrella Eisenberg Yair Kaufman Ohad Lipsky

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

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

3

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

There is not necessarily a connection between the different circuits. 5

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

7

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

9

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? 10

The different between P/poly & NP 1. For a given n, P/poly has a universal witness an 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. 11

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. 12

13

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. 14

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

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. 16

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) 17

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 {an} s. t. n |an| q(n). q(. ) Poly and a polynomial Turing Machine M s. t. M( , an)=χSAT( ). Definition: Sin=0 i-110 q(n)-I S = {1 n 0 Sin | n>0 where bit i of an is 1} S is sparse since for every n |S {0, 1}n+q(n)+1| |an| q(n) 18

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 |an| elements of length n+q(n)+1. 19

Cook-Reduction of SAT to S: Input: of length n Reconstruct an by q(n) queries to S. [The queries are: 1 n 0 Sin for 1 i q(n)]. Run M( , an) 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. 20

Reconstruction is done bit by bit. if 1 n 0 Sin S then bit i of an is 1. 21

[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 {an} and a deterministic polynomial time M that solves SAT using {an}. SAT is Cook-reducible to sparse language S. Therefore, there exists an oracle machine MS which solves SAT in polynomial time t(. ). MS makes at most t(| |) oracle queries of size t(| |). 22

23

Construct an 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 at most p(i) elements of length i in S |an| so an is polynomial in length. Now, given an the oracle queries will be simulated by scanning an. M will act as same as MS except that the oracle queries will be answered by an. M is a deterministic polynomial time machine that using an solves SAT, therefore SAT P/Poly. 24

25

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 : 26

{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} 27

( ) 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 0 sni | n >0, where bit i of an is 1} is guarded sparse by G= {1 n 0 sni | n >0 and 0<i<=q(n) }. 28

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

As Claimed, we have a Karp reduction from SAT to a guarded sparse language S by f. Input: A boolean formula = (x 1, …, xn). 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 . 30

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

The tree assignment 0= (0, x 2, …, xn) 00 1 0 01 10 1= (1, x 2, …, xn) 11 32

33

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. 34

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

Algorithm: Input = (x 1 , …, xn). l B= l Tree-Search( ) l In case the above call was not halted, reject as non satisfiable. 36

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. 37

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 38

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 39

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. 40

41

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. 42

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. 43

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. 44

45

Last point : Only polynomial part of the tree is developed. Proof : G is sparse thus at each level of the tree there 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). 46

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. 47

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 48

49