openAI-math-dataset / lean /OAI /Combinatorics /IndependentSets /Expansion /PreprocessingLevels.lean
| import Mathlib | |
| import OAI.Combinatorics.IndependentSets.Expansion.ExpanderTables | |
| namespace OAI | |
| namespace IndependentSetsGames.Foundations.PCP.PreprocessingLevels | |
| def levelLoop (g k : Nat) : Nat → Nat → Nat → Nat × Nat | |
| | 0, e, s => (e, s) | |
| | fuel + 1, e, s => | |
| if k ≤ s then (e, s) | |
| else levelLoop g k fuel (e + 1) (s * g) | |
| theorem levelLoop_level_le (g k fuel e s : Nat) : | |
| (levelLoop g k fuel e s).1 ≤ e + fuel := by | |
| induction fuel generalizing e s with | |
| | zero => simp only [levelLoop, Nat.add_zero, le_refl] | |
| | succ fuel ih => | |
| simp only [levelLoop] | |
| split | |
| · omega | |
| · have h := ih (e + 1) (s * g) | |
| omega | |
| theorem levelLoop_power (g k fuel e : Nat) : | |
| (levelLoop g k fuel e (g ^ e)).2 = | |
| g ^ (levelLoop g k fuel e (g ^ e)).1 := by | |
| induction fuel generalizing e with | |
| | zero => rfl | |
| | succ fuel ih => | |
| simp only [levelLoop] | |
| split | |
| · rfl | |
| · simpa only [pow_succ] using ih (e + 1) | |
| theorem levelLoop_covers (g k fuel e s : Nat) (hg : 1 < g) | |
| (hs : 0 < s) (hbudget : k ≤ s + fuel) : | |
| k ≤ (levelLoop g k fuel e s).2 := by | |
| induction fuel generalizing e s with | |
| | zero => simpa only [levelLoop, Nat.add_zero] using hbudget | |
| | succ fuel ih => | |
| simp only [levelLoop] | |
| split | |
| · assumption | |
| · apply ih | |
| · exact Nat.mul_pos hs (by omega) | |
| · have htwo : 2 ≤ g := by omega | |
| have hmul : s * 2 ≤ s * g := Nat.mul_le_mul_left s htwo | |
| omega | |
| theorem levelLoop_le_of_covering_power (g k fuel e j : Nat) | |
| (he : e ≤ j) (hj : k ≤ g ^ j) : | |
| (levelLoop g k fuel e (g ^ e)).1 ≤ j := by | |
| induction fuel generalizing e with | |
| | zero => exact he | |
| | succ fuel ih => | |
| simp only [levelLoop] | |
| split | |
| · exact he | |
| · rename_i hnot | |
| have hne : e ≠ j := by | |
| intro h | |
| subst e | |
| exact hnot hj | |
| have hnext : e + 1 ≤ j := by omega | |
| simpa only [pow_succ] using ih (e + 1) hnext | |
| def searchResult (k : Nat) : Nat × Nat := | |
| levelLoop ExpanderFamily.growth k k 0 1 | |
| def boundedLevel (k : Nat) : Nat := (searchResult k).1 | |
| def paddedSize (k : Nat) : Nat := (searchResult k).2 | |
| @[simp] theorem boundedLevel_zero : boundedLevel 0 = 0 := rfl | |
| @[simp] theorem paddedSize_zero : paddedSize 0 = 1 := rfl | |
| theorem boundedLevel_le_input (k : Nat) : boundedLevel k ≤ k := by | |
| simpa only [boundedLevel, searchResult, Nat.zero_add] using | |
| levelLoop_level_le ExpanderFamily.growth k k 0 1 | |
| theorem paddedSize_power (k : Nat) : | |
| paddedSize k = ExpanderFamily.growth ^ boundedLevel k := by | |
| simpa only [paddedSize, boundedLevel, searchResult, pow_zero] using | |
| levelLoop_power ExpanderFamily.growth k k 0 | |
| theorem le_paddedSize (k : Nat) : k ≤ paddedSize k := by | |
| exact levelLoop_covers ExpanderFamily.growth k k 0 1 | |
| ExpanderFamily.growth_gt_one (by omega) (by omega) | |
| theorem boundedLevel_eq_level (k : Nat) : | |
| boundedLevel k = ExpanderFamily.level k := by | |
| apply Nat.le_antisymm | |
| · simpa only [boundedLevel, searchResult, pow_zero] using | |
| levelLoop_le_of_covering_power ExpanderFamily.growth k k 0 | |
| (ExpanderFamily.level k) (Nat.zero_le _) (ExpanderFamily.le_size k) | |
| · apply (Nat.clog_le_iff_le_pow ExpanderFamily.growth_gt_one).2 | |
| rw [← paddedSize_power] | |
| exact le_paddedSize k | |
| theorem paddedSize_eq_size (k : Nat) : paddedSize k = ExpanderFamily.size k := by | |
| rw [paddedSize_power, boundedLevel_eq_level] | |
| rfl | |
| theorem boundedLevel_le_of_le_power {k j : Nat} | |
| (h : k ≤ ExpanderFamily.growth ^ j) : boundedLevel k ≤ j := by | |
| rw [boundedLevel_eq_level] | |
| exact (Nat.clog_le_iff_le_pow ExpanderFamily.growth_gt_one).2 h | |
| theorem paddedSize_positive (k : Nat) : 0 < paddedSize k := by | |
| rw [paddedSize_power] | |
| exact Nat.pow_pos (by have h := ExpanderFamily.growth_gt_one; omega) | |
| theorem paddedSize_bounds {k : Nat} (hk : 0 < k) : | |
| k ≤ paddedSize k ∧ paddedSize k ≤ ExpanderFamily.growth * k := by | |
| rw [paddedSize_eq_size] | |
| exact ⟨ExpanderFamily.le_size k, ExpanderFamily.size_le_mul hk⟩ | |
| def cloudPaddedSize (k : Nat) : Nat := if k = 0 then 0 else paddedSize k | |
| @[simp] theorem cloudPaddedSize_zero : cloudPaddedSize 0 = 0 := rfl | |
| theorem cloudPaddedSize_of_pos {k : Nat} (hk : 0 < k) : | |
| cloudPaddedSize k = paddedSize k := by | |
| simp only [cloudPaddedSize, Nat.ne_of_gt hk, ite_false] | |
| theorem cloudPaddedSize_bounds (k : Nat) : | |
| k ≤ cloudPaddedSize k ∧ cloudPaddedSize k ≤ ExpanderFamily.growth * k := by | |
| by_cases hk : k = 0 | |
| · subst k | |
| simp only [cloudPaddedSize_zero, Nat.mul_zero, le_refl, and_self] | |
| · rw [cloudPaddedSize_of_pos (Nat.pos_of_ne_zero hk)] | |
| exact paddedSize_bounds (Nat.pos_of_ne_zero hk) | |
| theorem table_vertexCount_eq_paddedSize (k : Nat) : | |
| ExpanderTables.vertexCount (Expanders.baseDegree * Expanders.baseDegree) | |
| (boundedLevel k) = paddedSize k := by | |
| rw [ExpanderTables.vertexCount_eq] | |
| have hg : (Expanders.baseDegree * Expanders.baseDegree) * | |
| (Expanders.baseDegree * Expanders.baseDegree) = ExpanderFamily.growth := by | |
| unfold ExpanderFamily.growth | |
| ring | |
| rw [hg] | |
| exact (paddedSize_power k).symm | |
| theorem family_row_count_at_size | |
| (H : ExpanderTables.Table | |
| ((Expanders.baseDegree * Expanders.baseDegree) * | |
| (Expanders.baseDegree * Expanders.baseDegree)) Expanders.baseDegree) | |
| (k : Nat) : | |
| (ExpanderTables.family H (boundedLevel k)).rows.toList.length = | |
| paddedSize k * (Expanders.baseDegree * Expanders.baseDegree) := by | |
| rw [ExpanderTables.row_count, table_vertexCount_eq_paddedSize] | |
| end IndependentSetsGames.Foundations.PCP.PreprocessingLevels | |
| end OAI | |