| import Mathlib |
| import OAI.Combinatorics.IndependentSets.Expansion.PoweringTest |
| import OAI.Combinatorics.IndependentSets.PCP.ClauseVerifier |
| import OAI.Combinatorics.IndependentSets.Expansion.PoweringWitness |
|
|
| namespace OAI |
|
|
| namespace IndependentSetsGames.Foundations.PCP.PoweringNumeric |
|
|
| theorem min_density_ratio (ε C k t : ℝ) |
| (hε : 0 < ε) (hC : 0 < C) (hk : 0 ≤ k) |
| (ht : 0 < t) (hkt : k ≤ t) : |
| min ε (1 / t) / (C + 1) ≤ ε / (C + k * ε) := by |
| have hx : 0 ≤ min ε (1 / t) := |
| le_min hε.le (one_div_nonneg.mpr ht.le) |
| have hxt : min ε (1 / t) * t ≤ 1 := |
| (le_div_iff₀ ht).mp (min_le_right ε (1 / t)) |
| have hkx : k * min ε (1 / t) ≤ 1 := by |
| calc |
| k * min ε (1 / t) ≤ t * min ε (1 / t) := |
| mul_le_mul_of_nonneg_right hkt hx |
| _ ≤ 1 := by simpa only [mul_comm] using hxt |
| have hC1 : 0 < C + 1 := by positivity |
| have hden : 0 < C + k * ε := |
| add_pos_of_pos_of_nonneg hC (mul_nonneg hk hε.le) |
| apply (div_le_div_iff₀ hC1 hden).2 |
| calc |
| min ε (1 / t) * (C + k * ε) = |
| C * min ε (1 / t) + ε * (k * min ε (1 / t)) := by ring |
| _ ≤ C * ε + ε * 1 := |
| add_le_add |
| (mul_le_mul_of_nonneg_left (min_le_left ε (1 / t)) hC.le) |
| (mul_le_mul_of_nonneg_left hkx hε.le) |
| _ = ε * (C + 1) := by ring |
|
|
| theorem count_moment_ratio_lower (α ε C t : ℝ) (m : ℕ) |
| (hm : 0 < m) (hε : 0 < ε) (hC : 0 < C) (ht : 0 < t) |
| (hmt : (m : ℝ) - 1 ≤ t) : |
| (α ^ 4 * (m : ℝ) / (C + 1)) * min ε (1 / t) ≤ |
| (α ^ 2 * (m : ℝ) * ε) ^ 2 / |
| ((m : ℝ) * ε * (C + ((m : ℝ) - 1) * ε)) := by |
| have hm0 : (0 : ℝ) < (m : ℝ) := Nat.cast_pos.mpr hm |
| have hm1 : (1 : ℝ) ≤ (m : ℝ) := by |
| exact_mod_cast (Nat.succ_le_iff.mpr hm) |
| have hk : 0 ≤ (m : ℝ) - 1 := sub_nonneg.mpr hm1 |
| have hden : 0 < C + ((m : ℝ) - 1) * ε := |
| add_pos_of_pos_of_nonneg hC (mul_nonneg hk hε.le) |
| have hαm : 0 ≤ α ^ 4 * (m : ℝ) := by positivity |
| have hratio := min_density_ratio ε C ((m : ℝ) - 1) t hε hC hk ht hmt |
| calc |
| (α ^ 4 * (m : ℝ) / (C + 1)) * min ε (1 / t) = |
| (α ^ 4 * (m : ℝ)) * (min ε (1 / t) / (C + 1)) := by ring |
| _ ≤ (α ^ 4 * (m : ℝ)) * (ε / (C + ((m : ℝ) - 1) * ε)) := |
| mul_le_mul_of_nonneg_left hratio hαm |
| _ = (α ^ 2 * (m : ℝ) * ε) ^ 2 / |
| ((m : ℝ) * ε * (C + ((m : ℝ) - 1) * ε)) := by |
| field_simp [ne_of_gt hm0, ne_of_gt hε, ne_of_gt hden] |
|
|
| end IndependentSetsGames.Foundations.PCP.PoweringNumeric |
| noncomputable section |
|
|
| namespace IndependentSetsGames.Foundations.PCP.PoweringSoundness |
|
|
| open scoped BigOperators |
| open PoweringWalks PoweringLabels PoweringOpinions PoweringTest |
| open SpectralReturn PoweringWitness PoweringMomentBound |
| open PoweringMoment (bit hits) |
|
|
| variable {V D A : Type*} |
|
|
| def center (q M : Nat) : Nat := (4 * q * M) ^ 2 |
|
|
| theorem le_center (q M : Nat) (hq : 1 ≤ q) (hM : 1 ≤ M) : M ≤ center q M := by |
| have hfour : 1 ≤ 4 * q := by omega |
| have hx : M ≤ 4 * q * M := by simpa only [Nat.one_mul] using Nat.mul_le_mul_right M hfour |
| have hone : 1 ≤ 4 * q * M := hM.trans hx |
| have hsquare : 4 * q * M ≤ (4 * q * M) * (4 * q * M) := by |
| simpa only [Nat.mul_one] using Nat.mul_le_mul_left (4 * q * M) hone |
| exact hx.trans (by simpa only [center, pow_two] using hsquare) |
|
|
| def gain (q M : Nat) (lambda : ℝ) : ℝ := |
| (1 / (2 * (q : ℝ))) ^ 4 * ((2 * M + 1 : Nat) : ℝ) / |
| ((1 + 2 / (1 - lambda)) + 1) |
|
|
| variable [Fintype V] [Fintype D] [Nonempty V] [Nonempty D] |
| [Fintype A] [Nonempty A] |
|
|
| def decodedError (G : PortGraph V D) (accepts : Edge V D → A → A → Bool) |
| (n N : Nat) (selectors : ∀ v, AddressSelector G (n + 1) v) |
| (labels : V → PaddedLabel D (n + 1) A) (fallback : A) : ℝ := |
| edgeDensity (decodedBad G accepts (decoded G (n + 1) N selectors labels fallback)) |
|
|
| def poweredRejection (G : PortGraph V D) (accepts : Edge V D → A → A → Bool) |
| (n : Nat) (selectors : ∀ v, AddressSelector G (n + 1) v) |
| (labels : V → PaddedLabel D (n + 1) A) : ℝ := |
| mean (fun d : Dart V D n => bit ((poweredGraph G accepts n selectors).edgeSatisfied labels d = false)) |
|
|
| omit [Fintype V] [Nonempty V] [Nonempty D] in |
| theorem witness_bit_eq (G : PortGraph V D) (accepts : Edge V D → A → A → Bool) |
| (n N : Nat) (selectors : ∀ v, AddressSelector G (n + 1) v) |
| (labels : V → PaddedLabel D (n + 1) A) (fallback : A) |
| (w : Walk V D (n + 1)) (k : Fin (n + 1)) : |
| bit (witness G accepts n selectors labels fallback |
| (decoded G (n + 1) N selectors labels fallback) w k) = |
| vertexWitness G |
| (decodedBad G accepts (decoded G (n + 1) N selectors labels fallback)) |
| (matchFn G (n + 1) N selectors labels fallback) n k w := by |
| simp only [witness, vertexWitness, endpointWitness, matchFn, |
| PoweringMoment.bit_mul, next, and_assoc] |
|
|
| omit [Nonempty V] in |
| theorem modal_witness_mean (G : PortGraph V D) (M : Nat) (hM : 1 ≤ M) |
| (accepts : Edge V (Bool × D) → A → A → Bool) |
| (selectors : ∀ v, AddressSelector (lazyGraph G) (2 * center (Fintype.card A) M + 1) v) |
| (labels : V → PaddedLabel (Bool × D) (2 * center (Fintype.card A) M + 1) A) |
| (fallback : A) (k : Fin (2 * center (Fintype.card A) M + 1)) |
| (hlo : center (Fintype.card A) M - M ≤ k.val) |
| (hhi : k.val ≤ center (Fintype.card A) M + M) : |
| decodedError (lazyGraph G) accepts (2 * center (Fintype.card A) M) |
| (center (Fintype.card A) M) selectors labels fallback / (4 * (Fintype.card A : ℝ) ^ 2) ≤ |
| mean (fun w => bit (witness (lazyGraph G) accepts (2 * center (Fintype.card A) M) |
| selectors labels fallback (decoded (lazyGraph G) (2 * center (Fintype.card A) M + 1) |
| (center (Fintype.card A) M) selectors labels fallback) w k)) := by |
| have h := lazy_middle_witness_mean G (Fintype.card A) M Fintype.card_pos hM k hlo hhi |
| (decodedBad (lazyGraph G) accepts |
| (decoded (lazyGraph G) (2 * center (Fintype.card A) M + 1) |
| (center (Fintype.card A) M) selectors labels fallback)) |
| (matchFn (lazyGraph G) (2 * center (Fintype.card A) M + 1) |
| (center (Fintype.card A) M) selectors labels fallback) |
| (matchFn_mem_Icc (lazyGraph G) (2 * center (Fintype.card A) M + 1) |
| (center (Fintype.card A) M) selectors labels fallback) |
| (decoded_modal_baseline (lazyGraph G) (2 * center (Fintype.card A) M + 1) |
| (center (Fintype.card A) M) selectors labels fallback) |
| simp_rw [witness_bit_eq] |
| convert h using 1 <;> rfl |
|
|
| theorem rejection_lower_bound (G : PortGraph V D) (lambda : ℝ) |
| (certificate : SpectralCertificate (lazyGraph G) lambda) |
| (accepts : Edge V (Bool × D) → A → A → Bool) |
| (reverse_accepts : ∀ e a b, accepts ((lazyGraph G).rot e) b a = accepts e a b) |
| (M : Nat) (hM : 1 ≤ M) |
| (selectors : ∀ v, AddressSelector (lazyGraph G) (2 * center (Fintype.card A) M + 1) v) |
| (labels : V → PaddedLabel (Bool × D) (2 * center (Fintype.card A) M + 1) A) |
| (fallback : A) |
| (hε : 0 < decodedError (lazyGraph G) accepts (2 * center (Fintype.card A) M) |
| (center (Fintype.card A) M) selectors labels fallback) : |
| gain (Fintype.card A) M lambda * |
| min (decodedError (lazyGraph G) accepts (2 * center (Fintype.card A) M) |
| (center (Fintype.card A) M) selectors labels fallback) |
| (1 / ((2 * center (Fintype.card A) M + 1 : Nat) : ℝ)) ≤ |
| poweredRejection (lazyGraph G) accepts (2 * center (Fintype.card A) M) selectors labels := by |
| let q := Fintype.card A |
| let N := center q M |
| let n := 2 * N |
| let m := 2 * M + 1 |
| let start := N - M |
| let L := lazyGraph G |
| let assignment := decoded L (n + 1) N selectors labels fallback |
| let bad := decodedBad L accepts assignment |
| let ε := edgeDensity bad |
| let α : ℝ := 1 / (2 * (q : ℝ)) |
| let C : ℝ := 1 + 2 / (1 - lambda) |
| have hNM : M ≤ N := le_center q M Fintype.card_pos hM |
| have hw : start + m ≤ n + 1 := by dsimp [start, m, n]; omega |
| let E := windowEvent L bad n start m hw |
| let W : Fin m → Walk V (Bool × D) (n + 1) → Prop := fun i w => |
| witness L accepts n selectors labels fallback assignment w (windowIndex n start m hw i) |
| let R : Walk V (Bool × D) (n + 1) → Prop := fun w => |
| pathAccepts L accepts n selectors w (labels w.1) (labels (endpoint L w)) = false |
| have hWE : ∀ i w, W i w → E i w := by |
| intro i w h |
| exact h.1 |
| have hWR : ∀ i w, W i w → R w := by |
| intro i w h |
| exact witness_implies_path_rejection L accepts n selectors labels fallback assignment w |
| (windowIndex n start m hw i) h |
| have hpoint (i : Fin m) : ε / (4 * (q : ℝ) ^ 2) ≤ mean (fun w => bit (W i w)) := by |
| have hlo : N - M ≤ (windowIndex n start m hw i).val := by |
| dsimp [windowIndex, start] |
| omega |
| have hhi : (windowIndex n start m hw i).val ≤ N + M := by |
| have hi := i.isLt |
| dsimp [windowIndex, start] |
| dsimp [m] at hi |
| omega |
| exact modal_witness_mean G M hM accepts selectors labels fallback |
| (windowIndex n start m hw i) hlo hhi |
| have hfirst : α ^ 2 * (m : ℝ) * ε ≤ mean (hits W) := by |
| change α ^ 2 * (m : ℝ) * ε ≤ PoweringMoment.mean (hits W) |
| rw [PoweringMoment.mean_hits] |
| calc |
| _ = ∑ _i : Fin m, ε / (4 * (q : ℝ) ^ 2) := by |
| simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul] |
| dsimp [α] |
| ring |
| _ ≤ _ := Finset.sum_le_sum (fun i _ => hpoint i) |
| have hsecond : mean (fun w => hits E w ^ 2) ≤ |
| (m : ℝ) * ε * (C + ((m : ℝ) - 1) * ε) := |
| window_second_moment_le L lambda certificate bad |
| (decodedBad_rot L accepts reverse_accepts assignment) n start m hw |
| have hε' : 0 < ε := hε |
| have hm : 0 < m := by dsimp [m]; omega |
| have hmReal : (0 : ℝ) < m := Nat.cast_pos.mpr hm |
| have hqReal : (0 : ℝ) < q := Nat.cast_pos.mpr Fintype.card_pos |
| have hden : 0 < 1 - lambda := sub_pos.mpr certificate.lt_one |
| have hC : 0 < C := by dsimp [C]; positivity |
| have hmOne : (1 : ℝ) ≤ m := by exact_mod_cast hm |
| have hα : 0 < α := by dsimp [α]; positivity |
| have ha : 0 < α ^ 2 * (m : ℝ) * ε := by positivity |
| have hb : 0 < (m : ℝ) * ε * (C + ((m : ℝ) - 1) * ε) := by |
| have hdiff : 0 ≤ (m : ℝ) - 1 := sub_nonneg.mpr hmOne |
| positivity |
| have hCS := PoweringMoment.rejection_lower_bound E W R hWE hWR |
| (α ^ 2 * (m : ℝ) * ε) ((m : ℝ) * ε * (C + ((m : ℝ) - 1) * ε)) |
| ha hb hfirst hsecond |
| have ht : (0 : ℝ) < ((n + 1 : Nat) : ℝ) := Nat.cast_pos.mpr (Nat.succ_pos n) |
| have hmn : m ≤ n + 1 := by dsimp [m, n]; omega |
| have hmt : (m : ℝ) - 1 ≤ ((n + 1 : Nat) : ℝ) := by |
| have hmnReal : (m : ℝ) ≤ ((n + 1 : Nat) : ℝ) := by exact_mod_cast hmn |
| linarith |
| have hratio := PoweringNumeric.count_moment_ratio_lower α ε C ((n + 1 : Nat) : ℝ) |
| m hm hε' hC ht hmt |
| change (α ^ 4 * (m : ℝ) / (C + 1)) * min ε (1 / ((n + 1 : Nat) : ℝ)) ≤ _ |
| change _ ≤ mean (fun d : Dart V (Bool × D) n => |
| bit ((poweredGraph L accepts n selectors).edgeSatisfied labels d = false)) |
| rw [rejection_mean_eq_path_mean] |
| exact hratio.trans hCS |
|
|
| end IndependentSetsGames.Foundations.PCP.PoweringSoundness |
| end |
|
|
| end OAI |
|
|
