| import Mathlib |
| import OAI.Combinatorics.IndependentSets.PCP.ClausePolynomial |
| import OAI.Combinatorics.IndependentSets.Encoding.BitsValue |
|
|
| namespace OAI |
|
|
| namespace LargeIndependentSets |
|
|
| section |
| open IndependentSetsGames.Foundations |
| noncomputable section |
| namespace SemanticReduction |
|
|
| def total (H : PCP.RoundTables.BaseTable) (p : SamplerParameters) (u q : ℕ) (hq : 0<q) |
| (b : List Bool) : Graph := reduce H p u q hq (BinaryParser.decode b) |
|
|
| def totalPolynomial (p : SamplerParameters) (u q : ℕ) : Polynomial ℕ := |
| (outputPolynomial p u q).comp (Polynomial.X+Polynomial.C 1) |
|
|
| lemma total_output_bound (H : PCP.RoundTables.BaseTable) (p : SamplerParameters) (u q : ℕ) (hq : 0<q) |
| (b : List Bool) : (graphBits (total H p u q hq b)).length ≤ (totalPolynomial p u q).eval b.length := by |
| apply (output_polynomial H p u q hq (BinaryParser.decode b)).trans |
| have hh := Complexity.MachineComposition.natPolynomial_eval_mono |
| (outputPolynomial p u q) (BinaryParser.decode_bits_bound b) |
| simpa only [totalPolynomial,Polynomial.eval_comp,Polynomial.eval_add,Polynomial.eval_X, |
| Polynomial.eval_C] using hh |
|
|
| end SemanticReduction |
|
|
| theorem total_semantic_polynomial_output_reduction {δ : ℚ} (hδ : 0<δ) : |
| ∃ reduce : List Bool → Graph, ∃ P : Polynomial ℕ, |
| (∀ b, (graphBits (reduce b)).length ≤ P.eval b.length) ∧ |
| (∀ F : Formula, F.Satisfiable → (reduce (formulaBits F)).ThreeColorable) ∧ |
| (∀ F : Formula, ¬F.Satisfiable → |
| ((reduce (formulaBits F)).independenceNumber : ℚ) < δ*(reduce (formulaBits F)).vertices) := by |
| obtain ⟨H,p,u,q,hq,hyes,hno⟩ := semantic_reduction hδ |
| refine ⟨SemanticReduction.total H p u q hq,SemanticReduction.totalPolynomial p u q, |
| SemanticReduction.total_output_bound H p u q hq,?_,?_⟩ |
| · intro F hF |
| simpa only [SemanticReduction.total,BinaryParser.decode_encoded] using hyes F hF |
| · intro F hF |
| simpa only [SemanticReduction.total,BinaryParser.decode_encoded] using hno F hF |
|
|
| end |
| end |
|
|
| namespace ShortestPaths |
| open scoped ENNReal |
|
|
| def pivot {X A : Type*} [Min A] [Add A] (w : X → X → A) (k : X) (x y : X) : A := |
| min (w x y) (w x k + w k y) |
|
|
| def closure {X A : Type*} [Min A] [Add A] (w : X → X → A) : List X → X → X → A |
| | [] => w |
| | k::ks => closure (pivot w k) ks |
|
|
| lemma pivot_le {X : Type*} (w : X → X → ℝ≥0∞) (k x y : X) : pivot w k x y ≤ w x y := |
| min_le_left _ _ |
|
|
| lemma pivot_at {X : Type*} (w : X → X → ℝ≥0∞) (k x y : X) : |
| pivot w k x y ≤ pivot w k x k + pivot w k k y := by |
| simp only [pivot, min_eq_left (le_self_add), min_eq_left (le_add_self)] |
| exact min_le_right _ _ |
|
|
| lemma pivot_preserves {X : Type*} (w : X → X → ℝ≥0∞) (k z : X) |
| (h : ∀ x y, w x y ≤ w x z + w z y) : |
| ∀ x y, pivot w k x y ≤ pivot w k x z + pivot w k z y := by |
| intro x y |
| unfold pivot |
| rw [min_add,add_min,add_min] |
| apply le_min |
| · apply le_min |
| · exact (min_le_left _ _).trans (h x y) |
| · exact (min_le_right _ _).trans (by |
| simpa only [add_assoc,add_comm,add_left_comm] using add_le_add_right (h x k) (w k y)) |
| · apply le_min |
| · exact (min_le_right _ _).trans (by |
| simpa only [add_assoc,add_comm,add_left_comm] using add_le_add_left (h k y) (w x k)) |
| · exact (min_le_right _ _).trans (by |
| have hh : w x k + w k y ≤ w x k + (w k z + w z k) + w k y := |
| add_le_add le_self_add le_rfl |
| simpa only [add_assoc,add_comm,add_left_comm] using hh) |
|
|
| lemma closure_le {X : Type*} (w : X → X → ℝ≥0∞) (ks : List X) (x y : X) : |
| closure w ks x y ≤ w x y := by |
| induction ks generalizing w with |
| | nil => exact le_rfl |
| | cons k ks ih => exact (ih _).trans (pivot_le _ _ _ _) |
|
|
| lemma closure_preserves {X : Type*} (w : X → X → ℝ≥0∞) (ks : List X) (z : X) |
| (h : ∀ x y, w x y ≤ w x z + w z y) : |
| ∀ x y, closure w ks x y ≤ closure w ks x z + closure w ks z y := by |
| induction ks generalizing w with |
| | nil => exact h |
| | cons k ks ih => exact ih _ (pivot_preserves w k z h) |
|
|
| lemma closure_at {X : Type*} (w : X → X → ℝ≥0∞) (ks : List X) {z : X} (hz : z ∈ ks) : |
| ∀ x y, closure w ks x y ≤ closure w ks x z + closure w ks z y := by |
| induction ks generalizing w with |
| | nil => simp at hz |
| | cons k ks ih => |
| rcases List.mem_cons.mp hz with he | hz |
| · subst z |
| exact closure_preserves _ ks k (pivot_at w k) |
| · exact ih _ hz |
|
|
| lemma distance_le_closure {X : Type*} (w : X → X → ℝ≥0∞) (ks : List X) (x y : X) : |
| pathDistance w x y ≤ closure w ks x y := by |
| have h : ∀ (v : X → X → ℝ≥0∞), (∀ x y, pathDistance w x y ≤ v x y) → |
| ∀ x y, pathDistance w x y ≤ closure v ks x y := by |
| induction ks with |
| | nil => intro v hv; exact hv |
| | cons k ks ih => |
| intro v hv |
| apply ih |
| intro x y |
| exact le_min (hv x y) ((pathDistance_triangle w x k y).trans (add_le_add (hv x k) (hv k y))) |
| exact h w (pathDistance_le_link w) x y |
|
|
| theorem closure_eq_distance {X : Type*} (w : X → X → ℝ≥0∞) (ks : List X) |
| (hks : ∀ z, z ∈ ks) (x y : X) : closure w ks x y = pathDistance w x y := by |
| apply le_antisymm ?_ (distance_le_closure w ks x y) |
| apply le_iInf |
| intro zs |
| induction zs generalizing x with |
| | nil => exact closure_le w ks x y |
| | cons z zs ih => |
| exact (closure_at w ks (hks z) x y).trans (add_le_add (closure_le w ks x z) (ih z)) |
|
|
| lemma closure_map {X A B : Type*} [Min A] [Add A] [Min B] [Add B] |
| (f : A → B) (hfmin : ∀ a b, f (min a b) = min (f a) (f b)) |
| (hfadd : ∀ a b, f (a+b) = f a+f b) (w : X → X → A) (ks : List X) : |
| (fun x y => f (closure w ks x y)) = closure (fun x y => f (w x y)) ks := by |
| induction ks generalizing w with |
| | nil => rfl |
| | cons k ks ih => |
| simp only [closure] |
| rw [ih] |
| congr 1 |
| funext x y |
| simp only [pivot,hfmin,hfadd] |
|
|
| abbrev Matrix (n : ℕ) := Vector (Vector ℕ∞ n) n |
|
|
| def Matrix.get {n : ℕ} (a : Matrix n) (i j : Fin n) : ℕ∞ := a[i.val][j.val] |
|
|
| def Matrix.pivot {n : ℕ} (a : Matrix n) (k : Fin n) : Matrix n := |
| letI : Min ℕ∞ := @LinearOrder.toMin ℕ∞ instLinearOrderENat |
| Vector.ofFn (fun i => Vector.ofFn (fun j => ShortestPaths.pivot a.get k i j)) |
|
|
| def Matrix.run {n : ℕ} (a : Matrix n) : List (Fin n) → Matrix n |
| | [] => a |
| | k::ks => (a.pivot k).run ks |
|
|
| lemma Matrix.run_get {n : ℕ} (a : Matrix n) (ks : List (Fin n)) : |
| (a.run ks).get = closure a.get ks := by |
| induction ks generalizing a with |
| | nil => rfl |
| | cons k ks ih => |
| rw [Matrix.run,ih] |
| simp only [closure] |
| congr 1 |
| funext i j |
| simp [Matrix.pivot, Matrix.get] |
|
|
| def Matrix.allPairs {n : ℕ} (a : Matrix n) : Matrix n := a.run (List.finRange n) |
|
|
| theorem Matrix.allPairs_exact {n : ℕ} (a : Matrix n) (i j : Fin n) : |
| ((a.allPairs.get i j : ℕ∞) : ℝ≥0∞) = |
| pathDistance (fun x y => (a.get x y : ℝ≥0∞)) i j := by |
| rw [Matrix.allPairs,Matrix.run_get] |
| have hm := congrFun (congrFun (closure_map (fun z : ℕ∞ => (z:ℝ≥0∞)) |
| ENat.toENNReal_min ENat.toENNReal_add a.get (List.finRange n)) i) j |
| rw [hm] |
| exact closure_eq_distance _ _ (fun z => List.mem_finRange z) i j |
|
|
| end ShortestPaths |
| end LargeIndependentSets |
|
|
| end OAI |
|
|
