openAI-math-dataset / lean /OAI /Probability /CriticalPercolation /Harmonic /LazyWalkProbability.lean
| import Mathlib | |
| import OAI.Probability.CriticalPercolation.Harmonic.LazyWalkHilbert | |
| namespace OAI | |
| section | |
| noncomputable section | |
| open Set Function | |
| open scoped Classical Pointwise BigOperators | |
| namespace CriticalPercolation.HarmonicAnalysis.WordGeometry | |
| variable {A : Type*} [Group A] (W : WordGeometry A) | |
| lemma lazyWalk_coordinate (f : RegularHilbert A) (x : A) : | |
| W.lazyWalk f x = (1/2:ℝ)*(f x+ | |
| (W.generators.card:ℝ)⁻¹*∑ s∈W.generators, f (s⁻¹*x)) := by | |
| simp only [W.lazyWalk_apply,W.walkAverage_apply,lp.coeFn_smul,lp.coeFn_add, | |
| lp.coeFn_sum,Pi.smul_apply,Pi.add_apply,Finset.sum_apply,regular_apply,smul_eq_mul] | |
| lemma lazyWalk_nonnegative (f : RegularHilbert A) (hf : ∀ x, 0≤f x) : | |
| ∀ x, 0≤W.lazyWalk f x := by | |
| intro x | |
| rw [W.lazyWalk_coordinate] | |
| exact mul_nonneg (by norm_num) (add_nonneg (hf x) | |
| (mul_nonneg (by positivity) (Finset.sum_nonneg (fun s _ => hf _)))) | |
| lemma lazyWalk_mass (f : RegularHilbert A) (m : ℝ) (hf : HasSum (fun x => f x) m) : | |
| HasSum (fun x => W.lazyWalk f x) m := by | |
| have hs : HasSum (fun x => ∑ s∈W.generators, f (s⁻¹*x)) | |
| ((W.generators.card:ℝ)*m) := by | |
| simpa only [Finset.sum_const,nsmul_eq_mul,Function.comp_apply,Equiv.coe_mulLeft] using | |
| hasSum_sum (s := W.generators) (fun s _ => | |
| (Equiv.mulLeft s⁻¹).hasSum_iff.mpr hf) | |
| have hc : (W.generators.card:ℝ)≠0 := by exact_mod_cast W.generators_card_pos.ne' | |
| have hh := HasSum.mul_left (1/2:ℝ) (hf.add (HasSum.mul_left (W.generators.card:ℝ)⁻¹ hs)) | |
| have he : (1/2:ℝ)*(m+(W.generators.card:ℝ)⁻¹*((W.generators.card:ℝ)*m))=m := by | |
| field_simp; ring | |
| rw [he] at hh | |
| simpa only [W.lazyWalk_coordinate] using hh | |
| def walkState (n : ℕ) : RegularHilbert A := | |
| (W.lazyWalk^n) (lp.single 2 (1:A) (1:ℝ)) | |
| @[simp] lemma walkState_zero : W.walkState 0=lp.single 2 (1:A) (1:ℝ) := rfl | |
| lemma walkState_succ (n : ℕ) : W.walkState (n+1)=W.lazyWalk (W.walkState n) := by | |
| simp only [walkState,pow_succ',Module.End.mul_apply] | |
| lemma walkState_nonnegative (n : ℕ) : ∀ x, 0≤W.walkState n x := by | |
| induction n with | |
| | zero => intro x; simp only [walkState_zero,lp.single_apply,Pi.single_apply]; split <;> norm_num | |
| | succ n ih => rw [W.walkState_succ]; exact W.lazyWalk_nonnegative _ ih | |
| lemma walkState_mass (n : ℕ) : HasSum (fun x => W.walkState n x) 1 := by | |
| induction n with | |
| | zero => | |
| simpa only [walkState_zero,lp.single_apply,Pi.single_apply] using hasSum_ite_eq (1:A) (1:ℝ) | |
| | succ n ih => rw [W.walkState_succ]; exact W.lazyWalk_mass _ _ ih | |
| lemma walkState_one_pos (n : ℕ) : 0<W.walkState n 1 := by | |
| induction n with | |
| | zero => simp | |
| | succ n ih => | |
| rw [W.walkState_succ,W.lazyWalk_coordinate] | |
| have hs : 0≤(W.generators.card:ℝ)⁻¹*∑ s∈W.generators, W.walkState n (s⁻¹*1) := by | |
| apply mul_nonneg (by positivity) | |
| exact Finset.sum_nonneg (fun s _ => W.walkState_nonnegative n _) | |
| positivity | |
| lemma walkState_support (n : ℕ) {x : A} (hx : x∉W.ball n) : W.walkState n x=0 := by | |
| induction n generalizing x with | |
| | zero => | |
| have hh : x≠1 := by simpa [ball] using hx | |
| simp [hh] | |
| | succ n ih => | |
| rw [W.walkState_succ,W.lazyWalk_coordinate] | |
| have hxn : x∉W.ball n := fun h => hx (W.ball_mono (by omega) h) | |
| rw [ih hxn] | |
| have hs : (∑ s∈W.generators, W.walkState n (s⁻¹*x))=0 := by | |
| apply Finset.sum_eq_zero | |
| intro s hs | |
| apply ih | |
| intro h | |
| apply hx | |
| change x∈W.generators^(n+1) | |
| rw [pow_succ'] | |
| exact Finset.mem_mul.mpr ⟨s,hs,s⁻¹*x,h,mul_inv_cancel_left s x⟩ | |
| rw [hs]; ring | |
| lemma walkPower_symmetric (n : ℕ) (f g : RegularHilbert A) : | |
| inner ℝ ((W.lazyWalk^n) f) g=inner ℝ f ((W.lazyWalk^n) g) := by | |
| induction n generalizing f g with | |
| | zero => rfl | |
| | succ n ih => | |
| calc | |
| _ = inner ℝ ((W.lazyWalk^n) (W.lazyWalk f)) g := by | |
| rw [pow_succ,Module.End.mul_apply] | |
| _ = inner ℝ (W.lazyWalk f) ((W.lazyWalk^n) g) := ih _ _ | |
| _ = inner ℝ f (W.lazyWalk ((W.lazyWalk^n) g)) := W.lazyWalk_symmetric _ _ | |
| _ = _ := by rw [pow_succ',Module.End.mul_apply] | |
| lemma walkState_double_at_one (n : ℕ) : W.walkState (2*n) 1=‖W.walkState n‖^2 := by | |
| have hh := W.walkPower_symmetric n (lp.single 2 (1:A) (1:ℝ)) (W.walkState n) | |
| rw [lp.inner_single_left] at hh | |
| have he : (W.lazyWalk^n) (W.walkState n)=W.walkState (2*n) := by | |
| simp only [walkState,←Module.End.mul_apply,←pow_add,two_mul] | |
| rw [he] at hh | |
| change inner ℝ (W.walkState n) (W.walkState n) = inner ℝ 1 (W.walkState (2*n) 1) at hh | |
| simpa only [real_inner_self_eq_norm_sq,Real.inner_apply,one_mul] using hh.symm | |
| lemma walkState_norm_sq (n : ℕ) : | |
| ‖W.walkState n‖^2=∑ x∈W.ball n, (W.walkState n x)^2 := by | |
| rw [←real_inner_self_eq_norm_sq] | |
| change (∑' x : A, inner ℝ (W.walkState n x) (W.walkState n x))=_ | |
| simp only [Real.inner_apply] | |
| rw [tsum_eq_sum (s := W.ball n)] | |
| · apply Finset.sum_congr rfl; intro x _; ring | |
| · intro x hx; rw [W.walkState_support n hx]; simp | |
| lemma walkState_norm_lower (n : ℕ) : | |
| 1≤((W.ball n).card:ℝ)*‖W.walkState n‖^2 := by | |
| have hmass : (∑ x∈W.ball n, W.walkState n x)=1 := by | |
| rw [←(W.walkState_mass n).tsum_eq] | |
| exact (tsum_eq_sum (f := fun x => W.walkState n x) (s := W.ball n) | |
| (fun x hx => W.walkState_support n (x := x) hx)).symm | |
| have hcs := Finset.sum_mul_sq_le_sq_mul_sq (W.ball n) (fun _ => (1:ℝ)) | |
| (fun x => W.walkState n x) | |
| simpa only [one_mul,hmass,one_pow,Finset.sum_const,nsmul_eq_mul,mul_one, | |
| ←W.walkState_norm_sq] using hcs | |
| end CriticalPercolation.HarmonicAnalysis.WordGeometry | |
| end | |
| end | |
| end OAI | |