<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<?xml-stylesheet type="text/xsl" href="http://www.w3.org/style/mathml.xsl"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1 plus MathML 2.0 plus SVG 1.1//EN" "http://www.w3.org/Math/DTD/mathml2/xhtml-math11-f.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head><title>Proof of PCP Theorem Using Gap Amplification</title></head>

<body>
<a href="http://www.cs.huji.ac.il/~dinuri/mypapers/combpcp.pdf"><b>The PCP Theorem by Gap Amplification</b>, Irit Dinur</a>
<br/>This document uses <a href="http://www.w3.org/Math/">MathML</a>. 
<a href="http://www.mozilla.org/projects/mathml/fonts/">Fonts for Mozilla/Firefox</a>.
<br/>
Presentation file is <a href="http://cs.uiuc.edu/homes/zamani/pcp.ppt">here</a>.
<br/><br/><br/>

<b>Constraint Graph:</b> A constraint graph is a 4-tuple <i>G=(V,E,&Sigma;,C)</i>, where <i>G=(V,E)</i> is a 
graph and elements of <i>V</i> are interpreted as variables over &Sigma;. For each edge <i>e&in;E</i>,
<i>C(e)</i> is a binary relation over &Sigma; (<i>C(e)&sube;&Sigma;<sup>2</sup></i>).
We say edge <i>e</i> is satisfied under some assignment to its endpoint variables <i>x</i> and <i>y</i>, iff 
<i>(x,y)&in;C(e)</i>. By UNSAT<i>(G)</i>, we mean the minimum fraction of edges of <i>G</i> that remain
unsatisfied under every assignment to vertices of <i>G</i>.
We need <i>O(|V|+|E||&Sigma;|<sup>2</sup>)</i> bits to store <i>G</i>.


<br/>
<b>Gap Satisfaction Problem (GSP):</b> Given a constraint graph <i>G</i> and a real number <i>&alpha;</i>,
distinguish between these two cases: UNSAT<i>(G)</i> =0 or UNSAT<i>(G)</i> &ge;&alpha;.
(We know that <i>G</i> is in one of these two cases for sure).

<br/><br/>
Note that when <i>&alpha; &leq; 1/|E|</i>, GSP is equivalent to the 
<a href="http://www.nada.kth.se/~viggo/wwwcompendium/node15.html">Graph-3Coloring</a> problem and so is NP-complete.
We want to show even for large values of &alpha;, GSP is NP-complete (It is easy to show that if
GSP is NP-complete, then GAP-3SAT(the question of whether a given 3SAT formula is satisfiable
or has always at least an &alpha; fraction of its clauses unsatisfied) will be NP-complete. But we know that
<a href="http://www.cs.huji.ac.il/~pcp/lecture-notes/lect02/lect02.pdf">
GAP-3SAT is NP-complete iff PCP Theorem is true</a>, 
so this will give us a less and more combinatorial proof of
PCP Theorem, compared with its <a href="http://citeseer.ist.psu.edu/arora92probabilistic.html">traditional proof</a>).

To show that GSP is hard for large values of &alpha;, we reduce GSP for small values of &alpha; to the case of
large values. We will use these three black boxes (each of them is just a polynomial time algorithm):
<ul>
<li><b>BB<sub>0</sub></b><i>(Preprocessing)</i> <b>:</b> The input here is a GSP and the output is a GSP
where its graph is an expander with degree <i>d</i> and eigenvalue gap at least &Delta; (where <i>d</i> and
&Delta; are fixed global constants). This expander at each vertex has a self-loop.
Size of new GSP is not bigger than a constant times previous size and UNSAT of new problem drops but not
more than a constant fraction of the previous UNSAT of problem.
</li>


<li><b>BB<sub>1</sub></b><i>(Powering)</i> <b>:</b> The input here is an integer <i>t</i> (the power) and
a GSP (let its alphabet be &Sigma;) with small &alpha; threshold (&alpha; &leq; <i>1/|E|</i>)
where its constraint graph must be 
a <i>d</i>-regular expander with eigenvalue gap at least &Delta;.
The output is a new GSP with a graph on the same vertex set (so of the same size); size of its edge set increases
by a factor of <i>d</i>, and the alphabet of new problem is &Sigma;<sup>d<sup>1+t/2</sup></sup>. This operation enlarges the
UNSAT value by a factor of 
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msqrt><mi>t</mi></msqrt>
</math>
times a parameter that just depends on <i>d</i>, |&Sigma;| and &Delta; (In the following we
will fix these three parameters so this black box will enlarge UNSAT just by a constant factor 2).
</li>

