| import Mathlib |
| import OAI.Computability.VertexCover.Machines.ExpanderCorrect |
|
|
| namespace OAI |
|
|
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| |
| section |
|
|
| namespace VertexCover.Machine |
| open UniqueGames.Foundations.PCP |
|
|
| theorem listBits_length_bound {α : Type} (e : α → List Bool) (xs : List α) (B : ℕ) |
| (h : ∀ x ∈ xs, (e x).length ≤ B) : |
| (listBits e xs).length ≤ xs.length*(2*B+2)+1 := by |
| induction xs with |
| | nil => simp |
| | cons x xs ih => |
| have hx := h x (by simp) |
| have ht := ih (fun a ha => h a (by simp [ha])) |
| simp only [List.length_cons,listBits_cons_length] |
| nlinarith |
|
|
| namespace ExpandMachine |
|
|
| noncomputable def verticesPoly {q : ℕ} : Poly (code (q := q)) natBits Sigma.fst := |
| (Poly.fst natBits (listBits natBits)).encodeCongr erase (fun _ => rfl) (fun _ => rfl) |
|
|
| theorem code_bound {q : ℕ} (T : Input q) : |
| (code T).length ≤ 2*T.1+2+(T.1*q)*(2*(T.1*q)+2) := by |
| have hb := listBits_length_bound natBits (T.2.rows.toList.map Fin.val) (T.1*q) (by |
| intro x hx |
| obtain ⟨i,_,rfl⟩ := List.mem_map.mp hx |
| simpa only [natBits_length] using Nat.le_of_lt i.isLt) |
| simp only [List.length_map,Vector.length_toList] at hb |
| simp only [code,dataCode,erase,prodBits,pairBits_length,natBits_length] |
| omega |
|
|
| theorem vertices_le_code {q : ℕ} (T : Input q) : T.1 ≤ (code T).length := by |
| simp only [code,dataCode,erase,prodBits,pairBits_length,natBits_length] |
| omega |
|
|
| def capped {d : ℕ} (H : ExpanderTables.Table ((d*d)*(d*d)) d) |
| (p : ℕ × Input (d*d)) : ℕ × Input (d*d) := |
| (p.1,if p.1 ≤ p.2.1 then p.2 else step H p.2) |
|
|
| noncomputable def cappedPoly {d : ℕ} (H : ExpanderTables.Table ((d*d)*(d*d)) d) : |
| Poly (prodBits natBits (code (q := d*d))) (prodBits natBits code) (capped H) := by |
| let ck := Poly.fst natBits (code (q := d*d)) |
| let ct := Poly.snd natBits (code (q := d*d)) |
| let test := (ck.pair (ct.comp verticesPoly)).comp Poly.natLE |
| exact ck.pair ((test.ite ct (ct.comp (stepPoly H))).congr (fun p => by simp)) |
|
|
| theorem capped_vertex_bound {d : ℕ} (H : ExpanderTables.Table ((d*d)*(d*d)) d) |
| (p : ℕ × Input (d*d)) : (capped H p).2.1 ≤ p.2.1+((d*d)*(d*d))*p.1 := by |
| dsimp only [capped] |
| split |
| · omega |
| · rename_i h |
| have hm := Nat.mul_le_mul_right ((d*d)*(d*d)) (Nat.le_of_lt (Nat.lt_of_not_ge h)) |
| dsimp only [step] |
| nlinarith |
|
|
| theorem capped_iterate_bound {d : ℕ} (H : ExpanderTables.Table ((d*d)*(d*d)) d) |
| (n : ℕ) (p : ℕ × Input (d*d)) : |
| (Iterate.run (capped H) n p).1=p.1 ∧ |
| (Iterate.run (capped H) n p).2.1 ≤ max p.2.1 (((d*d)*(d*d))*p.1) := by |
| induction n generalizing p with |
| | zero => exact ⟨rfl,Nat.le_max_left _ _⟩ |
| | succ n ih => |
| have hh := ih (capped H p) |
| refine ⟨hh.1,hh.2.trans ?_⟩ |
| apply max_le |
| · simp only [capped] |
| split |
| · exact Nat.le_max_left _ _ |
| · rename_i h |
| change p.2.1*((d*d)*(d*d)) ≤ _ |
| rw [Nat.mul_comm] |
| exact (Nat.mul_le_mul_left _ (Nat.le_of_lt (Nat.lt_of_not_ge h))).trans (Nat.le_max_right _ _) |
| · exact Nat.le_max_right _ _ |
|
|
| theorem encoding_bound (q g n p v₀ v l N L : ℕ) |
| (hn : n ≤ N) (hp : p ≤ N) (hv : v₀ ≤ N) (hl : l ≤ n) |
| (hb : v ≤ max v₀ (g*p)) (hlen : L ≤ 2*v+2+(v*q)*(2*(v*q)+2)) : |
| 2*l+1+(2*p+1+L) ≤ 20*((g+1)*(q+1)+1)^2*(N+1)^2 := by |
| let C := g+1 |
| let R := C*(q+1)+1 |
| let B := R*(N+1) |
| have hm : v ≤ C*N := by |
| apply hb.trans |
| apply max_le |
| · dsimp [C]; nlinarith only [hv,Nat.zero_le (g*N)] |
| · exact (Nat.mul_le_mul_left g hp).trans (by dsimp [C]; nlinarith only [Nat.zero_le N]) |
| have hr : 1 ≤ R := by dsimp [R]; omega |
| have hc : C ≤ R := by dsimp [R]; nlinarith only [Nat.zero_le (C*q)] |
| have hcq : C*q ≤ R := by dsimp [R]; nlinarith only [Nat.zero_le C] |
| have hB : 1 ≤ B := Nat.mul_le_mul hr (Nat.succ_le_succ (Nat.zero_le N)) |
| have hNB : N ≤ B := (Nat.le_succ N).trans (by |
| simpa only [one_mul] using Nat.mul_le_mul_right (N+1) hr) |
| have hvB : v ≤ B := hm.trans (Nat.mul_le_mul hc (Nat.le_succ N)) |
| have hqB : v*q ≤ B := by |
| calc |
| v*q ≤ C*N*q := Nat.mul_le_mul_right q hm |
| _ = (C*q)*N := by ring |
| _ ≤ B := Nat.mul_le_mul hcq (Nat.le_succ N) |
| have hsquare := Nat.mul_le_mul hqB hqB |
| have hlinear : B ≤ B*B := by simpa only [one_mul] using Nat.mul_le_mul_right B hB |
| have hlB := (hl.trans hn).trans hNB |
| have hpB := hp.trans hNB |
| change _ ≤ 20*R^2*(N+1)^2 |
| rw [show 20*R^2*(N+1)^2=20*B^2 by dsimp [B]; ring] |
| nlinarith only [hB,hlinear,hvB,hqB,hsquare,hlen,hlB,hpB] |
|
|
| noncomputable def cappedIteratePoly {d : ℕ} (H : ExpanderTables.Table ((d*d)*(d*d)) d) : |
| Poly (prodBits natBits (prodBits natBits (code (q := d*d)))) |
| (prodBits natBits code) (fun p => Iterate.run (capped H) p.1 p.2) := by |
| let g := (d*d)*(d*d) |
| let Q := d*d |
| let size : Polynomial ℕ := Polynomial.C (20*((g+1)*(Q+1)+1)^2)*(Polynomial.X+1)^2 |
| apply Poly.iterate _ (cappedPoly H) size |
| intro n p k l h |
| let N := (prodBits natBits (prodBits natBits (code (q := d*d))) (n,p)).length |
| have hn : n ≤ N := by dsimp [N,prodBits]; simp only [pairBits_length,natBits_length]; omega |
| have hp : p.1 ≤ N := by dsimp [N,prodBits]; simp only [pairBits_length,natBits_length]; omega |
| have hv : p.2.1 ≤ N := by |
| have hh := vertices_le_code p.2 |
| dsimp [N,prodBits]; simp only [pairBits_length,natBits_length]; omega |
| have hb := capped_iterate_bound H k p |
| change (prodBits natBits (prodBits natBits (code (q := d*d))) |
| (l,Iterate.run (capped H) k p)).length ≤ size.eval N |
| simp only [prodBits,pairBits_length,natBits_length,hb.1,size, |
| Polynomial.eval_mul,Polynomial.eval_C,Polynomial.eval_pow, |
| Polynomial.eval_add,Polynomial.eval_X,Polynomial.eval_one] |
| exact encoding_bound Q g n p.1 p.2.1 _ l N _ hn hp hv (by omega) hb.2 (code_bound _) |
|
|
| end ExpandMachine |
| end VertexCover.Machine |
| end |
|
|
|
|
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
|
|
| end OAI |
|
|
