Defining polynomials
This presentation is the property of its rightful owner.
Sponsored Links
1 / 24

Defining Polynomials PowerPoint PPT Presentation

  • Uploaded on
  • Presentation posted in: General

Defining Polynomials. p 1 (n) is the bound on the length of an input pair <x,y> p 2 (n) is the bound on the running time of f p 3 (n) is a bound on the number of strings in S of length  n.

Download Presentation

Defining Polynomials

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

Defining polynomials

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

Defining polynomials

CULL (, )

Used in combination with splitting intervals into upper and lower halves to eventually get intervals of size 1.

Defining polynomials

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.

Defining polynomials

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)

Defining polynomials

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)

Defining polynomials

CULL(, )

Ex: CULL3(, [s(w1) = 1, s(w2) = 0, s(w3) = 0])

Use this  to transform, for each I,

f(I) = ( a, v1, v2, … vk )


g(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

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

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



G0 G1

G0’ G1’

Nonleaf Nodes

Consists of two phases:

phase 1 removes duplicates in G

phase 2 divides G’ into groups that we can use in recursive calls

while eliminating some intervals along the way

Phase 1 remove duplicates



G0 G1

G0’ G1’

Phase 1: Remove duplicates

If g(I) = g(I’) for I < I’, then take

G’ = G - {I}

Then G’ will still be a cover

Remove all such duplicates

Phase 2 split g




G0’ G1’

Phase 2: Split G’

G0 = {all I G’ | (I) (0,0,…,0) = 0}

G1 = {all I G’ | (I) (0,0,…,0) = 1}

Order within g 0

Order within G0

Order the intervals in G0 as follows:

I1 = min{I | IG0}

It+1 = min{I | IG0  Z(I)  Z(I1) =… Z(I)  Z(It) =}

m is the largest t such that It is defined.

Order within g 01




G0’ G1’

Order within G0

This means two things:

I1 < I2 < … < Im

The Z(Ii) are pair-wise disjoint.

Now define G0’ =

{ G0 if m  q(n)

{ J | J G0  J Iq(n)+1 otherwise

x2, x3 x4, x5 x2, x6x7, x8



Claim g 0 is a cover of g 0

Claim: G0’ is a cover of G0

if  is correct

Without loss of generality, let m>q(n)

(otherwise G0’ = G0 by our definition)

Then $JG0 such that (IG0)

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

Nearing the Punchline...

The number of strings in S that can appear in these Z’s is bounded by q(n).

(I G0)[(I)(0,0,…0)=0]

So S does not satisfy g(Iq(n)+1)

x2, x4x3, x5 x2, x6x7, x8



Ex: q(n)=2

The punchline

The Punchline

wmax(x) < left endpoint of Iq(n)+1.

so we can eliminate from G0 any I > Iq(n)+1

This keeps the number of intervals polynomial.

x2, x4 x3, x5 x2, x6x7, x8 x? x? chopped-->

i1i2i3i4 I?

I1I2I3 I?

Computing the recursive calls

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 , let

t = {I | IG0‘  I U1 st-1s 


Ex:x2, x4 x3, x5 x2, x6x7, x8



1 = {i1, i3}

2 = {i2}


What does do for us

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, x6x7, x8



1 = {i1, i3}

2 = {i2}


The recursive calls

The Recursive Calls

CULL(1,  + s(y1) = 0)

CULL(1,  + s(y1) = 1)

up to

CULL((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 g 1

Computing G1

  • Repeat whole process to get G1

  • Use max instead of min



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.



At the leaves, because we have a full set of assumptions, we are evaluating constant functions.

We get G that covers [0p(|x|), 1p(|x|)].

Therefore if wmax(x) is in [0p(|x|), 1p(|x|)], then it must be in G. One of the assumptions is correct.



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…

Defining polynomials


Using our hypothetical sparse NP-hard setS, we have given a P algorithm for an arbitrary NP set!


  • Login