<li><b>BB<sub>2</sub></b><i>(Composition)</i> <b>:</b> The input here is a GSP on any arbitrary finite alphabet.
The output is a GSP on a certain fixed alphabet &Sigma;<sub>0</sub> such that size of new GSP is not more than a
constant factor of size of original GSP and UNSAT value of GSP drops, but not more than a constant factor.
</li>
</ul>


Now let GSP(&alpha;) be an instance of GSP with "small" &alpha; (&alpha; &leq; <i>1/|E|</i> )
and with <i>m</i> edges (<i>m=|E|</i>). Then consider the following GSP :

<br/><br/>
<center>
<math xmlns="http://www.w3.org/1998/Math/MathML">
GSP'=
<mover>
       <m><mi mathvariant="bold"><msub><mi>BB</mi><mn>2</mn></msub></mi>(<mi mathvariant="bold"><msub><mi>BB</mi><mn>1</mn></msub></mi>(<mi mathvariant="bold"><msub><mi>BB</mi><mn>0</mn></msub></mi>(&hellip;&hellip;(<mi mathvariant="bold"><msub><mi>BB</mi><mn>2</mn></msub></mi>(<mi mathvariant="bold"><msub><mi>BB</mi><mn>1</mn></msub></mi>(<mi mathvariant="bold"><msub><mi>BB</mi><mn>0</mn></msub></mi></m>
       <mover>
         <mo>&OverBrace;</mo>
         <mrow>
           <mi>c.3. <mo>log</mo> &nbsp;n</mi>
           <mtext>&nbsp;elements</mtext>
         </mrow>
       </mover>
</mover>(GSP(&alpha;))))&hellip;)
</math>
</center>

The above statements about black boxes ensures us that <i> we can decide GSP iff 
we can decide GSP'</i>. Moreover GSP'
can have a threshold as large as any &alpha; &leq;1 
(by adjusting the parameter <i>c</i> in the number of iterations above), 
and computing GSP' is possible in polytime; so now we have our
reduction from <u>GSP for "small" thresholds</u> to <u>GSP for "large" thresholds</u>.
This completes the proof. 

<br/>Here is some explanation of how each of these black boxes work, but before that
we assume <a href="http://eccc.uni-trier.de/eccc-reports/2001/TR01-018/Paper.pdf">
there exist constants <i>d<sub>0</sub></i> and <i>h<sub>0</sub></i> and 
a polynomial time algorithm which given every integer <i>n</i>,
 generates an <i>n</i>-vertex expander with degree <i>d<sub>0</sub></i>
and with edge expansion at least <i>h<sub>0</sub></i></a>. All the following
black boxes transform a graph <i>G</i> into a graph <i>G'</i>, every parameter with a "prime" is
related to transformed graph, e.g. <i>E'</i> will indicate edges of transformed graph and etc.

<br/><br/>
<lu>
<li><a href="javascript:void(0)" onclick="toggle('l1','t1')"><b>BB<sub>0</sub></b><i>(Preprocessing)</i> <a id="t1">---</a></a>
<div style="display:block;" name="l1" id="l1">
We do this in two steps, first we make the graph regular (and then we convert it into an expander). For each
vertex <i>v</i> in graph, we generate an expander (of degree <i>d<sub>0</sub></i> and expansion at least
<i>h<sub>0</sub></i>) on <i>d(v)</i> vertices and replace it with <i>v</i> (each old edge of
<i>v</i> will become adjacent to exactly one of the new vertices which have replaced <i>v</i>).
All the old edges will have their previous constraint and all the new edges (edges of expanders) will be assigned
an equality constraint (i.e. <i>C(e)</i>={<i>(x,x)</i> : <i>x</i> &in; &Sigma; }).
Let's call this new graph <i>G'</i>, trivially <i>G'</i> is regular (of degree <i>d<sub>0</sub>+1</i>),
is of size at most a constant times size of <i>G</i> and generating it, is possible in polytime. Moreover since every
assignment to vertices of <i>G</i> can be naturally transformed (assign the value of vertex <i>v</i> to all the vertices
of expander which is replaced <i>v</i>) 
to an assignment of vertices of <i>G'</i>,
then UNSAT<i>(G')</i> &leq; UNSAT<i>(G)</i>.
<br/> Now consider a "best" assignment &sigma;' 
to vertices of <i>G'</i>, so exactly UNSAT<i>(G')</i> edges of <i>G'</i> will 
remain unsatisfied under this assignment. Build assignment &sigma; to vertices of <i>G</i> by taking plurality (majority),
i.e. for every vertex <i>v</i> in <i>G</i>, look at values (under &sigma;') 
of all vertices of the expander which replaced <i>v</i> 
and set &sigma;<i>(v)</i> to the most frequently visited value among them. Assume &beta; fraction of edges
of <i>G</i> remain unsatisfied under &sigma;, then we claim that (for some constant <i>c</i>) at least 
<i>c&beta;</i> fraction of edges of <i>G'</i> is unsatisfied under &sigma;' (Note that this will complete what 
we expect from this black box to perform, except the expansion property). 
Let <i>F</i> be the set of unsatisfied edges of <i>G</i>,
<i>F'</i> be the set of unsatisfied edges of <i>G'</i> and <i>S</i> be the set of vertices of <i>G'</i> that 
their assigned value is different from majority vote among vertices of the expander they belong to.
(It is trivial to see <i>|F'|+|S| &geq; |F|</i> ). Now if <i>|F'|&geq; 0.5 |F|</i>, the claim will be trivial
(note that by the construction <i>|E'|=(d<sub>0</sub>+1).|E|</i> ).
On the other hand if <i>|F'| &lt; 0.5|F|</i>, then by previous inequality we must have <i>|S| &gt; 0.5|F|</i>.
Now group vertices in <i>S</i> that have been assigned the same value under &sigma;' and belong to the same expander. 
By definition of <i>S</i> (majority),
each of these groups has a size less than half of the vertices of that expander, and so expands with a constant factor.
But this means that the whole <i>S</i> also must expand with a constant factor, which immediately completes the proof.

<br/> Now we have a regular graph, to convert it into an expander we just consider a <i>(d,h<sub>0</sub>)</i>-expander
on the same vertex set of the graph and take the union of edges. It is trivial to see every thing that we want from this
black box is now established.

</div>
</li>


<li><a href="javascript:void(0)" onclick="toggle('l2','t2')"><b>BB<sub>1</sub></b><i>(Powering)</i> <a id="t2">---</a></a>
<div style="display:block;" name="l2" id="l2">
Let's define powering first. For input GSP <i>G</i> and integer <i>t</i>, <i>G<sup>t</sup></i> is the constraint
graph on the same vertex set as <i>G</i>. Each <i>uv</i> walk of length <i>t</i> in <i>G</i> is converted into
a <i>uv</i> edge in <i>G<sup>t</sup></i>. Each vertex <i>v</i> of <i>G<sup>t</sup></i> takes values from alphabet 
&Sigma;<sup>d<sup>1+t/2</sup></sup>, we veiw these as "the opinions of <i>v</i> " about vertices of distance at most
<i>t/2</i> to <i>v</i>. Finally we create a constraint on edge <i>e=uv</i> of <i>G<sup>t</sup></i> such that 
<i>e</i> is satisfied iff opinions of <i>u</i> and <i>v</i> together, satisfy all the edges in <i>G</i>
which can be evaluated just using opinions of <i>u</i> and <i>v</i>.

<br/><br/>
To analyse this construction we need two lemmas:
<p><b>Lemma1:</b> For any non-negative random varible <i>X</i> we have:
<center>
<math xmlns="http://www.w3.org/1998/Math/MathML">
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">  <mrow>    <mfrac>      <mrow>        <msup>          <mi>E</mi>          <mn>2</mn>        </msup>        <mfenced>          <mrow>            <mi>X</mi>          </mrow>        </mfenced>      </mrow>      <mrow>        <mi>E</mi>        <mfenced>          <mrow>            <msup>              <mi>X</mi>              <mn>2</mn>            </msup>          </mrow>        </mfenced>      </mrow>    </mfrac>    <mo>&le;</mo>    <mfrac>      <mrow>        <msup>          <mi>E</mi>          <mn>2</mn>        </msup>        <mfenced>          <mrow>            <mi>X</mi>            <mo>|</mo>            <mi>X</mi>            <mo>></mo>            <mn>0</mn>          </mrow>        </mfenced>        <msup>          <mi>P</mi>          <mn>2</mn>        </msup>        <mfenced>          <mrow>            <mi>X</mi>            <mo>></mo>            <mn>0</mn>          </mrow>        </mfenced>      </mrow>      <mrow>        <mi>E</mi>        <mfenced>          <mrow>            <msup>              <mi>X</mi>              <mn>2</mn>            </msup>            <mo>|</mo>            <mi>X</mi>            <mo>></mo>            <mn>0</mn>          </mrow>        </mfenced>        <mi>P</mi>        <mfenced>          <mrow>            <mi>X</mi>            <mo>></mo>            <mn>0</mn>          </mrow>        </mfenced>      </mrow>    </mfrac>    <mo>&le;</mo>    <mi>P</mi>    <mfenced>      <mrow>        <mi>X</mi>        <mo>></mo>        <mn>0</mn>      </mrow>    </mfenced>  </mrow></math>
</math></center>
where last inequality is true because: 
<center>
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
  <mrow>
    <mn>0</mn>
    <mo>&le;</mo>
    <mtext>Var</mtext>
    <mfenced>
      <mrow>
        <mi>X</mi>
        <mo>|</mo>
        <mi>X</mi>
        <mo>></mo>
        <mn>0</mn>
      </mrow>
    </mfenced>
    <mo>=</mo>
    <mi>E</mi>
    <mfenced>
      <mrow>
        <msup>
          <mi>X</mi>
          <mn>2</mn>
        </msup>
        <mo>|</mo>
        <mi>X</mi>
        <mo>></mo>
        <mn>0</mn>
      </mrow>
    </mfenced>
    <mo>&minus;</mo>
    <msup>
      <mi>E</mi>
      <mn>2</mn>
    </msup>
    <mfenced>
      <mrow>
        <mi>X</mi>
        <mo>|</mo>
        <mi>X</mi>
        <mo>></mo>
        <mn>0</mn>
      </mrow>
    </mfenced>
  </mrow>
</math>
</center>
</p>


<p><b>Lemma2:</b> Given an expander <i>G=(V,E)</i> with degree <i>d</i> and 2nd eigenvalue &lambda; and a set
of "bad edges" <i>F</i>, odds that a random walk starting at a random edge in <i>F</i> has its <i>i+1</i>-st edge
in <i>F</i>, is at most:</p>
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
  <mrow>
    <mfrac>
      <mrow>
        <mo>|</mo>
        <mi>F</mi>
        <mo>|</mo>
      </mrow>
      <mrow>
        <mo>|</mo>
        <mi>E</mi>
        <mo>|</mo>
      </mrow>
    </mfrac>
    <mo>+</mo>
    <msup>
      <mfenced>
        <mrow>
          <mrow>
            <mfrac>
              <mi>&lambda;</mi>
              <mi>d</mi>
            </mfrac>
          </mrow>
        </mrow>
      </mfenced>
      <mi>i</mi>
    </msup>
  </mrow>
</math>
We will prove this using similar techniques we saw in class for analysing random walks and then
continue with the description of black box.
<br/> Let <i>K</i> be the distribution imposed on <i>vertices</i> of <i>G</i> by first selecting an edge in <i>F</i>
and then selecting a vertex adjacent to that edge. Let <i>B</i> be the vertices adjacent to at least one edge
of <i>F</i> and <i>A</i> the normalized adjacency matrix of <i>G</i>.
Let <i>x</i> be the vector such that <i>x<sub>v</sub>=Pr<sub>K</sub>[v]</i> and <i>y<sub>v</sub></i> be the 
probability that a random step from <i>v</i> falls in <i>F</i>, we have:
<i>x<sub>v</sub>&leq; d / (2|F|)</i> and <i>y=2|F| x / d</i>. 
The lemma seeks the following probability:
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
  <mrow>
    <munder>
      <mo>&Sum;</mo>
      <mrow>
        <mi>v</mi>
        <mo>&Element;</mo>
        <mi>B</mi>
      </mrow>
    </munder>
    <msub>
      <mi>y</mi>
      <mi>v</mi>
    </msub>
    <msub>
      <mfenced>
        <mrow>
          <msup>
            <mi>A</mi>
            <mi>i</mi>
          </msup>
          <mi>x</mi>
        </mrow>
      </mfenced>
      <mi>v</mi>
    </msub>
    <mo>=</mo>
    <mo>&lang;</mo>
    <mi>y</mi>
    <mo>,</mo>
    <msup>
      <mi>A</mi>
      <mi>i</mi>
    </msup>
    <mi>x</mi>
    <mo>&rang;</mo>
  </mrow>
</math>
Write 
<math xmlns="http://www.w3.org/1998/Math/MathML">
  <mrow>
    <mi>x</mi>
    <mo>=</mo>
    <msup>
      <mi>x</mi>
      <mo>&DoubleVerticalBar;</mo>
    </msup>
    <mo>+</mo>
    <msup>
      <mi>x</mi>
      <mo>&UpTee;</mo>
    </msup>
  </mrow>
</math>
where 
<math xmlns="http://www.w3.org/1998/Math/MathML">
  <mrow>
    <msup>
      <mi>x</mi>
      <mo>&DoubleVerticalBar;</mo>
    </msup>
    <mo>=</mo>
    <mrow>
      <mfrac>
        <mn>1</mn>
        <mi>n</mi>
      </mfrac>
    </mrow>
    <mstyle mathvariant="bold">
      <mn>1</mn>
    </mstyle>
  </mrow>
</math>. Using properties of eigenvalues and Cauchy-Schwartz inequality (respectively) we have:
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
  <mrow>
    <mo>&DoubleVerticalBar;</mo>
    <msup>
      <mi>A</mi>
      <mi>i</mi>
    </msup>
    <msup>
      <mi>x</mi>
      <mo>&UpTee;</mo>
    </msup>
    <mo>&DoubleVerticalBar;</mo>
    <mo>&le;</mo>
    <mo>|</mo>
    <mfrac>
      <mi>&lambda;</mi>
      <mi>d</mi>
    </mfrac>
    <msup>
      <mo>|</mo>
      <mi>i</mi>
    </msup>
    <mo>&DoubleVerticalBar;</mo>
    <msup>
      <mi>x</mi>
      <mo>&UpTee;</mo>
    </msup>
    <mo>&DoubleVerticalBar;</mo>
    <mo>&le;</mo>
    <mo>|</mo>
    <mfrac>
      <mi>&lambda;</mi>
      <mi>d</mi>
    </mfrac>
    <msup>
      <mo>|</mo>
      <mi>i</mi>
    </msup>
    <mo>&DoubleVerticalBar;</mo>
    <mi>x</mi>
    <mo>&DoubleVerticalBar;</mo>
  </mrow>
</math>

<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
  <mrow>
    <mo>&lang;</mo>
    <mi>y</mi>
    <mo>,</mo>
    <msup>
      <mi>A</mi>
      <mi>i</mi>
    </msup>
    <msup>
      <mi>x</mi>
      <mo>&UpTee;</mo>
    </msup>
    <mo>&rang;</mo>
    <mo>&le;</mo>
    <mrow>
      <mo>&DoubleVerticalBar;</mo>
      <mi>y</mi>
      <mo>&DoubleVerticalBar;</mo>
    </mrow>
    <mo>.</mo>
    <mrow>
      <mo>&DoubleVerticalBar;</mo>
      <msup>
        <mi>A</mi>
        <mi>i</mi>
      </msup>
      <msup>
        <mi>x</mi>
        <mo>&UpTee;</mo>
      </msup>
      <mo>&DoubleVerticalBar;</mo>
    </mrow>
    <mo>&le;</mo>
    <mrow>
      <mn>2</mn>
      <mfrac>
        <mrow>
          <mo>|</mo>
          <mi>F</mi>
          <mo>|</mo>
        </mrow>
        <mi>d</mi>
      </mfrac>
    </mrow>
    <mrow>
      <mo>&DoubleVerticalBar;</mo>
      <mi>x</mi>
      <mo>&DoubleVerticalBar;</mo>
    </mrow>
    <mo>.</mo>
    <msup>
      <mrow>
        <mo>|</mo>
        <mrow>
          <mfrac>
            <mi>&lambda;</mi>
            <mi>d</mi>
          </mfrac>
        </mrow>
        <mo>|</mo>
      </mrow>
      <mi>i</mi>
    </msup>
    <mrow>
      <mo>|</mo>
      <mo>|</mo>
      <mi>x</mi>
      <mo>&DoubleVerticalBar;</mo>
    </mrow>
    <mo>&le;</mo>
    <msup>
      <mrow>
        <mo>|</mo>
        <mrow>
          <mfrac>
            <mi>&lambda;</mi>
            <mi>d</mi>
          </mfrac>
        </mrow>
        <mo>|</mo>
      </mrow>
      <mi>i</mi>
    </msup>
  </mrow>
</math>

Now by combining everything above:
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
  <mrow>
    <mrow>
      <mo>&lang;</mo>
      <mi>y</mi>
      <mo>,</mo>
      <msup>
        <mi>A</mi>
        <mi>i</mi>
      </msup>
      <mi>x</mi>
      <mo>&rang;</mo>
    </mrow>
    <mo>=</mo>
    <mrow>
      <mo>&lang;</mo>
      <mi>y</mi>
      <mo>,</mo>
      <msup>
        <mi>A</mi>
        <mi>i</mi>
      </msup>
      <msup>
        <mi>x</mi>
        <mo>&DoubleVerticalBar;</mo>
      </msup>
      <mo>&rang;</mo>
    </mrow>
    <mo>+</mo>
    <mrow>
      <mo>&lang;</mo>
      <mi>y</mi>
      <mo>,</mo>
      <msup>
        <mi>A</mi>
        <mi>i</mi>
      </msup>
      <msup>
        <mi>x</mi>
        <mo>&UpTee;</mo>
      </msup>
      <mo>&rang;</mo>
    </mrow>
    <mo>&le;</mo>
    <mrow>
      <mn>2</mn>
      <mfrac>
        <mrow>
          <mo>|</mo>
          <mi>F</mi>
          <mo>|</mo>
        </mrow>
        <mrow>
          <mi>d</mi>
          <mi>n</mi>
        </mrow>
      </mfrac>
    </mrow>
    <mo>+</mo>
    <mo>|</mo>
    <mrow>
      <mfrac>
        <mi>&lambda;</mi>
        <mi>d</mi>
      </mfrac>
    </mrow>
    <msup>
      <mo>|</mo>
      <mi>i</mi>
    </msup>
    <mo>=</mo>
    <mrow>
      <mfrac>
        <mrow>
          <mo>|</mo>
          <mi>F</mi>
          <mo>|</mo>
        </mrow>
        <mrow>
          <mo>|</mo>
          <mi>E</mi>
          <mo>|</mo>
        </mrow>
      </mfrac>
    </mrow>
    <mo>+</mo>
    <msup>
      <mfenced>
        <mrow>
          <mrow>
            <mfrac>
              <mrow>
                <mo>|</mo>
                <mi>&lambda;</mi>
                <mo>|</mo>
              </mrow>
              <mi>d</mi>
            </mfrac>
          </mrow>
        </mrow>
      </mfenced>
      <mi>i</mi>
    </msup>
  </mrow>
</math>



<hr style="width:70%;"/>


<br/><br/><br/>
The only non-trivial claim that we had about this box is that it amplifies the amount of unsatisfaction 
(where UNSAT<i>(G)</i> is small of course). Let <i>G<sup>t</sup>=G'</i> and let &sigma;' be a "best" assignment
for vertices of <i>G'</i>. Build the assignment &sigma; for vertices of <i>G</i> this way: for every vertex <i>v</i>
in <i>G</i> start a random walk of length <i>t/2</i> in <i>G</i> and set &sigma;(v) such that the probability
that the opinion of the other end of random walk about <i>v</i> becomes &sigma;(v), gets maximum. Now let 
<i>F</i> be the subset of unsatisfied edges of <i>G</i> under &sigma; (but if <i>|F|</i> is more that <i>1/t</i>
fraction of the edges of <i>G</i> then throw out some of the members of <i>F</i> such that
<i>|F|/|E| &leq; 1/t</i> ).
From now on we refer to an edge <i>e</i> in <i>G'</i> and its corresponding <i>t</i>-walk in <i>G</i> by the same
notation <i>e</i>. Let's name vertices of <i>e</i> by 
<i>v<sub>0</sub>,v<sub>1</sub>,&hellip;,v<sub>t-1</sub>,v<sub>t</sub></i>.
We say an edge <i>e</i> is <i>hit</i> in its <i>i</i>-th edge iff 
<i>v<sub>i</sub>v<sub>i+1</sub> &in; F</i>, opinion of <i>v<sub>0</sub></i> about <i>v<sub>i</sub></i> is
&sigma;(<i>v<sub>i</sub></i>) and opinion of <i>v<sub>t</sub></i> about <i>v<sub>i+1</sub></i> is 
&sigma;(<i>v<sub>i+1</sub></i>). A hit is <i>in the middle</i> if 
<math xmlns="http://www.w3.org/1998/Math/MathML">
  <mrow>
    <mfrac>
      <mi>t</mi>
      <mn>2</mn>
    </mfrac>
    <mo>&minus;</mo>
    <msqrt>
      <mi>t</mi>
    </msqrt>
    <mo>&le;</mo>
    <mi>i</mi>
    <mo>&le;</mo>
    <mfrac>
      <mi>t</mi>
      <mn>2</mn>
    </mfrac>
    <mo>+</mo>
    <msqrt>
      <mi>t</mi>
    </msqrt>
  </mrow>
</math>
.

Let <i>N(e)</i> show the number of times an edge <i>e</i> is hit in the middle.
Obviously every edge which is hit is unsatisfied in <i>G'</i>, so 
<i>P<sub>e</sub>(N(e)&gt;0) &leq; </i>UNSAT<i>(G')</i> (over <i>e</i> taken uniformly).
Now we will prove the following two lemmas, note that these two combined with <b>Lamma1</b> and the previous
ineqaulity will finish the proof.

<p><b>Lemma3:</b> 
<math xmlns="http://www.w3.org/1998/Math/MathML">
  <mrow>
    <mi>E</mi>
    <mfenced>
      <mrow>
        <mi>N</mi>
        <mfenced>
          <mrow>
            <mi>e</mi>
          </mrow>
        </mfenced>
        <mo>></mo>
        <mn>0</mn>
      </mrow>
    </mfenced>
    <mo>&GreaterEqual;</mo>
    <mrow>
      <mfrac>
        <mrow>
          <mo>|</mo>
          <mi>F</mi>
          <mo>|</mo>
        </mrow>
        <mrow>
          <mo>|</mo>
          <mi>E</mi>
          <mo>|</mo>
        </mrow>
      </mfrac>
    </mrow>
    <mi>&Omega;</mi>
    <mfenced>
      <mrow>
        <msqrt>
          <mi>t</mi>
        </msqrt>
      </mrow>
    </mfenced>
  </mrow>
</math>

<br/>Proof of this doesn't use any property of expanders, and in fact it uses standard analysis methods
(defining indicator random variables and &hellip;). It relies on the fact that two poisson experiments with
the same probability of success and "almost" the same number of experiments have the same distribution
around their mean.
</p>


<p><b>Lemma4:</b>
<math xmlns="http://www.w3.org/1998/Math/MathML" >
  <mrow>
    <mi>E</mi>
    <mfenced>
      <mrow>
        <mi>N</mi>
        <msup>
          <mfenced>
            <mrow>
              <mi>e</mi>
            </mrow>
          </mfenced>
          <mn>2</mn>
        </msup>
        <mo>></mo>
        <mn>0</mn>
      </mrow>
    </mfenced>
    <mo>&le;</mo>
    <mrow>
      <mfrac>
        <mrow>
          <mo>|</mo>
          <mi>F</mi>
          <mo>|</mo>
        </mrow>
        <mrow>
          <mo>|</mo>
          <mi>E</mi>
          <mo>|</mo>
        </mrow>
      </mfrac>
    </mrow>
    <mi>O</mi>
    <mfenced>
      <mrow>
        <msqrt>
          <mi>t</mi>
        </msqrt>
      </mrow>
    </mfenced>
  </mrow>
</math>

<br/>
Define <i>Z(e)</i> to be the number of "middle" edges of <i>e</i> which are in <i>F</i>, obviously 
<i>N(e) &lt; Z(e)</i>, so we will upper-bound <i>E(Z(e)<sup>2</sup>)</i>.
Let's define an indicator variable <i>Z<sub>i</sub></i> which indicates that edge <i>e</i> is hit in its
<i>i</i>-th edge. We will have:
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
  <mrow>
    <mi>E</mi>
    <mfenced>
      <mrow>
        <mi>Z</mi>
        <msup>
          <mfenced>
            <mrow>
              <mi>e</mi>
            </mrow>
          </mfenced>
          <mn>2</mn>
        </msup>
      </mrow>
    </mfenced>
    <mo>=</mo>
    <mo>&Sum;</mo>
    <mi>E</mi>
    <mfenced>
      <mrow>
        <msup>
          <mrow>
            <msub>
              <mi>Z</mi>
              <mi>i</mi>
            </msub>
          </mrow>
          <mn>2</mn>
        </msup>
      </mrow>
    </mfenced>
    <mo>+</mo>
    <mn>2</mn>
    <mo>&Sum;</mo>
    <mi>E</mi>
    <mfenced>
      <mrow>
        <msub>
          <mi>Z</mi>
          <mi>i</mi>
        </msub>
        <msub>
          <mi>Z</mi>
          <mi>j</mi>
        </msub>
      </mrow>
    </mfenced>
    <mo>=</mo>
    <mn>4</mn>
    <msqrt>
      <mi>t</mi>
    </msqrt>
    <mrow>
      <mfrac>
        <mrow>
          <mo>|</mo>
          <mi>F</mi>
          <msup>
            <mo>|</mo>
            <mn>2</mn>
          </msup>
        </mrow>
        <mrow>
          <mo>|</mo>
          <mi>E</mi>
          <msup>
            <mo>|</mo>
            <mn>2</mn>
          </msup>
        </mrow>
      </mfrac>
    </mrow>
    <mo>+</mo>
    <mn>2</mn>
    <mo>&Sum;</mo>
    <mi>E</mi>
    <mfenced>
      <mrow>
        <msub>
          <mi>Z</mi>
          <mi>i</mi>
        </msub>
        <msub>
          <mi>Z</mi>
          <mi>j</mi>
        </msub>
      </mrow>
    </mfenced>
  </mrow>
</math>

Since <i>|F|/|E| &leq; 1/t</i>, the first term of the last inequality approaches zero. 
The second term is upperbounded by <b>Lemma2</b>.

</p>







</div>
</li>

<li><a href="javascript:void(0)" onclick="toggle('l3','t3')"><b>BB<sub>2</sub></b><i>(Composition)</i> <a id="t3">---</a></a>
<div style="display:block;" name="l3" id="l3">
Here we accept <a href="http://www.wisdom.weizmann.ac.il/~reingold/publications/pcptesters.pdf">
existence of an algorithm which is called <i>assignment tester</i></a>.
For our purpose this definition of an assignment tester suffices:
<p><b>Assignment Tester:</b> An A.T. is an algorithm <i>A</i> with a fixed alphabet &Sigma;<sub>0</sub> and
constant &epsilon; such that given any Boolean formula &phi; over a set of <u>Boolean</u> variables <i>X</i>,
generates a GSP over  the same set of Boolean variables <i>X</i> and some auxiliary variables <i>Y</i> which take
values from &Sigma;<sub>0</sub> (so these new variable are not boolean) such that

<ul>
<li>Every assignment to <i>X</i> that satisfies &phi;, has an extension to <i>Y</i> that satisfies the GSP.</li>
<li>Every extension <i>b</i> of every assignment <i>a</i> to <i>X</i> that doesn't satisfy &phi;, 
satisfies this property UNSAT<i>(GSP)</i> &ge; &epsilon; d(<i>a,</i>,SAT(&phi;))
where SAT(&phi;) indicates the set of all satisfying assignments of &phi; and <i>d(.,.)</i> is the 
relative hamming distance between two strings.
</li>
</ul>
</p>


So suppose we have such an assignment tester <i>T</i> (explicit constructions of <i>T</i> exist, but
for our purpose as far as we have a proof of existence of A.T.'s, we can use brute force search to find one). 
Since we will always run <i>T</i> on inputs of constant
size, we don't need <i>T</i> to be efficient. 

<br/>
Now we build our black box. The idea is to apply <i>T</i> on each edge of <i>G</i> (input GSP) and take the union
of all generated GSPs. But each edge of <i>G</i> is a constraint over a finite alphabet &Sigma; and <i>T</i>
just works on "Boolean functions with Boolean input", so we first encode each vertex of <i>G</i> using 
binary variables. Using an efficient error correcting code with relative distance &rho; (which means any 
two valid code words are in relative distance at least &rho;), 
we will need <i>O(log |&Sigma;|)</i> new variables
per vertex of <i>G</i>. Now we apply <i>T</i> to each edge of <i>G</i> and take the union of outputs, this union is 
our output GSP <i>G'</i>. 
<br/>
So far this black box does almost everything that we asked for (trivial to see), except the condition on
UNSAT value. We will prove for some constant <i>c</i>, <i>c.</i>UNSAT<i>(G)</i> &leq; UNSAT<i>(G')</i> 
(proving UNSAT<i>(G')</i> &leq; UNSAT<i>(G)</i> will be similar). First see that w.l.o.g. we can assume that all
the GSP's that we took their unions had the same size (just add extra edges when necessary).
Take a "best" assignment &sigma;' in <i>G'</i>, we will build an assignment &sigma; in <i>G</i> such that
every unsatisfied edge in <i>G</i> generates at least <i>c</i> unsatisfied edges under application of <i>T</i> to that (for
a constant <i>c</i>). Note that this will complete the proof. 
To build &sigma;, take a vertex <i>v</i> in <i>G</i> and look at all <i>O(log |&Sigma;|)</i> variables that encode
<i>v</i>, these variable under &sigma;' have assigned binary values (though they might not be a correct code word). Assign
to &sigma;(v) the simple in &Sigma; with the nearest valid code word to those variables.
Now look at an unsatisfied edge <i>e=uv</i> in <i>G</i>. Since <i>e</i> is unsatisfied, and since
we have an error correcting code, at least half of bits in <i>u</i> or <i>v</i> must change to make <i>e</i> satisfied,
which means <i>d </i>(&sigma;(u,v),SAT(e)) &geq; &rho;/4. (&sigma;(u,v) indicates the assignment under &sigma; to
all variables that encode <i>u</i> and <i>v</i>). But this using the properties of <i>T</i> shows that at least
&epsilon;&rho;/4 fraction of edges remain unsatisfied when we apply <i>T</i> to <i>e</i>.


</div>
</li>


</lu>












<script language="javascript">
function toggle(x,z) {
var y = document.getElementById(z);
if (y.innerHTML == "+++") {
y.innerHTML = "---";
} else {
y.innerHTML = "+++";
};

y = document.getElementById(x);
if (y.style.display == "none") {
y.style.display = "block";
} else {
y.style.display = "none";
};
};
</script>



<!--
<math xmlns="http://www.w3.org/1998/Math/MathML">
<msub><mi>a</mi><mi>b</mi></msub>
</math>

<math xmlns="http://www.w3.org/1998/Math/MathML">
<mroot><mi>a</mi><mi>asdsa</mi></mroot>
</math>
-->
</body>

</html>
