Download data/lean/OAI/Computability/BinPacking/PCP/PoweringMomentBound.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 29.5 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/BinPacking/PCP/PoweringMomentBound.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/BinPacking/PCP/PoweringMomentBound.lean
-
curl -L -o PoweringMomentBound.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/BinPacking/PCP/PoweringMomentBound.lean
29.5 kB
| import Lean.Elab.Tactic.Omega | |
| import Mathlib.Algebra.BigOperators.Fin | |
| import Mathlib.Algebra.BigOperators.Intervals | |
| import Mathlib.Algebra.Order.BigOperators.Expect | |
| import Mathlib.Basic.Real.Basic | |
| import Mathlib.Tactic.Ring | |
| import OAI.Computability.BinPacking.Expanders.LazySmoothing | |
| import OAI.Computability.BinPacking.Expanders.SpectralCut | |
| namespace OAI | |
| noncomputable section | |
| namespace BinPackingGames.Foundations.PCP.PoweringMoment | |
| open scoped BigOperators | |
| def bit (p : Prop) : β := by | |
| classical | |
| exact if p then 1 else 0 | |
| def hits {I Ξ© : Type*} [Fintype I] (E : I β Ξ© β Prop) (Ο : Ξ©) : β := | |
| β i, bit (E i Ο) | |
| def mean {Ξ© : Type*} [Fintype Ξ©] (f : Ξ© β β) : β := Finset.univ.expect f | |
| theorem bit_nonneg (p : Prop) : 0 β€ bit p := by | |
| classical | |
| by_cases hp : p <;> simp [bit, hp] | |
| theorem bit_sq (p : Prop) : bit p ^ 2 = bit p := by | |
| classical | |
| by_cases hp : p <;> simp [bit, hp] | |
| theorem bit_mul (p q : Prop) : bit p * bit q = bit (p β§ q) := by | |
| classical | |
| by_cases hp : p <;> by_cases hq : q <;> simp [bit, hp, hq] | |
| theorem bit_mono {p q : Prop} (hpq : p β q) : bit p β€ bit q := by | |
| classical | |
| by_cases hp : p | |
| Β· simp [bit, hp, hpq hp] | |
| Β· have hz : bit p = 0 := by simp [bit, hp] | |
| rw [hz] | |
| exact bit_nonneg q | |
| theorem hits_nonneg {I Ξ© : Type*} [Fintype I] (E : I β Ξ© β Prop) (Ο : Ξ©) : | |
| 0 β€ hits E Ο := Finset.sum_nonneg (fun i _ => bit_nonneg (E i Ο)) | |
| theorem mean_nonneg {Ξ© : Type*} [Fintype Ξ©] (f : Ξ© β β) (hf : β Ο, 0 β€ f Ο) : | |
| 0 β€ mean f := Finset.expect_nonneg (fun Ο _ => hf Ο) | |
| theorem mean_hits {I Ξ© : Type*} [Fintype I] [Fintype Ξ©] (E : I β Ξ© β Prop) : | |
| mean (hits E) = β i, mean (fun Ο => bit (E i Ο)) := by | |
| exact Finset.expect_sum_comm _ _ _ | |
| theorem second_moment_eq {I Ξ© : Type*} [Fintype I] [Fintype Ξ©] | |
| (E : I β Ξ© β Prop) : | |
| mean (fun Ο => hits E Ο ^ 2) = | |
| β i, β j, mean (fun Ο => bit (E i Ο β§ E j Ο)) := by | |
| simp only [hits, pow_two, Finset.sum_mul, Finset.mul_sum, bit_mul, | |
| mean, Finset.expect_sum_comm] | |
| exact Finset.sum_comm | |
| theorem mean_witness_sq_le {I Ξ© : Type*} [Fintype I] [Fintype Ξ©] | |
| (E W : I β Ξ© β Prop) (reject : Ξ© β Prop) | |
| (hWE : β i Ο, W i Ο β E i Ο) | |
| (hWR : β i Ο, W i Ο β reject Ο) : | |
| mean (hits W) ^ 2 β€ | |
| mean (fun Ο => bit (reject Ο)) * mean (fun Ο => hits E Ο ^ 2) := by | |
| classical | |
| have hNH (Ο : Ξ©) : hits W Ο β€ hits E Ο := | |
| Finset.sum_le_sum (fun i _ => bit_mono (hWE i Ο)) | |
| have hzero (Ο : Ξ©) (hr : Β¬ reject Ο) : hits W Ο = 0 := by | |
| apply Finset.sum_eq_zero | |
| intro i _ | |
| have hw : Β¬ W i Ο := fun h => hr (hWR i Ο h) | |
| simp [bit, hw] | |
| have hsupport (Ο : Ξ©) : bit (reject Ο) * hits W Ο = hits W Ο := by | |
| by_cases hr : reject Ο | |
| Β· simp [bit, hr] | |
| Β· rw [hzero Ο hr] | |
| simp | |
| have hCS := Finset.expect_mul_sq_le_sq_mul_sq Finset.univ | |
| (fun Ο => bit (reject Ο)) (hits W) | |
| have hsquares : mean (fun Ο => hits W Ο ^ 2) β€ mean (fun Ο => hits E Ο ^ 2) := by | |
| apply Finset.expect_le_expect | |
| intro Ο _ | |
| simpa only [pow_two] using | |
| (mul_le_mul (hNH Ο) (hNH Ο) (hits_nonneg W Ο) (hits_nonneg E Ο)) | |
| calc | |
| _ β€ mean (fun Ο => bit (reject Ο)) * mean (fun Ο => hits W Ο ^ 2) := by | |
| simpa only [mean, hsupport, bit_sq] using hCS | |
| _ β€ _ := mul_le_mul_of_nonneg_left hsquares | |
| (mean_nonneg _ (fun Ο => bit_nonneg (reject Ο))) | |
| theorem rejection_lower_bound {I Ξ© : Type*} [Fintype I] [Fintype Ξ©] | |
| (E W : I β Ξ© β Prop) (reject : Ξ© β Prop) | |
| (hWE : β i Ο, W i Ο β E i Ο) | |
| (hWR : β i Ο, W i Ο β reject Ο) | |
| (a b : β) (ha : 0 < a) (hb : 0 < b) | |
| (hfirst : a β€ mean (hits W)) | |
| (hsecond : mean (fun Ο => hits E Ο ^ 2) β€ b) : | |
| a ^ 2 / b β€ mean (fun Ο => bit (reject Ο)) := by | |
| have hN : 0 β€ mean (hits W) := mean_nonneg _ (hits_nonneg W) | |
| have hΟ : 0 β€ mean (fun Ο => bit (reject Ο)) := | |
| mean_nonneg _ (fun Ο => bit_nonneg (reject Ο)) | |
| have haSq : a ^ 2 β€ mean (hits W) ^ 2 := by | |
| simpa only [pow_two] using mul_le_mul hfirst hfirst ha.le hN | |
| have hCS := mean_witness_sq_le E W reject hWE hWR | |
| apply (div_le_iffβ hb).2 | |
| exact haSq.trans (hCS.trans (mul_le_mul_of_nonneg_left hsecond hΟ)) | |
| end BinPackingGames.Foundations.PCP.PoweringMoment | |
| end | |
| section | |
| namespace BinPackingGames.Foundations.PCP.PoweringWalks | |
| variable {V D : Type*} | |
| def lazyRotate (G : PortGraph V D) : Edge V (Bool Γ D) β Edge V (Bool Γ D) | |
| | (v, (false, d)) => (v, (false, d)) | |
| | (v, (true, d)) => ((G.rot (v, d)).1, (true, (G.rot (v, d)).2)) | |
| theorem lazyRotate_involutive (G : PortGraph V D) : | |
| Function.Involutive (lazyRotate G) := by | |
| rintro β¨v, b, dβ© | |
| cases b with | |
| | false => rfl | |
| | true => | |
| exact congrArg (fun e : V Γ D => (e.1, (true, e.2))) (rot_rot G (v, d)) | |
| def lazyGraph (G : PortGraph V D) : PortGraph V (Bool Γ D) where | |
| rot := { | |
| toFun := lazyRotate G | |
| invFun := lazyRotate G | |
| left_inv := lazyRotate_involutive G | |
| right_inv := lazyRotate_involutive G } | |
| rot_involutive := lazyRotate_involutive G | |
| @[simp] theorem lazyGraph_rot_false (G : PortGraph V D) (v : V) (d : D) : | |
| (lazyGraph G).rot (v, (false, d)) = (v, (false, d)) := rfl | |
| @[simp] theorem lazyGraph_rot_true (G : PortGraph V D) (v : V) (d : D) : | |
| (lazyGraph G).rot (v, (true, d)) = ((G.rot (v, d)).1, (true, (G.rot (v, d)).2)) := rfl | |
| end BinPackingGames.Foundations.PCP.PoweringWalks | |
| namespace BinPackingGames.Foundations.PCP.PoweringLazy | |
| open PoweringWalks SpectralReturn | |
| variable {V D : Type*} | |
| theorem operator_binomialMean [Fintype D] (G : PortGraph V D) | |
| (n : Nat) (g : Nat β V β β) (v : V) : | |
| averagingOperator G (fun w => LazySmoothing.binomialMean n (fun k => g k w)) v = | |
| LazySmoothing.binomialMean n (fun k => averagingOperator G (g k) v) := by | |
| unfold averagingOperator LazySmoothing.binomialMean | |
| exact Finset.expect_comm Finset.univ Finset.univ | |
| (fun d tape => g (LazySmoothing.bitCount tape) (G.rot (v, d)).1) | |
| theorem averagingOperator_lazy [Fintype D] [Nonempty D] | |
| (G : PortGraph V D) (f : V β β) (v : V) : | |
| averagingOperator (lazyGraph G) f v = (f v + averagingOperator G f v) / 2 := by | |
| change mean (fun bd : Bool Γ D => f ((lazyGraph G).rot (v, bd)).1) = _ | |
| rw [mean_prod] | |
| change Finset.univ.expect (fun b : Bool => | |
| mean (fun d : D => f ((lazyGraph G).rot (v, (b, d))).1)) = _ | |
| rw [LazySmoothing.expect_bool] | |
| simp only [lazyGraph_rot_false, lazyGraph_rot_true] | |
| rw [mean_const] | |
| rfl | |
| theorem iterate_lazy_eq_binomialMean [Fintype D] [Nonempty D] | |
| (G : PortGraph V D) (n : Nat) (f : V β β) : | |
| iterateOperator (lazyGraph G) n f = | |
| fun v => LazySmoothing.binomialMean n (fun k => iterateOperator G k f v) := by | |
| induction n with | |
| | zero => | |
| funext v | |
| simp [iterateOperator] | |
| | succ n ih => | |
| funext v | |
| change averagingOperator (lazyGraph G) (iterateOperator (lazyGraph G) n f) v = _ | |
| rw [ih, averagingOperator_lazy, operator_binomialMean, LazySmoothing.mean_succ] | |
| rfl | |
| theorem iterate_mem_Icc [Fintype D] [Nonempty D] | |
| (G : PortGraph V D) (f : V β β) (hf : β w, f w β Set.Icc (0 : β) 1) | |
| (n : Nat) (v : V) : iterateOperator G n f v β Set.Icc (0 : β) 1 := by | |
| induction n generalizing v with | |
| | zero => exact hf v | |
| | succ n ih => | |
| change mean (fun d : D => iterateOperator G n f (G.rot (v, d)).1) β Set.Icc (0 : β) 1 | |
| constructor | |
| Β· exact mean_nonnegative _ (fun d => (ih ((G.rot (v, d)).1)).1) | |
| Β· calc | |
| mean (fun d : D => iterateOperator G n f (G.rot (v, d)).1) β€ | |
| mean (fun _ : D => (1 : β)) := | |
| mean_mono (fun d => (ih ((G.rot (v, d)).1)).2) | |
| _ = 1 := mean_const _ | |
| theorem lazy_endpoint_modal_transfer [Fintype D] [Nonempty D] | |
| (G : PortGraph V D) (q M m : Nat) (hq : 1 β€ q) (hM : 1 β€ M) | |
| (hlo : (4 * q * M) ^ 2 - M β€ m) (hhi : m β€ (4 * q * M) ^ 2 + M) | |
| (f : V β β) (hf : β w, f w β Set.Icc (0 : β) 1) (v : V) | |
| (hmodal : 1 / (q : β) β€ iterateOperator (lazyGraph G) ((4 * q * M) ^ 2) f v) : | |
| 1 / (2 * (q : β)) β€ iterateOperator (lazyGraph G) m f v := by | |
| rw [iterate_lazy_eq_binomialMean] at hmodal β’ | |
| exact LazySmoothing.modal_transfer q M m hq hM hlo hhi | |
| (fun k => iterateOperator G k f v) (fun k => iterate_mem_Icc G f hf k v) hmodal | |
| end BinPackingGames.Foundations.PCP.PoweringLazy | |
| end | |
| namespace BinPackingGames.Foundations.PCP.PoweringReturn | |
| open PoweringWalks SpectralReturn | |
| open PoweringMoment (bit) | |
| variable {V D : Type*} | |
| def portConsEquiv (D : Type*) (n : Nat) : | |
| (D Γ (Fin n β D)) β (Fin (n + 1) β D) where | |
| toFun z := Fin.cases z.1 z.2 | |
| invFun r := (r 0, fun j => r j.succ) | |
| left_inv z := by | |
| apply Prod.ext | |
| Β· rfl | |
| Β· funext j | |
| rfl | |
| right_inv r := by | |
| funext j | |
| exact Fin.cases rfl (fun _ => rfl) j | |
| theorem mean_word_cons_head [Fintype D] (n : Nat) | |
| (F : (Fin (n + 1) β D) β β) : | |
| mean F = mean (fun d : D => mean (fun r : Fin n β D => F (Fin.cases d r))) := by | |
| calc | |
| mean F = mean (fun z : D Γ (Fin n β D) => F (Fin.cases z.1 z.2)) := | |
| (mean_equiv (portConsEquiv D n) F).symm | |
| _ = _ := mean_prod _ | |
| theorem mean_word_cons_tail [Fintype D] (n : Nat) | |
| (F : (Fin (n + 1) β D) β β) : | |
| mean F = mean (fun r : Fin n β D => mean (fun d : D => F (Fin.cases d r))) := by | |
| calc | |
| mean F = mean (fun z : (Fin n β D) Γ D => F (Fin.cases z.2 z.1)) := | |
| (mean_equiv ((Equiv.prodComm (Fin n β D) D).trans (portConsEquiv D n)) F).symm | |
| _ = _ := mean_prod _ | |
| theorem iterateOperator_succ_right [Fintype D] (G : PortGraph V D) | |
| (n : Nat) (f : V β β) : | |
| iterateOperator G n (averagingOperator G f) = iterateOperator G (n + 1) f := by | |
| induction n with | |
| | zero => rfl | |
| | succ n ih => exact congrArg (averagingOperator G) ih | |
| theorem mean_wordEnd [Fintype D] [Nonempty D] (G : PortGraph V D) : | |
| β (n : Nat) (v : V) (f : V β β), | |
| mean (fun r : Fin n β D => f (wordEnd G n v r)) = iterateOperator G n f v := by | |
| intro n | |
| induction n with | |
| | zero => | |
| intro v f | |
| change mean (fun _ : Fin 0 β D => f v) = f v | |
| exact mean_const _ | |
| | succ n ih => | |
| intro v f | |
| rw [mean_word_cons_head] | |
| change mean (fun d : D => mean (fun r : Fin n β D => | |
| f (wordEnd G n (next G v d) r))) = _ | |
| calc | |
| _ = mean (fun d : D => iterateOperator G n f (next G v d)) := by | |
| congr 1 | |
| funext d | |
| exact ih (next G v d) f | |
| _ = iterateOperator G (n + 1) f v := rfl | |
| theorem mean_pivot_endpoints [Fintype D] [Nonempty D] (G : PortGraph V D) : | |
| β (n : Nat) (k : Fin (n + 1)) (e : Edge V D) (Ο Ο : V β β), | |
| mean (fun r : Fin n β D => | |
| Ο (leftFromPivot G n k e.1 r) * Ο (rightFromPivot G n k e r)) = | |
| iterateOperator G k.val Ο e.1 * | |
| iterateOperator G (n - k.val) Ο (next G e.1 e.2) := by | |
| intro n | |
| induction n with | |
| | zero => | |
| intro k e Ο Ο | |
| have hk : k = 0 := Fin.eq_zero k | |
| subst k | |
| change mean (fun _ : Fin 0 β D => Ο e.1 * Ο (next G e.1 e.2)) = | |
| Ο e.1 * Ο (next G e.1 e.2) | |
| exact mean_const _ | |
| | succ n ih => | |
| intro k e Ο Ο | |
| refine Fin.cases ?_ (fun j => ?_) k | |
| Β· change mean (fun r : Fin (n + 1) β D => | |
| Ο e.1 * Ο (wordEnd G (n + 1) (next G e.1 e.2) r)) = | |
| Ο e.1 * iterateOperator G (n + 1) Ο (next G e.1 e.2) | |
| rw [mean_mul_left, mean_wordEnd] | |
| Β· simp only [Fin.val_succ, Nat.add_sub_add_right] | |
| rw [mean_word_cons_tail] | |
| change mean (fun r : Fin n β D => mean (fun d : D => | |
| Ο (next G (leftFromPivot G n j e.1 r) d) * | |
| Ο (rightFromPivot G n j e r))) = | |
| iterateOperator G (j.val + 1) Ο e.1 * | |
| iterateOperator G (n - j.val) Ο (next G e.1 e.2) | |
| calc | |
| _ = mean (fun r : Fin n β D => | |
| averagingOperator G Ο (leftFromPivot G n j e.1 r) * | |
| Ο (rightFromPivot G n j e r)) := by | |
| congr 1 | |
| funext r | |
| rw [mean_mul_right] | |
| rfl | |
| _ = iterateOperator G j.val (averagingOperator G Ο) e.1 * | |
| iterateOperator G (n - j.val) Ο (next G e.1 e.2) := | |
| ih j e (averagingOperator G Ο) Ο | |
| _ = _ := by rw [iterateOperator_succ_right] | |
| theorem mean_edge_endpoints [Fintype V] [Fintype D] [Nonempty D] | |
| (G : PortGraph V D) (n : Nat) (k : Fin (n + 1)) (Ο Ο : Edge V D β V β β) : | |
| mean (fun w : Walk V D (n + 1) => | |
| Ο (edgeAt G n w k) w.1 * Ο (edgeAt G n w k) (endpoint G w)) = | |
| mean (fun e : Edge V D => | |
| iterateOperator G k.val (Ο e) e.1 * | |
| iterateOperator G (n - k.val) (Ο e) (next G e.1 e.2)) := by | |
| let F : Edge V D Γ (Fin n β D) β β := fun z => | |
| Ο z.1 (leftFromPivot G n k z.1.1 z.2) * | |
| Ο z.1 (rightFromPivot G n k z.1 z.2) | |
| calc | |
| _ = mean (fun w => F (pivotEquiv G n k w)) := by | |
| congr 1 | |
| funext w | |
| dsimp [F] | |
| rw [leftFromPivot_actual, rightFromPivot_actual, pivotEquiv_fst] | |
| _ = mean F := mean_equiv (pivotEquiv G n k) F | |
| _ = mean (fun e : Edge V D => mean (fun r : Fin n β D => | |
| Ο e (leftFromPivot G n k e.1 r) * Ο e (rightFromPivot G n k e r))) := mean_prod F | |
| _ = _ := by | |
| congr 1 | |
| funext e | |
| exact mean_pivot_endpoints G n k e (Ο e) (Ο e) | |
| theorem bit_bool (b : Bool) : bit (b = true) = (if b then 1 else 0 : β) := by | |
| cases b <;> simp [bit] | |
| theorem mean_edge_bit [Fintype D] (bad : V Γ D β Bool) (v : V) : | |
| mean (fun d : D => bit (bad (v, d) = true)) = edgeProfile bad v := by | |
| simp only [bit_bool, mean, edgeProfile] | |
| theorem mean_marked_bit [Fintype D] (G : PortGraph V D) | |
| (bad : V Γ D β Bool) (f : V β β) (v : V) : | |
| mean (fun d : D => bit (bad (v, d) = true) * f (next G v d)) = | |
| markedStep G bad f v := by | |
| change mean (fun d : D => bit (bad (v, d) = true) * f (next G v d)) = | |
| mean (fun d : D => if bad (v, d) then f (next G v d) else 0) | |
| congr 1 | |
| funext d | |
| cases bad (v, d) <;> simp [bit] | |
| theorem edgeAt_zero (G : PortGraph V D) (n : Nat) (w : Walk V D (n + 1)) : | |
| edgeAt G n w 0 = (w.1, w.2 0) := by | |
| cases n <;> rfl | |
| theorem word_first_hit_mean [Fintype D] [Nonempty D] | |
| (G : PortGraph V D) (bad : V Γ D β Bool) (n : Nat) (v : V) : | |
| mean (fun p : Fin (n + 1) β D => bit (bad (edgeAt G n (v, p) 0) = true)) = | |
| edgeProfile bad v := by | |
| rw [mean_word_cons_head] | |
| simp_rw [edgeAt_zero] | |
| change mean (fun d : D => mean (fun _ : Fin n β D => bit (bad (v, d) = true))) = _ | |
| calc | |
| _ = mean (fun d : D => bit (bad (v, d) = true)) := by simp only [mean_const] | |
| _ = edgeProfile bad v := mean_edge_bit bad v | |
| theorem word_hit_mean [Fintype D] [Nonempty D] | |
| (G : PortGraph V D) (bad : V Γ D β Bool) : | |
| β (n : Nat) (v : V) (k : Fin (n + 1)), | |
| mean (fun p : Fin (n + 1) β D => bit (bad (edgeAt G n (v, p) k) = true)) = | |
| iterateOperator G k.val (edgeProfile bad) v := by | |
| intro n | |
| induction n with | |
| | zero => | |
| intro v k | |
| have hk : k = 0 := Fin.eq_zero k | |
| subst k | |
| exact word_first_hit_mean G bad 0 v | |
| | succ n ih => | |
| intro v k | |
| refine Fin.cases ?_ (fun j => ?_) k | |
| Β· exact word_first_hit_mean G bad (n + 1) v | |
| Β· rw [mean_word_cons_head] | |
| change mean (fun d : D => mean (fun p : Fin (n + 1) β D => | |
| bit (bad (edgeAt G n (next G v d, p) j) = true))) = | |
| averagingOperator G (iterateOperator G j.val (edgeProfile bad)) v | |
| calc | |
| _ = mean (fun d : D => iterateOperator G j.val (edgeProfile bad) (next G v d)) := by | |
| congr 1 | |
| funext d | |
| exact ih (next G v d) j | |
| _ = _ := rfl | |
| theorem word_pair_hit_mean [Fintype D] [Nonempty D] | |
| (G : PortGraph V D) (bad : V Γ D β Bool) : | |
| β (n : Nat) (v : V) (i j : Fin (n + 1)), i < j β | |
| mean (fun p : Fin (n + 1) β D => | |
| bit (bad (edgeAt G n (v, p) i) = true) * | |
| bit (bad (edgeAt G n (v, p) j) = true)) = | |
| iterateOperator G i.val (markedStep G bad | |
| (iterateOperator G (j.val - i.val - 1) (edgeProfile bad))) v := by | |
| intro n | |
| induction n with | |
| | zero => | |
| intro v i j hij | |
| have hi : i = 0 := Fin.eq_zero i | |
| have hj : j = 0 := Fin.eq_zero j | |
| subst i | |
| subst j | |
| exact ((lt_irrefl _) hij).elim | |
| | succ n ih => | |
| intro v i | |
| refine Fin.cases ?_ (fun a => ?_) i | |
| Β· intro j | |
| refine Fin.cases ?_ (fun b => ?_) j | |
| Β· intro hij | |
| exact ((lt_irrefl _) hij).elim | |
| Β· intro _hij | |
| simp only [Fin.val_zero, Fin.val_succ, Nat.sub_zero, Nat.add_sub_cancel] | |
| rw [mean_word_cons_head] | |
| change mean (fun d : D => mean (fun p : Fin (n + 1) β D => | |
| bit (bad (v, d) = true) * bit (bad (edgeAt G n (next G v d, p) b) = true))) = | |
| markedStep G bad (iterateOperator G b.val (edgeProfile bad)) v | |
| calc | |
| _ = mean (fun d : D => bit (bad (v, d) = true) * | |
| iterateOperator G b.val (edgeProfile bad) (next G v d)) := by | |
| congr 1 | |
| funext d | |
| rw [mean_mul_left, word_hit_mean] | |
| _ = _ := mean_marked_bit G bad _ v | |
| Β· intro j | |
| refine Fin.cases ?_ (fun b => ?_) j | |
| Β· intro hij | |
| exact (Nat.not_lt_zero _ hij).elim | |
| Β· intro hij | |
| have hab : a < b := Nat.lt_of_succ_lt_succ hij | |
| simp only [Fin.val_succ, Nat.add_sub_add_right] | |
| rw [mean_word_cons_head] | |
| change mean (fun d : D => mean (fun p : Fin (n + 1) β D => | |
| bit (bad (edgeAt G n (next G v d, p) a) = true) * | |
| bit (bad (edgeAt G n (next G v d, p) b) = true))) = | |
| averagingOperator G (iterateOperator G a.val (markedStep G bad | |
| (iterateOperator G (b.val - a.val - 1) (edgeProfile bad)))) v | |
| calc | |
| _ = mean (fun d : D => iterateOperator G a.val (markedStep G bad | |
| (iterateOperator G (b.val - a.val - 1) (edgeProfile bad))) (next G v d)) := by | |
| congr 1 | |
| funext d | |
| exact ih (next G v d) a b hab | |
| _ = _ := rfl | |
| theorem hit_mean [Fintype V] [Fintype D] [Nonempty V] [Nonempty D] | |
| (G : PortGraph V D) (bad : V Γ D β Bool) (n : Nat) (k : Fin (n + 1)) : | |
| mean (fun w : Walk V D (n + 1) => bit (bad (edgeAt G n w k) = true)) = | |
| edgeDensity bad := by | |
| calc | |
| _ = mean (fun v : V => mean (fun p : Fin (n + 1) β D => | |
| bit (bad (edgeAt G n (v, p) k) = true))) := | |
| mean_prod (A := V) (B := Fin (n + 1) β D) | |
| (fun w => bit (bad (edgeAt G n w k) = true)) | |
| _ = mean (iterateOperator G k.val (edgeProfile bad)) := by | |
| congr 1 | |
| funext v | |
| exact word_hit_mean G bad n v k | |
| _ = mean (edgeProfile bad) := mean_iterate G k.val _ | |
| _ = _ := rfl | |
| theorem pair_hit_mean [Fintype V] [Fintype D] [Nonempty V] [Nonempty D] | |
| (G : PortGraph V D) (bad : V Γ D β Bool) (n : Nat) | |
| (i j : Fin (n + 1)) (hij : i < j) : | |
| mean (fun w : Walk V D (n + 1) => bit (bad (edgeAt G n w i) = true) * | |
| bit (bad (edgeAt G n w j) = true)) = returnMass G bad (j.val - i.val - 1) := by | |
| calc | |
| _ = mean (fun v : V => mean (fun p : Fin (n + 1) β D => | |
| bit (bad (edgeAt G n (v, p) i) = true) * | |
| bit (bad (edgeAt G n (v, p) j) = true))) := | |
| mean_prod (A := V) (B := Fin (n + 1) β D) | |
| (fun w => bit (bad (edgeAt G n w i) = true) * | |
| bit (bad (edgeAt G n w j) = true)) | |
| _ = mean (iterateOperator G i.val (markedStep G bad | |
| (iterateOperator G (j.val - i.val - 1) (edgeProfile bad)))) := by | |
| congr 1 | |
| funext v | |
| exact word_pair_hit_mean G bad n v i j hij | |
| _ = mean (markedStep G bad | |
| (iterateOperator G (j.val - i.val - 1) (edgeProfile bad))) := mean_iterate G i.val _ | |
| _ = _ := rfl | |
| theorem pair_event_mean [Fintype V] [Fintype D] [Nonempty V] [Nonempty D] | |
| (G : PortGraph V D) (bad : V Γ D β Bool) (n : Nat) | |
| (i j : Fin (n + 1)) (hij : i < j) : | |
| mean (fun w : Walk V D (n + 1) => | |
| bit (bad (edgeAt G n w i) = true β§ bad (edgeAt G n w j) = true)) = | |
| returnMass G bad (j.val - i.val - 1) := by | |
| simpa only [PoweringMoment.bit_mul] using pair_hit_mean G bad n i j hij | |
| end BinPackingGames.Foundations.PCP.PoweringReturn | |
| namespace BinPackingGames.Foundations.PCP.PoweringWitness | |
| open PoweringWalks SpectralReturn PoweringReturn PoweringLazy | |
| open PoweringMoment (bit) | |
| variable {V D : Type*} | |
| theorem iterate_mul_const [Fintype D] (G : PortGraph V D) | |
| (n : Nat) (c : β) (h : V β β) : | |
| iterateOperator G n (fun x => c * h x) = | |
| fun x => c * iterateOperator G n h x := by | |
| induction n with | |
| | zero => rfl | |
| | succ n ih => | |
| change averagingOperator G (iterateOperator G n (fun x => c * h x)) = | |
| fun x => c * averagingOperator G (iterateOperator G n h) x | |
| rw [ih] | |
| funext v | |
| exact mean_mul_left c (fun d => iterateOperator G n h (G.rot (v, d)).1) | |
| noncomputable def endpointWitness (G : PortGraph V D) (bad : Edge V D β Bool) | |
| (Ο Ο : Edge V D β V β β) (n : Nat) (k : Fin (n + 1)) | |
| (w : Walk V D (n + 1)) : β := | |
| bit (bad (edgeAt G n w k) = true) * | |
| Ο (edgeAt G n w k) w.1 * Ο (edgeAt G n w k) (endpoint G w) | |
| noncomputable def vertexWitness (G : PortGraph V D) (bad : Edge V D β Bool) | |
| (f : V β V β β) (n : Nat) (k : Fin (n + 1)) : | |
| Walk V D (n + 1) β β := | |
| endpointWitness G bad (fun e => f e.1) (fun e => f (next G e.1 e.2)) n k | |
| theorem endpoint_lower_bound [Fintype V] [Fintype D] [Nonempty D] | |
| (G : PortGraph V D) (n : Nat) (k : Fin (n + 1)) (bad : Edge V D β Bool) | |
| (Ο Ο : Edge V D β V β β) (a : β) (ha : 0 β€ a) | |
| (hL : β e, bad e = true β a β€ iterateOperator G k.val (Ο e) e.1) | |
| (hR : β e, bad e = true β | |
| a β€ iterateOperator G (n - k.val) (Ο e) (next G e.1 e.2)) : | |
| edgeDensity bad * a ^ 2 β€ mean (endpointWitness G bad Ο Ο n k) := by | |
| have hfactor : mean (endpointWitness G bad Ο Ο n k) = | |
| mean (fun e : Edge V D => | |
| (bit (bad e = true) * iterateOperator G k.val (Ο e) e.1) * | |
| iterateOperator G (n - k.val) (Ο e) (next G e.1 e.2)) := by | |
| unfold endpointWitness | |
| rw [mean_edge_endpoints G n k (fun e x => bit (bad e = true) * Ο e x) Ο] | |
| simp_rw [iterate_mul_const] | |
| have hbitMean : mean (fun e : Edge V D => bit (bad e = true)) = edgeDensity bad := by | |
| calc | |
| _ = mean (fun v : V => mean (fun d : D => bit (bad (v, d) = true))) := | |
| mean_prod (A := V) (B := D) (fun e => bit (bad e = true)) | |
| _ = edgeDensity bad := by simp only [mean_edge_bit, edgeDensity] | |
| calc | |
| edgeDensity bad * a ^ 2 = | |
| mean (fun e : Edge V D => bit (bad e = true) * a ^ 2) := by | |
| rw [mean_mul_right, hbitMean] | |
| _ β€ mean (fun e : Edge V D => | |
| (bit (bad e = true) * iterateOperator G k.val (Ο e) e.1) * | |
| iterateOperator G (n - k.val) (Ο e) (next G e.1 e.2)) := by | |
| apply mean_mono | |
| intro e | |
| cases hb : bad e with | |
| | false => simp [bit] | |
| | true => | |
| have hprod := mul_le_mul (hL e hb) (hR e hb) ha (ha.trans (hL e hb)) | |
| simpa [bit, hb, pow_two] using hprod | |
| _ = mean (endpointWitness G bad Ο Ο n k) := hfactor.symm | |
| theorem lazy_middle_witness_mean [Fintype V] [Fintype D] [Nonempty D] | |
| (G : PortGraph V D) (q M : Nat) (hq : 1 β€ q) (hM : 1 β€ M) | |
| (k : Fin (2 * (4 * q * M) ^ 2 + 1)) | |
| (hlo : (4 * q * M) ^ 2 - M β€ k.val) | |
| (hhi : k.val β€ (4 * q * M) ^ 2 + M) | |
| (bad : Edge V (Bool Γ D) β Bool) (f : V β V β β) | |
| (hf : β u w, f u w β Set.Icc (0 : β) 1) | |
| (hmodal : β u, 1 / (q : β) β€ | |
| iterateOperator (lazyGraph G) ((4 * q * M) ^ 2) (f u) u) : | |
| edgeDensity bad / (4 * (q : β) ^ 2) β€ | |
| mean (vertexWitness (lazyGraph G) bad f (2 * (4 * q * M) ^ 2) k) := by | |
| have hk : k.val β€ 2 * (4 * q * M) ^ 2 := Nat.le_of_lt_succ k.isLt | |
| have hslo : (4 * q * M) ^ 2 - M β€ 2 * (4 * q * M) ^ 2 - k.val := by omega | |
| have hshi : 2 * (4 * q * M) ^ 2 - k.val β€ (4 * q * M) ^ 2 + M := by omega | |
| have ha : (0 : β) β€ 1 / (2 * (q : β)) := by positivity | |
| have hbound := endpoint_lower_bound (lazyGraph G) (2 * (4 * q * M) ^ 2) k bad | |
| (fun e => f e.1) (fun e => f (next (lazyGraph G) e.1 e.2)) | |
| (1 / (2 * (q : β))) ha | |
| (by | |
| intro e _ | |
| exact lazy_endpoint_modal_transfer G q M k.val hq hM hlo hhi | |
| (f e.1) (hf e.1) e.1 (hmodal e.1)) | |
| (by | |
| intro e _ | |
| exact lazy_endpoint_modal_transfer G q M (2 * (4 * q * M) ^ 2 - k.val) | |
| hq hM hslo hshi (f (next (lazyGraph G) e.1 e.2)) | |
| (hf (next (lazyGraph G) e.1 e.2)) (next (lazyGraph G) e.1 e.2) | |
| (hmodal (next (lazyGraph G) e.1 e.2))) | |
| have hscale : edgeDensity bad * (1 / (2 * (q : β))) ^ 2 = | |
| edgeDensity bad / (4 * (q : β) ^ 2) := by ring | |
| simpa only [vertexWitness, hscale] using hbound | |
| end BinPackingGames.Foundations.PCP.PoweringWitness | |
| namespace BinPackingGames.Foundations.PCP.PoweringMomentBound | |
| open scoped BigOperators | |
| open PoweringWalks SpectralReturn PoweringReturn | |
| open PoweringMoment (bit hits) | |
| theorem symmetric_gap_matrix_sum (Ξ΅ : β) (r : Nat β β) : | |
| β (m : Nat) (f : Fin m β Fin m β β), | |
| (β i j, f i j = f j i) β (β i, f i i = Ξ΅) β | |
| (β i j, i.val < j.val β f i j = r (j.val - i.val - 1)) β | |
| (β i, β j, f i j) = (m : β) * Ξ΅ + | |
| 2 * β j β Finset.range m, β gap β Finset.range j, r gap := by | |
| intro m | |
| induction m with | |
| | zero => intro f _hSym _hDiag _hUpper; simp | |
| | succ m ih => | |
| intro f hSym hDiag hUpper | |
| have hOld : (β i : Fin m, β j : Fin m, f i.castSucc j.castSucc) = | |
| (m : β) * Ξ΅ + 2 * β j β Finset.range m, β gap β Finset.range j, r gap := by | |
| apply ih (fun i j => f i.castSucc j.castSucc) | |
| Β· intro i j; exact hSym i.castSucc j.castSucc | |
| Β· intro i; exact hDiag i.castSucc | |
| Β· intro i j hij; exact hUpper i.castSucc j.castSucc hij | |
| have hLast : (β i : Fin m, f i.castSucc (Fin.last m)) = | |
| β gap β Finset.range m, r gap := by | |
| calc | |
| _ = β i : Fin m, r (m - 1 - i.val) := by | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| rw [hUpper i.castSucc (Fin.last m) i.isLt] | |
| simp only [Fin.val_last, Fin.val_castSucc] | |
| congr 1 | |
| omega | |
| _ = β i β Finset.range m, r (m - 1 - i) := | |
| Fin.sum_univ_eq_sum_range (fun i => r (m - 1 - i)) m | |
| _ = _ := Finset.sum_range_reflect r m | |
| have hLastRow : (β j : Fin m, f (Fin.last m) j.castSucc) = | |
| β gap β Finset.range m, r gap := by | |
| calc | |
| _ = β j : Fin m, f j.castSucc (Fin.last m) := by | |
| apply Finset.sum_congr rfl | |
| intro j _ | |
| exact hSym (Fin.last m) j.castSucc | |
| _ = _ := hLast | |
| calc | |
| (β i, β j, f i j) = | |
| (β i : Fin m, β j : Fin m, f i.castSucc j.castSucc) + | |
| (β i : Fin m, f i.castSucc (Fin.last m)) + | |
| (β j : Fin m, f (Fin.last m) j.castSucc) + f (Fin.last m) (Fin.last m) := by | |
| simp only [Fin.sum_univ_castSucc, Finset.sum_add_distrib] | |
| ring | |
| _ = (m : β) * Ξ΅ + | |
| 2 * (β j β Finset.range m, β gap β Finset.range j, r gap) + | |
| (β gap β Finset.range m, r gap) + (β gap β Finset.range m, r gap) + Ξ΅ := by | |
| rw [hOld, hLast, hLastRow, hDiag] | |
| _ = ((m + 1 : Nat) : β) * Ξ΅ + | |
| 2 * β j β Finset.range (m + 1), β gap β Finset.range j, r gap := by | |
| rw [Finset.sum_range_succ] | |
| simp only [Nat.cast_add, Nat.cast_one] | |
| ring | |
| def windowIndex (n start m : Nat) (h : start + m β€ n + 1) (i : Fin m) : Fin (n + 1) := | |
| β¨start + i.val, (Nat.add_lt_add_left i.isLt start).trans_le hβ© | |
| variable {V D : Type*} [Fintype V] [Fintype D] [Nonempty V] [Nonempty D] | |
| def windowEvent (G : PortGraph V D) (bad : V Γ D β Bool) | |
| (n start m : Nat) (h : start + m β€ n + 1) (i : Fin m) (w : Walk V D (n + 1)) : Prop := | |
| bad (edgeAt G n w (windowIndex n start m h i)) = true | |
| theorem window_second_moment_eq (G : PortGraph V D) (bad : V Γ D β Bool) | |
| (n start m : Nat) (h : start + m β€ n + 1) : | |
| mean (fun w => hits (windowEvent G bad n start m h) w ^ 2) = | |
| (m : β) * edgeDensity bad + | |
| 2 * β j β Finset.range m, β gap β Finset.range j, returnMass G bad gap := by | |
| rw [show mean (fun w => hits (windowEvent G bad n start m h) w ^ 2) = | |
| β i, β j, mean (fun w => bit (windowEvent G bad n start m h i w β§ | |
| windowEvent G bad n start m h j w)) from | |
| PoweringMoment.second_moment_eq (windowEvent G bad n start m h)] | |
| apply symmetric_gap_matrix_sum | |
| Β· intro i j | |
| congr 1 | |
| funext w | |
| simp only [and_comm] | |
| Β· intro i | |
| simp only [and_self] | |
| exact hit_mean G bad n (windowIndex n start m h i) | |
| Β· intro i j hij | |
| have hwin : windowIndex n start m h i < windowIndex n start m h j := | |
| Nat.add_lt_add_left hij start | |
| have hp := pair_event_mean G bad n (windowIndex n start m h i) | |
| (windowIndex n start m h j) hwin | |
| simpa only [windowEvent, windowIndex, Nat.add_sub_add_left] using hp | |
| theorem window_second_moment_le (G : PortGraph V D) (lambda : β) | |
| (certificate : SpectralCertificate G lambda) (bad : V Γ D β Bool) | |
| (reversal : β e, bad (G.rot e) = bad e) | |
| (n start m : Nat) (h : start + m β€ n + 1) : | |
| mean (fun w => hits (windowEvent G bad n start m h) w ^ 2) β€ | |
| (m : β) * edgeDensity bad * | |
| (1 + 2 / (1 - lambda) + ((m : β) - 1) * edgeDensity bad) := by | |
| rw [window_second_moment_eq] | |
| exact secondMoment_return_envelope G lambda certificate bad reversal m | |
| end BinPackingGames.Foundations.PCP.PoweringMomentBound | |
| end OAI | |