Chapter 5 The Witness Reduction Technique: Feasible Closure Properties of #P Greg Goldstein Andrew Learn 18 April 2001

Outline Introduction Thm: Proper Subtraction and “Closure Completeness” Thm: Complexity Class Collapse Related Results Summary

Closure Concepts Let  be an operation, N x N  N Natural Numbers: –Closure under an operation defined as: (  x  N) (  y  N)[x  y  N] –Closed under addition, multiplication; not subtraction Functions: –Closure similarly defined for a class of functions: (  f 1  F) (  f 2  F)[h f 1,f 2  F] where h f 1,f 2 (n) =  (f 1 (n), f 2 (n)) –e.g. Polynomials closed under addition, subtraction, etc. –We examine another class of functions: #P

#P -- Counting Class for Accepting Paths Defn: f is a #P function if  a NPTM N, s.t. for each input x, f(x) = number of accepting paths of N(x) #P has closure properties –Addition: –Multiplication: f 1 (x) f 2 (x) + f 1 (x) f 2 (x) * N1N1 N1N1 N2N2 N2N2

#P Subtraction Skepticism What about subtraction? –Can’t have # paths < 0 –Consider Proper Subtraction: a b = max{0, a-b} Ponderable: Is #P closed under proper subtraction?? –Witness Reduction Technique: Reducing the number of accepting paths –If we can do this, class hierarchies come crashing down

Our Prove-it Roadmap “Closure Completeness” Theorem –Proper subtraction is “hardest” closure property –If #P is closed under proper subtraction, implies: #P closed under all polynomial-time operations Hierarchy collapse follows “Hierarchy Heroics” Theorem –Given one hierarchy collapse from above, prove a lot of others Related Cases –Other “hardest” closure properties –Other classes of functions

But first, a word from these complexity classes... UP (Unambiguous Polynomial Time): “Unique Paths” –UP = {L |  NPTM N such that L=L(N) and  x, N(x) has at most one accepting path} x  L  One accepting path x  L  Zero accepting paths  P (Parity P): “Odd Paths” –  P = {L |  NPTM N such that x  L  #acc N (x)  0 (mod 2)} x  L  Odd number of accepting paths x  L  Even number of accepting paths

Complexity classes (continued) PP (Probabilistic Polynomial Time): “Probabilistic Plurality” –Probabilistic machines: NPTM with a twist Binary, fully populated computation tree Path is sequence of coin flips -- one path taken, acceptance not guaranteed –L  PP if  PPTM M such that x  L  M(x) accepts with probability  1/2 I.e. number of accepting paths  1/2 of total paths Depth = q(|x|) Total paths = 2 q(|x|), Accepting paths  2 q(|x|)-1

Handwritten slides here for Theorem 5.5 on Closure Completeness

“Hierarchy Heroics” Theorem The following statements are equivalent: –UP = PP –UP = NP = coNP = PH =  P = PP  PP PP  PP PP PP ... Given UP = PP from previous theorem, we explore the hierarchy collapse

Building by Bits... UP = PP = NP = coNP = PH =  P = PP  PP PP  PP PP PP ... –Known facts: UP = PP (from Theorem 1) UP  NP  PP –Proof: Trivially obvious UP = PP = NP = coNP = PH =  P = PP  PP PP  PP PP PP ... –Known facts: PP is closed under complementation –Proof: PP = coPP Since PP = NP, then NP = coNP

Hierarchy Proof (continued) UP = PP = NP = coNP = PH =  P = PP  PP PP  PP PP PP ... –Known facts: PH =  i = P  NP  NP NP  NP NP NP ... –Proof: Because NP = coNP, we can construct a single NPTM with the power of an oracle. Thus NP = NP NP, and we can collapse any size stack of NP NP NP… NANA NANA One of these must accept; thus we get an oracle-type yes/no answer in polynomial time.

Hierarchy Proof (continued) UP = PP = NP = coNP = PH =  P = PP  PP PP  PP PP PP ... –Known facts: P UP  PH –Proof: Since UP = PH, we get P UP  UP It’s also true that UP  P UP because UP oracle decides UP.  P UP = UP (by double-inclusion) We know UP   P  PP  P (1/0 acc. paths  odd/even acc. paths) From Lemma 4.13, we know that PP  P  P PP Putting these together with what we already know, we get: UP   P  PP  P  P PP = P UP = UP  UP =  P = PP  P

Hierarchy Proof (continued) UP = PP = NP = coNP = PH =  P = PP  PP PP  PP PP PP ... –Proof: On last page we showed PP  P = PP Thus we can start with a stack of two PP’s: PP PP = PP  P = PP And thus can collapse any size stack of PP PP PP… !

Related Results Other “hardest” closure properties: Integer Division –Defn: a b =  a/b  Thm: The following statements are equivalent: 1. #P is closed under integer division 2. #P is closed under every polynomial-time computable operation 3. UP = PP   ?

#P Integer Division... (continued) We’re going to prove the integer division case using the Witness Reduction Technique again, similar to proper subtraction. Conceptually, it works like this: 1. Pick an arbitrary PP language 2. Take the corresponding #P function PP 3. Make a tricky pick of another #P function 4. Using assumed closure property, generate a third #P function, for a machine That accepts the same language, but voila!--is in a different class UP L f g h Assumed closure L

#P Integer Division... (continued) Proof: –Part 2 trivially implies Part 1 –Part 3 implies Part 2 from previous proof –Show Part 1 implies Part 3: Let L be any PP set; we seek to show L  UP Because L  PP,  NPTM N and integer k  1 s.t. 1. N(x) has exactly 2 |x| k computation paths, each with |x| k choices (steps) 2. x  L iff N(x) has at least 2 |x| k -1 accepting paths 3. For each x, N(x) has at least one rejecting path q(|x|) |x| k

#P Integer Division... (continued) Let f(x) be the #P function for N. Let g(x) = 2 |x| k -1 be another #P function. By our assumption, h(x) = f(x) g(x) is a #P function. x  Lx  L 2 |x| k - 1  f(x)  2 |x| k -1 2 |x| k -1  f(x) h(x) =  f(x)/g(x)  = 1h(x) =  f(x)/g(x)  = 0 Thus the NPTM defined by h is a UP machine for L!  L  UP  UP = PP max # of accepting paths min #

More Related Results Other complexity classes: OptP and SpanP –OptP Each path considered to have a non-negative output f is an OptP function if f(x) = max of path outputs –SpanP f is a SpanP function if f(x) = number of different path outputs For both classes: –Proper subtraction is a “hardest” closure property –If the class is closed under proper subtraction, some complexity class collapse occurs OptP: NP = coNP SpanP: PP NP = PH = NP

Summary Definitions –#P = functions that count accepting paths –Witness Reduction = Reducing # of accepting paths “Closure Completeness” Theorem –If #P is closed under proper subtraction: #P is closed under all polynomial-time computable operations UP = PP “Hierarchy Heroics” Theorem –If UP = PP, UP = PP = NP = coNP = PH =  P = PP  PP PP  PP PP PP ... Related Results: –Integer division for #P, Proper subtraction for OptP, SpanP