math / data /lean /OAI /Computability /BinPacking /PCP /PoweringMomentBound.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
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