Defining Polynomials
p1(n) is the bound on the length of an input pair <x,y>
p2(n) is the bound on the running time of f
p3(n) is a bound on the number of strings in S of length n.
q(n) = p3(p2(p1(n))) is the maximum number of strings in S that can be in the argument part of the output of f.
r(n) = 4k k! (q(n) + 1)k
CULL (, )
Used in combination with splitting intervals into upper and lower halves to eventually get
intervals of size 1.
CULL(, )
Cull: its job is to prune the number of intervals to a polynomial.
For example, it will prune the number of intervals of size 1 from 2 p(|x|) to a polynomial, so that we can brute-force check each interval in polynomial time.
CULL(, )
A recursive function with recursion depth bounded by k
= set of intervals within [{0p(|x|), 1p(|x|)}]
= [s(w1) = b1, … s(wd) = bd], a list of assumptions, fixing query responses to 1 or 0 (since our polynomial machine can’t use the oracle)
CULL(, )
For instance:
Initial call: CULL0 ([0 p(|x|), 1p(|x|)], Ø)
At depth d=1: CULL1(, 1 assumption)
.
.
.At depth d=k: CULLk(, k assumptions)
CULL(, )
Ex: CULL3(, [s(w1) = 1, s(w2) = 0, s(w3) = 0])
Use this to transform, for each I,f(I) = ( v1, v2, … vk )
tog(I) = ((I), Z(I) )
where Z(I) is the list with the w’s removed
(I) is a (k-d)-ary Boolean function with d variables fixed to specific values
Leaf Nodes of CULL
Represent a complete set of assumptions (making Z(I) empty)
(I) is a constant function, and so can be evaluated
We evaluate each, and return the maximum interval such that g(I) is true.
If none exists, we return Ø
Correctness of CULL at leaves
If the assumptions are correct, then look at what is returned.
If it is an interval, then x L, else x L
Nonleaf Nodes
Consists of two phases:phase 1 removes duplicates in phase 2 divides ’ into groups
that we can use in recursive calls
while eliminating some intervals along the way
’
’’
Phase 1: Remove duplicates
If g(I) = g(I’) for I < I’, then take
’ = - {I}Then ’ will still be a coverRemove all such duplicates
’
’’
Phase 2: Split ’
= {all I ’ | (I) (0,0,…,0) = 0}
= {all I ’ | (I) (0,0,…,0) = 1}
’
’’
Order within
Order the intervals in as follows:
I1 = min{I | I}
It+1 = min{I | IZ(I) Z(I1) … Z(I) Z(It) }
m is the largest t such that It is defined.
Order within
This means two things:I1 < I2 < … < ImThe Z(Ii) are pair-wise disjoint.
Now define ’ = { if m q(n)
{ J | J J Iq(n)+1 otherwise
x2, x3 x4, x5 x2, x6 x7, x8
i1 i2 i3 i4I1 I2 I3
’
’’
Claim: ’ is a cover of
if is correctWithout loss of generality, let m>q(n)
(otherwise ’ = by our definition)
Then Jsuch that (I)
S satisfies g(I) IFF I J
Specifically, r, 1 r m,such that t, 1 t m,S satisfies g(It) IFF t r
Nearing the Punchline...The number of strings in S that can appear in these Z’s is
bounded by q(n).(I )[(I)(0,0,…0)=0]
So S does not satisfy g(Iq(n)+1)
x2, x4 x3, x5 x2, x6 x7, x8
i1 i2 i3 i4I1 I2 I3
Ex: q(n)=2
The Punchline
wmax(x) < left endpoint of Iq(n)+1.
so we can eliminate from any I > Iq(n)+1
This keeps the number of intervals polynomial.
x2, x4 x3, x5 x2, x6 x7, x8 x? x? chopped-->
i1 i2 i3 i4 I?I1 I2 I3 I?
Computing the Recursive Calls
Let y1, … y(k-d)m be an enumeration of the strings in Z(I1) ,…, Z(Im)
Then for each t in the range 1 t(k-d)m , lett = {I | I‘ I U1 st-1s
yt Z(I)}
Ex: x2, x4 x3, x5 x2, x6 x7, x8
i1 i2 i3 i4I1 I2 I3
1 = {i1, i3}
2 = {i2}
...
What does do for Us?
This means that the intervals within a given i all have at least one variable in common, namely yi.
Ex: x2, x4 x3, x5 x2, x6 x7, x8
i1 i2 i3 i4I1 I2 I3
1 = {i1, i3}
2 = {i2}
...
The Recursive Calls
CULL(1, + s(y1) = 0)
CULL(1, + s(y1) = 1)
up toCULL((k-d)m, + s(y(k-d)m) = 0)
CULL((k-d)m, + s(y(k-d)m) = 1)
Total number of calls: 2(k-d)m
Computing
• Repeat whole process to get
• Use max instead of min
Correctness
Need to set this free variable to true and to false at each level of the tree to guarantee that one of the leaves will contain the correct set of assumptions.
Correctness
At the leaves, because we have a full set of assumptions, we are evaluating constant functions.
We get that covers [0p(|x|), 1p(|x|)]. Therefore if wmax(x) is in [0p(|x|), 1p(|x|)], then it must
be in . One of the assumptions is correct.
Summary
Since the entire number of recursive calls at each level is polynomial and the depth of recursion is contstant,
and the time needed to cull the intervals is polynomial,
and the number of intervals is polynomial,and each one can be checked in polynomial
time…
P=NP
Using our hypothetical sparse NP-hard setS, we have given a P algorithm for an arbitrary NP set!
QED
