| import Mathlib |
| import OAI.Computability.VertexCover.PCP.ExpanderFamily |
|
|
| namespace OAI |
|
|
| |
|
|
| namespace UniqueGames.Foundations.PCP.ExpanderTables |
|
|
| open PoweringWalks SpectralReturn |
|
|
| def rowIndex (v d : Nat) : Fin v × Fin d ≃ Fin (v * d) := finProdFinEquiv |
|
|
| theorem rowIndex_val (v d : Nat) (x : Fin v × Fin d) : |
| (rowIndex v d x).val = x.2.val + d * x.1.val := rfl |
|
|
| structure Table (v d : Nat) where |
| rows : Vector (Fin (v * d)) (v * d) |
| involutive : Function.Involutive (fun i : Fin (v * d) => rows[i]) |
|
|
| def reverseIndex {v d : Nat} (table : Table v d) (i : Fin (v * d)) : Fin (v * d) := |
| table.rows[i] |
|
|
| def lookup {v d : Nat} (table : Table v d) (x : Fin v × Fin d) : Fin v × Fin d := |
| (rowIndex v d).symm (reverseIndex table (rowIndex v d x)) |
|
|
| theorem lookup_involutive {v d : Nat} (table : Table v d) : |
| Function.Involutive (lookup table) := by |
| intro x |
| simp only [lookup, Equiv.apply_symm_apply] |
| exact (congrArg (rowIndex v d).symm (table.involutive (rowIndex v d x))).trans |
| ((rowIndex v d).symm_apply_apply x) |
|
|
| def graph {v d : Nat} (table : Table v d) : PortGraph (Fin v) (Fin d) where |
| rot := ZigzagGraphs.involutionEquiv (lookup table) (lookup_involutive table) |
| rot_involutive := lookup_involutive table |
|
|
| @[simp] theorem graph_rot {v d : Nat} (table : Table v d) (x : Fin v × Fin d) : |
| (graph table).rot x = lookup table x := rfl |
|
|
| def ofGraph {v d : Nat} (G : PortGraph (Fin v) (Fin d)) : Table v d where |
| rows := Vector.ofFn (fun i => rowIndex v d (G.rot ((rowIndex v d).symm i))) |
| involutive := by |
| intro i |
| simp only [Fin.getElem_fin, Vector.getElem_ofFn, Fin.eta, Equiv.symm_apply_apply] |
| exact (congrArg (rowIndex v d) (G.rot_involutive ((rowIndex v d).symm i))).trans |
| ((rowIndex v d).apply_symm_apply i) |
|
|
| @[simp] theorem lookup_ofGraph {v d : Nat} (G : PortGraph (Fin v) (Fin d)) |
| (x : Fin v × Fin d) : lookup (ofGraph G) x = G.rot x := by |
| simp only [lookup, reverseIndex, ofGraph, Fin.getElem_fin, Vector.getElem_ofFn, Fin.eta, |
| Equiv.symm_apply_apply] |
|
|
| private theorem graph_ext {V D : Type*} {G H : PortGraph V D} |
| (h : ∀ x, G.rot x = H.rot x) : G = H := by |
| have hr : G.rot = H.rot := Equiv.ext h |
| cases G |
| cases H |
| cases hr |
| rfl |
|
|
| @[simp] theorem graph_ofGraph {v d : Nat} (G : PortGraph (Fin v) (Fin d)) : |
| graph (ofGraph G) = G := graph_ext (lookup_ofGraph G) |
|
|
| theorem row_count {v d : Nat} (table : Table v d) : table.rows.toList.length = v * d := by |
| simp |
|
|
| def vertexIndex (v q : Nat) : Fin v × (Fin q × Fin q) ≃ Fin (v * (q * q)) := |
| (Equiv.prodCongr (Equiv.refl _) (rowIndex q q)).trans (rowIndex v (q * q)) |
|
|
| def stepGraph {v d : Nat} (G : Table v (d * d)) |
| (H : Table ((d * d) * (d * d)) d) : |
| PortGraph (Fin (v * ((d * d) * (d * d)))) (Fin (d * d)) := |
| GraphTransport.reindex |
| (ZigzagGraphs.zigzag (ZigzagGraphs.square (graph G)) |
| (GraphTransport.reindex (graph H) (rowIndex (d * d) (d * d)).symm (Equiv.refl _))) |
| (vertexIndex v (d * d)) (rowIndex d d) |
|
|
| def step {v d : Nat} (G : Table v (d * d)) |
| (H : Table ((d * d) * (d * d)) d) : |
| Table (v * ((d * d) * (d * d))) (d * d) := ofGraph (stepGraph G H) |
|
|
| def stepLookup {v d : Nat} (G : Table v (d * d)) |
| (H : Table ((d * d) * (d * d)) d) |
| (x : Fin (v * ((d * d) * (d * d))) × Fin (d * d)) : |
| Fin (v * ((d * d) * (d * d))) × Fin (d * d) := |
| let vc := (rowIndex v ((d * d) * (d * d))).symm x.1 |
| let ports := (rowIndex d d).symm x.2 |
| let first := lookup H (vc.2, ports.1) |
| let squarePorts := (rowIndex (d * d) (d * d)).symm first.1 |
| let outerFirst := lookup G (vc.1, squarePorts.1) |
| let outerSecond := lookup G (outerFirst.1, squarePorts.2) |
| let last := lookup H (rowIndex (d * d) (d * d) (outerSecond.2, outerFirst.2), ports.2) |
| (rowIndex v ((d * d) * (d * d)) (outerSecond.1, last.1), |
| rowIndex d d (last.2, first.2)) |
|
|
| theorem lookup_step {v d : Nat} (G : Table v (d * d)) |
| (H : Table ((d * d) * (d * d)) d) |
| (x : Fin (v * ((d * d) * (d * d))) × Fin (d * d)) : |
| lookup (step G H) x = stepLookup G H x := by |
| simp [step, stepGraph, GraphTransport.reindex, |
| Equiv.trans_apply, Equiv.prodCongr_apply, |
| Equiv.prodCongr_symm, Equiv.refl_apply, vertexIndex, Equiv.apply_symm_apply, |
| ZigzagGraphs.zigzag, ZigzagGraphs.square, ZigzagGraphs.involutionEquiv, |
| ZigzagGraphs.cloudFirst, ZigzagGraphs.crossCloud, graph_rot, |
| stepLookup, Prod.map, Equiv.symm_symm] |
| all_goals repeat' constructor |
|
|
| theorem step_certificate {v d : Nat} [NeZero v] [NeZero d] |
| (G : Table v (d * d)) (H : Table ((d * d) * (d * d)) d) |
| (hG : SpectralCertificate (graph G) (1 / 2 : ℝ)) |
| (hH : SpectralCertificate (graph H) (1 / 100 : ℝ)) : |
| SpectralCertificate (graph (step G H)) (1 / 2 : ℝ) := by |
| rw [step, graph_ofGraph] |
| apply GraphTransport.reindex_spectralCertificate |
| apply ZigzagSpectral.square_zigzag_halfCertificate |
| · exact hG |
| · exact GraphTransport.reindex_spectralCertificate _ _ _ _ hH |
|
|
| def initial (d : Nat) : Table 1 (d * d) := |
| ofGraph { rot := Equiv.refl _, rot_involutive := fun _ => rfl } |
|
|
| theorem initial_certificate (d : Nat) : |
| SpectralCertificate (graph (initial d)) (1 / 2 : ℝ) := by |
| refine ⟨by norm_num, by norm_num, ?_⟩ |
| intro f hf |
| have hfun : f = fun _ => f 0 := funext (fun x => congrArg f (Subsingleton.elim x 0)) |
| have hm : mean f = f 0 := (congrArg mean hfun).trans (mean_const _) |
| have hz : f 0 = 0 := hm.symm.trans hf |
| rw [hfun, hz] |
| simp [energy, mean, averagingOperator] |
|
|
| def vertexCount (q : Nat) : Nat → Nat |
| | 0 => 1 |
| | n + 1 => vertexCount q n * (q * q) |
|
|
| theorem vertexCount_eq (q n : Nat) : vertexCount q n = (q * q) ^ n := by |
| induction n with |
| | zero => rfl |
| | succ n ih => simp only [vertexCount, ih, pow_succ] |
|
|
| theorem vertexCount_positive {q : Nat} (hq : 0 < q) (n : Nat) : |
| 0 < vertexCount q n := by |
| rw [vertexCount_eq] |
| exact Nat.pow_pos (Nat.mul_pos hq hq) |
|
|
| def family {d : Nat} (H : Table ((d * d) * (d * d)) d) : |
| (n : Nat) → Table (vertexCount (d * d) n) (d * d) |
| | 0 => initial d |
| | n + 1 => step (family H n) H |
|
|
| theorem family_certificate {d : Nat} [NeZero d] |
| (H : Table ((d * d) * (d * d)) d) |
| (hH : SpectralCertificate (graph H) (1 / 100 : ℝ)) (n : Nat) : |
| SpectralCertificate (graph (family H n)) (1 / 2 : ℝ) := by |
| induction n with |
| | zero => exact initial_certificate d |
| | succ n ih => |
| let : NeZero (vertexCount (d * d) n) := |
| ⟨Nat.ne_of_gt (vertexCount_positive (Nat.mul_pos (NeZero.pos d) (NeZero.pos d)) n)⟩ |
| exact step_certificate _ _ ih hH |
|
|
| theorem family_row_count {d : Nat} (H : Table ((d * d) * (d * d)) d) (n : Nat) : |
| (family H n).rows.toList.length = ((d * d) * (d * d)) ^ n * (d * d) := by |
| rw [row_count, vertexCount_eq] |
|
|
| theorem exists_base_table : ∃ H : Table |
| ((Expanders.baseDegree * Expanders.baseDegree) * |
| (Expanders.baseDegree * Expanders.baseDegree)) Expanders.baseDegree, |
| SpectralCertificate (graph H) (1 / 100 : ℝ) := by |
| classical |
| have hv : Fintype.card ExpanderFamily.CloudPort = |
| (Expanders.baseDegree * Expanders.baseDegree) * |
| (Expanders.baseDegree * Expanders.baseDegree) := by |
| rw [ExpanderFamily.card_cloudPort] |
| unfold ExpanderFamily.growth |
| ring |
| let vertices := Fintype.equivFinOfCardEq hv |
| let ports := Fintype.equivFinOfCardEq Expanders.card_basePort |
| let G := GraphTransport.reindex ExpanderFamily.baseOnCloud vertices ports |
| refine ⟨ofGraph G, ?_⟩ |
| rw [graph_ofGraph] |
| exact GraphTransport.reindex_spectralCertificate _ _ _ _ |
| ExpanderFamily.baseOnCloud_certificate |
|
|
| end UniqueGames.Foundations.PCP.ExpanderTables |
|
|
| end OAI |
|
|
