File size: 7,809 Bytes
f205175 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 | import Mathlib
import OAI.Probability.CriticalPercolation.Growth.HomogeneousGeometry
import OAI.Probability.CriticalPercolation.Harmonic.FiniteHilbert
import OAI.Probability.CriticalPercolation.Harmonic.GraphWalkOperator
namespace OAI
section
noncomputable section
open Set Function
open scoped Classical BigOperators
namespace CriticalPercolation.HomogeneousAnalysis.Geometry
open HarmonicAnalysis
variable {X : Type*} (W : Geometry X)
lemma degree_pos [Infinite X] : 0<W.degree := by
obtain ⟨x,hx⟩ := exists_ne W.root
obtain ⟨p⟩ := W.connected W.root x
cases p with
| nil => exact (hx rfl).elim
| @cons a y z h p => exact Finset.card_pos.mpr ⟨y,W.mem_neighbors.mpr h⟩
lemma averaging_mass (hD : 0<W.degree) (f : FH X) : FH.mass (W.averaging f)=FH.mass f := by
have hc : (W.degree:ℝ)≠0 := by exact_mod_cast hD.ne'
have hdelta (x : X) : FH.mass (W.averaging (FH.delta x))=1 := by
rw [W.averaging_delta,map_smul,map_sum]
simp only [FH.mass_delta,Finset.sum_const,nsmul_eq_mul,mul_one,smul_eq_mul,W.neighbors_card]
exact inv_mul_cancel₀ hc
rw [←f.delta_decomposition]
simp only [map_sum,map_smul,hdelta,FH.mass_delta]
lemma lazyWalk_nonnegative (f : FH X) (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 y hy => hf y))))
lemma lazyWalk_mass (hD : 0<W.degree) (f : FH X) : FH.mass (W.lazyWalk f)=FH.mass f := by
rw [W.lazyWalk_apply,map_smul,map_add,W.averaging_mass hD]
simp only [smul_eq_mul]; ring
def walkFeature (n : ℕ) (x : X) : FH X := (W.lazyWalk^n) (FH.delta x)
abbrev walkState (n : ℕ) := W.walkFeature n W.root
@[simp] lemma walkFeature_zero (x : X) : W.walkFeature 0 x=FH.delta x := rfl
lemma walkFeature_succ (n : ℕ) (x : X) : W.walkFeature (n+1) x=W.lazyWalk (W.walkFeature n x) := by
simp only [walkFeature,pow_succ',Module.End.mul_apply]
lemma walkState_succ (n : ℕ) : W.walkState (n+1)=W.lazyWalk (W.walkState n) := W.walkFeature_succ n W.root
lemma walkState_nonnegative (n : ℕ) : ∀ x, 0≤W.walkState n x := by
induction n with
| zero => intro x; simp only [walkState,walkFeature_zero,FH.delta_apply]; split <;> norm_num
| succ n ih => rw [W.walkState_succ]; exact W.lazyWalk_nonnegative _ ih
lemma walkState_mass (hD : 0<W.degree) (n : ℕ) : FH.mass (W.walkState n)=1 := by
induction n with
| zero => exact FH.mass_delta _
| succ n ih => rw [W.walkState_succ,W.lazyWalk_mass hD,ih]
lemma walkState_root_pos (n : ℕ) : 0<W.walkState n W.root := by
induction n with
| zero => simp
| succ n ih =>
rw [W.walkState_succ,W.lazyWalk_coordinate]
have hs : 0≤(W.degree:ℝ)⁻¹*∑ y∈W.neighbors W.root, W.walkState n y := by
exact mul_nonneg (by positivity) (Finset.sum_nonneg (fun y hy => W.walkState_nonnegative n y))
positivity
lemma walkState_support (n : ℕ) {x : X} (hx : x∉W.ball n) : W.walkState n x=0 := by
induction n generalizing x with
| zero =>
have hne : x≠W.root := by intro h; apply hx; rw [h]; exact W.self_mem_around _ _
simp [hne]
| succ n ih =>
rw [W.walkState_succ,W.lazyWalk_coordinate,ih (fun h => hx (W.ball_mono (by omega) h))]
have hs : (∑ y∈W.neighbors x, W.walkState n y)=0 := by
apply Finset.sum_eq_zero
intro y hy
apply ih
intro hn
apply hx
apply W.mem_around_add hn
exact W.mem_around.mpr ⟨SimpleGraph.Walk.cons (W.mem_neighbors.mp hy).symm .nil,by simp⟩
rw [hs]; ring
lemma walkPower_symmetric (n : ℕ) (f g : FH X) :
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_root (n : ℕ) : W.walkState (2*n) W.root=‖W.walkState n‖^2 := by
have hh := W.walkPower_symmetric n (FH.delta W.root) (W.walkState n)
rw [FH.delta_inner] at hh
have he : (W.lazyWalk^n) (W.walkState n)=W.walkState (2*n) := by
simp only [walkState,walkFeature,←Module.End.mul_apply,←pow_add,two_mul]
rw [he] at hh
change inner ℝ (W.walkState n) (W.walkState n)=_ at hh
rw [real_inner_self_eq_norm_sq] at hh
exact hh.symm
lemma walkState_norm_sq (n : ℕ) : ‖W.walkState n‖^2=∑ x∈W.ball n, (W.walkState n x)^2 :=
(W.walkState n).norm_sq_eq_sum _ (by
intro x hx; by_contra hn; exact ((W.walkState n).mem_support x).mp hx (W.walkState_support n hn))
lemma walkState_norm_lower (hD : 0<W.degree) (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 hD n]
exact (tsum_eq_sum (f:=fun x => W.walkState n x) (s:=W.ball n)
(fun x hx => W.walkState_support n hx)).symm
have hc := 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 hc
lemma transport_averaging (g : W.Aut) (f : FH X) :
FH.transport g.toEquiv (W.averaging f)=W.averaging (FH.transport g.toEquiv f) := by
ext x
simp only [FH.transport_apply,W.averaging_coordinate]
congr 1
change (∑ y∈W.neighbors (g.symm x), f y)=∑ y∈W.neighbors x, f (g.symm y)
rw [←W.neighbors_image g.symm x,Finset.sum_image]
exact fun a ha b hb h => g.symm.injective h
lemma transport_lazyWalk (g : W.Aut) (f : FH X) :
FH.transport g.toEquiv (W.lazyWalk f)=W.lazyWalk (FH.transport g.toEquiv f) := by
simp only [W.lazyWalk_apply,map_smul,map_add,W.transport_averaging]
lemma transport_walkFeature (g : W.Aut) (n : ℕ) (x : X) :
FH.transport g.toEquiv (W.walkFeature n x)=W.walkFeature n (g x) := by
induction n with
| zero => exact FH.transport_delta _ _
| succ n ih => rw [W.walkFeature_succ,W.transport_lazyWalk,ih,W.walkFeature_succ]
lemma walkFeature_norm (n : ℕ) (x : X) : ‖W.walkFeature n x‖=‖W.walkState n‖ := by
obtain ⟨g,rfl⟩ := W.transitive W.root x
rw [←W.transport_walkFeature,LinearIsometryEquiv.norm_map]
lemma walkFeature_average (n : ℕ) (x : X) :
(∑ y∈W.neighbors x, W.walkFeature n y)=(W.degree:ℝ) • W.averaging (W.walkFeature n x) := by
have hc : W.averaging.comp W.lazyWalk=W.lazyWalk.comp W.averaging := by
ext f y
simp only [LinearMap.comp_apply,W.lazyWalk_apply,map_smul,map_add]
have hcomm : ∀ n, W.averaging.comp (W.lazyWalk^n)=(W.lazyWalk^n).comp W.averaging := by
intro n
induction n with
| zero => rfl
| succ n ih =>
change W.averaging*(W.lazyWalk^(n+1))=(W.lazyWalk^(n+1))*W.averaging
rw [pow_succ',←mul_assoc,show W.averaging*W.lazyWalk=W.lazyWalk*W.averaging from hc,
mul_assoc,show W.averaging*W.lazyWalk^n=W.lazyWalk^n*W.averaging from ih,←mul_assoc,←pow_succ']
have hd (x : X) : (W.degree:ℝ) • W.averaging (FH.delta x)=∑ y∈W.neighbors x, FH.delta y := by
by_cases hD : W.degree=0
· have he : W.neighbors x=∅ := Finset.card_eq_zero.mp (by exact (W.neighbors_card x).trans hD)
simp [hD,he]
· rw [W.averaging_delta,smul_smul,mul_inv_cancel₀ (by exact_mod_cast hD),one_smul]
calc
_ = (W.lazyWalk^n) (∑ y∈W.neighbors x, FH.delta y) := (map_sum _ _ _).symm
_ = (W.lazyWalk^n) ((W.degree:ℝ) • W.averaging (FH.delta x)) := by rw [hd]
_ = _ := by rw [map_smul,←LinearMap.comp_apply,←hcomm,LinearMap.comp_apply]; rfl
end CriticalPercolation.HomogeneousAnalysis.Geometry
end
end
end OAI
|