| import Mathlib |
| import OAI.Combinatorics.IndependentSets.Reduction.GraphReduction |
| import OAI.Combinatorics.IndependentSets.Reduction.ClampCube |
| import OAI.Combinatorics.IndependentSets.PCP.FinalCNF |
| import OAI.Combinatorics.IndependentSets.Reduction.MapEquiv |
| import OAI.Combinatorics.IndependentSets.Machines.ProfileMachine |
| import OAI.Combinatorics.IndependentSets.Encoding.PortTableEncoding |
| import OAI.Combinatorics.IndependentSets.Machines.MachineLazyTableRuntime |
| import OAI.Combinatorics.IndependentSets.Machines.PCPGapMachine |
| import OAI.Combinatorics.IndependentSets.Machines.TargetLCMachine |
| import OAI.Combinatorics.IndependentSets.Geometry.GeometryOutput |
|
|
| namespace OAI |
|
|
| namespace LargeIndependentSets |
| open IndependentSetsGames.Foundations |
| open scoped Classical |
| noncomputable section |
|
|
| namespace CompleteReduction |
| open PCP Hastad.SourceContexts Hastad.SourceGame |
| open Complexity |
|
|
| def gapInput (H : RoundTables.BaseTable) (b : List Bool) : TargetLC.Input := |
| ⟨TableIteration.gapMap H (BinaryNormalize.normalize b),TableIteration.gapMap_nonempty H _⟩ |
|
|
| def gapView (H : RoundTables.BaseTable) : |
| Turing.TM2ComputableInPolyTime (id : List Bool → List Bool) |
| (fun F : TargetLC.Input => Complexity.formulaBits F.val) (gapInput H) where |
| tm := (BinaryNormalize.gapCertificate H).tm |
| inputAlphabet := (BinaryNormalize.gapCertificate H).inputAlphabet |
| outputAlphabet := (BinaryNormalize.gapCertificate H).outputAlphabet |
| time := (BinaryNormalize.gapCertificate H).time |
| outputsFun := (BinaryNormalize.gapCertificate H).outputsFun |
|
|
| def lcComputer (H : RoundTables.BaseTable) (u : ℕ) : |
| Turing.TM2ComputableInPolyTime (id : List Bool → List Bool) UniformLC.Table.bits |
| (fun b => TargetLC.table u (gapInput H b)) := |
| MachineSequential.composeBits (gapView H) (TargetLC.certificate u) |
|
|
| lemma lcComputer_finiteAlphabet (H : RoundTables.BaseTable) (u : ℕ) : |
| MachineFiniteAlphabet.FiniteAlphabet (lcComputer H u).tm := |
| MachineFiniteAlphabet.composeBits (gapView H) (TargetLC.certificate u) |
| (BinaryNormalize.gap_finiteAlphabet H) (TargetLC.finiteAlphabet u) |
|
|
| def reduce (H : RoundTables.BaseTable) (p : SamplerParameters) (u q : ℕ) (hq : 0<q) |
| (b : List Bool) : Graph := GeometryNames.output (J u) (I u) p q hq (TargetLC.table u (gapInput H b)) |
|
|
| def certificate (H : RoundTables.BaseTable) (p : SamplerParameters) (u q : ℕ) (hq : 0<q) : |
| Turing.TM2ComputableInPolyTime (id : List Bool → List Bool) graphBits (reduce H p u q hq) := |
| MachineSequential.composeBits (f := fun b => TargetLC.table u (gapInput H b)) |
| (g := GeometryNames.output (J u) (I u) p q hq) |
| (lcComputer H u) (GeometryNames.graphComputer (J u) (I u) p q hq) |
|
|
| lemma finiteAlphabet (H : RoundTables.BaseTable) (p : SamplerParameters) (u q : ℕ) (hq : 0<q) : |
| MachineFiniteAlphabet.FiniteAlphabet (certificate H p u q hq).tm := |
| MachineFiniteAlphabet.composeBits (lcComputer H u) (GeometryNames.graphComputer (J u) (I u) p q hq) |
| (lcComputer_finiteAlphabet H u) (GeometryNames.graphComputer_finiteAlphabet (J u) (I u) p q hq) |
|
|
| lemma normalize_bits (b : List Bool) : |
| (Complexity.formulaBits (BinaryNormalize.normalize b)).length ≤ 100*(b.length+1)^2 := by |
| have h := Complexity.formulaBits_length_le (BinaryNormalize.normalize b) |
| rw [BinaryNormalize.clauses_length] at h |
| change (Complexity.formulaBits (BinaryNormalize.normalize b)).length ≤ |
| b.length+1+2*b.length+2+2*b.length*(3*(b.length+1+2)) at h |
| nlinarith [Nat.zero_le b.length] |
|
|
| def clausePolynomial : Polynomial ℕ := TableIteration.formulaBitsPolynomial.comp |
| (Polynomial.C 100*(Polynomial.X+Polynomial.C 1)^2) |
|
|
| lemma clauses_bound (H : RoundTables.BaseTable) (b : List Bool) : |
| (gapInput H b).val.clauses.length ≤ clausePolynomial.eval b.length := by |
| have h0 := Hastad.SourceBounds.formulaBits_length_ge_clauses (gapInput H b).val |
| have h1 := TableIteration.gapMap_bits_le H (BinaryNormalize.normalize b) |
| have h2 := MachineComposition.natPolynomial_eval_mono TableIteration.formulaBitsPolynomial (normalize_bits b) |
| apply h0.trans (h1.trans _) |
| simpa only [clausePolynomial,Polynomial.eval_comp,Polynomial.eval_mul,Polynomial.eval_C, |
| Polynomial.eval_pow,Polynomial.eval_add,Polynomial.eval_X] using h2 |
|
|
| def vertexPolynomial (p : SamplerParameters) (u q : ℕ) : Polynomial ℕ := |
| Polynomial.C q + (Polynomial.C 3*clausePolynomial)^(u*p.n) * |
| Polynomial.C (GeometryNames.outcomeCount (J u) (I u) p) |
|
|
| lemma vertices_bound (H : RoundTables.BaseTable) (p : SamplerParameters) (u q : ℕ) (hq : 0<q) |
| (b : List Bool) : (reduce H p u q hq b).vertices ≤ |
| (vertexPolynomial p u q).eval b.length := by |
| have hs : (reduce H p u q hq b).vertices ≤ q+ |
| ((gapInput H b).val.clauses.length*3)^(u*p.n)*GeometryNames.outcomeCount (J u) (I u) p := by |
| unfold reduce GeometryNames.output |
| split |
| · change q ≤ _ |
| omega |
| · change (TargetLC.table u (gapInput H b)).ne^p.n*GeometryNames.outcomeCount (J u) (I u) p ≤ _ |
| simp only [TargetLC.table,← pow_mul] |
| omega |
| apply hs.trans |
| simp only [vertexPolynomial,Polynomial.eval_add,Polynomial.eval_C,Polynomial.eval_mul,Polynomial.eval_pow] |
| apply Nat.add_le_add_left |
| apply Nat.mul_le_mul_right |
| apply Nat.pow_le_pow_left |
| nlinarith [clauses_bound H b] |
|
|
| def outputPolynomial (p : SamplerParameters) (u q : ℕ) : Polynomial ℕ := |
| Polynomial.C 4*(vertexPolynomial p u q+Polynomial.C 1)^2 |
|
|
| lemma output_bound (H : RoundTables.BaseTable) (p : SamplerParameters) (u q : ℕ) (hq : 0<q) |
| (b : List Bool) : (graphBits (reduce H p u q hq b)).length ≤ |
| (outputPolynomial p u q).eval b.length := by |
| apply (graphBits_bound _).trans |
| simp only [outputPolynomial,Polynomial.eval_mul,Polynomial.eval_C,Polynomial.eval_add,Polynomial.eval_pow] |
| exact Nat.mul_le_mul_left 4 (Nat.pow_le_pow_left |
| (Nat.add_le_add_right (vertices_bound H p u q hq b) 1) 2) |
|
|
| lemma complete (H : RoundTables.BaseTable) (p : SamplerParameters) (u q : ℕ) (hq : 0<q) |
| (F : Formula) (hF : F.Satisfiable) : (reduce H p u q hq (formulaBits F)).ThreeColorable := by |
| have hgap : (gapInput H (formulaBits F)).val.Satisfiable := |
| TableIteration.gapMap_completeness H _ ((BinaryNormalize.satisfiable_iff F).mpr hF) |
| obtain ⟨l,r,hr⟩ := TargetLC.complete u (gapInput H (formulaBits F)) hgap |
| exact (GeometryNames.outputRenaming (J u) (I u) p q hq (TargetLC.table u (gapInput H (formulaBits F)))).symm.colorable |
| (p.output_complete q hq _ l r hr) |
|
|
| end CompleteReduction |
|
|
| theorem mainTheoremReal : |
| ∀ δ : ℝ, 0 < δ → δ < 1 / 3 → Nonempty (RealGraphReduction δ) := by |
| intro δ hδ _hδ3 |
| obtain ⟨H,hH⟩ := PCP.ExpanderTables.exists_base_table |
| obtain ⟨p,σ,q,hq,hσ,_hσ1,hp⟩ := finite_graph_reduction hδ |
| obtain ⟨u,_hu,hrep⟩ := LCInput.uniform_repetition |
| PCP.PCPIteration.finalClauseGap_positive PCP.TableGapReduction.finalClauseGap_le_one hσ |
| refine ⟨{ |
| reduce := CompleteReduction.reduce H p u q hq |
| computation := CompleteReduction.certificate H p u q hq |
| finiteAlphabets := CompleteReduction.finiteAlphabet H p u q hq |
| outputBound := CompleteReduction.outputPolynomial p u q |
| outputSize := CompleteReduction.output_bound H p u q hq |
| completeness := CompleteReduction.complete H p u q hq |
| soundness := ?_ }⟩ |
| intro F hF |
| have hg : Hastad.SourceGap.ClauseGap (CompleteReduction.gapInput H (formulaBits F)).val |
| PCP.PCPIteration.finalClauseGap := |
| PCP.TableGapReduction.gapMap_clauseGap H hH _ |
| (fun h => hF ((BinaryNormalize.satisfiable_iff F).mp h)) |
| have hs := TargetLC.sound u (CompleteReduction.gapInput H (formulaBits F)) (hrep _ hg) |
| have hout := (hp _ _ _ _ _ (TargetLC.table u (CompleteReduction.gapInput H (formulaBits F))).lc).2 hs |
| exact (GeometryNames.outputRenaming (Hastad.SourceContexts.J u) (Hastad.SourceContexts.I u) p q hq |
| (TargetLC.table u (CompleteReduction.gapInput H (formulaBits F)))).symm.strict_density hout |
|
|
| end |
| end LargeIndependentSets |
|
|
| end OAI |
|
|
