File size: 6,769 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
import Mathlib
import OAI.Probability.CriticalPercolation.Modular.RelativeModular
import OAI.Probability.CriticalPercolation.Modular.ActionOrbitTransport
import OAI.Probability.CriticalPercolation.Growth.HomogeneousGeometry
import OAI.Probability.CriticalPercolation.Growth.HomogeneousAverage
import OAI.Probability.CriticalPercolation.Criticality.NormalClosureGrowth

namespace OAI

section
noncomputable section
open Set Function
open scoped Classical BigOperators

namespace CriticalPercolation.HomogeneousAnalysis.Geometry
open ActionOrbitTransport

variable {X : Type*} (W : Geometry X)

def HasDegree (d : ℕ) : Prop := ∃ C : ℕ, ∀ R : ℕ, ∃ n≥R, (W.ball n).card≤C*n^d

lemma not_quadratic_exponential_lower
    (d : ℕ) (hg : W.HasDegree d) (L : ℕ) (hL : 0<L)
    (hlo : ∀ n : ℕ, 2^n ≤ (W.ball (L*n^2)).card) : False := by
  obtain ⟨C,hC⟩ := hg
  obtain ⟨N,hN⟩ := SparseGrowth.eventually_exponential_dominates (C*(4*L)^d) (2*d)
  obtain ⟨r,hr,hbound⟩ := hC (L*(max N 1)^2)
  let n := Nat.sqrt (r/L)
  have hn : max N 1 ≤ n := Nat.le_sqrt'.mpr ((Nat.le_div_iff_mul_le hL).mpr (by
    simpa only [Nat.mul_comm] using hr))
  have hn1 : 1 ≤ n := (le_max_right N 1).trans hn
  have hnr : L*n^2 ≤ r := by
    calc
      _ ≤ L*(r/L) := Nat.mul_le_mul_left L (Nat.sqrt_le' (r/L))
      _ ≤ r := by simpa only [Nat.mul_comm] using Nat.div_mul_le_self r L
  have hrn : r ≤ (4*L)*n^2 := by
    have ht := Nat.lt_mul_div_succ r hL
    have hs : r/L+1 ≤ (n+1)^2 := Nat.succ_le_of_lt (Nat.lt_succ_sqrt' (r/L))
    have hs' : (n+1)^2 ≤ 4*n^2 := by nlinarith
    have hj := (Nat.mul_le_mul_left L hs).trans (Nat.mul_le_mul_left L hs')
    nlinarith
  have hu : 2^n ≤ (C*(4*L)^d)*n^(2*d) := by
    calc
      _ ≤ (W.ball (L*n^2)).card := hlo n
      _ ≤ (W.ball r).card := Finset.card_le_card (W.ball_mono hnr)
      _ ≤ C*r^d := hbound
      _ ≤ C*((4*L)*n^2)^d := Nat.mul_le_mul_left C (Nat.pow_le_pow_left hrn d)
      _ = (C*(4*L)^d)*n^(2*d) := by rw [mul_pow,pow_mul]; ring
  exact (not_le_of_gt (hN n ((le_max_left N 1).trans hn))) hu

lemma suborbit_card_relIndex (x y : X) : suborbitCard W.Aut X x y=
    (MulAction.stabilizer W.Aut y).relIndex (MulAction.stabilizer W.Aut x) := by
  have he : (MulAction.stabilizer W.Aut y).subgroupOf (MulAction.stabilizer W.Aut x)=
      MulAction.stabilizer (MulAction.stabilizer W.Aut x) y := by ext g; rfl
  rw [Subgroup.relIndex,he,MulAction.index_stabilizer]
  rfl

def ratio (x y : X) : ℝ := (suborbitCard W.Aut X x y : ℝ)/(suborbitCard W.Aut X y x : ℝ)
lemma ratio_relativeMass (x y : X) : W.ratio x y=
    Subgroup.relativeMass (MulAction.stabilizer W.Aut x) (MulAction.stabilizer W.Aut y) := by
  simp only [ratio,W.suborbit_card_relIndex,Subgroup.relativeMass]
lemma ratio_pos (x y : X) : 0<W.ratio x y :=
  div_pos (Nat.cast_pos.mpr (W.suborbit_card_pos x y)) (Nat.cast_pos.mpr (W.suborbit_card_pos y x))
lemma ratio_cocycle (x y z : X) : W.ratio x y*W.ratio y z=W.ratio x z := by
  simp only [W.ratio_relativeMass]
  apply Subgroup.relativeMass_cocycle
  all_goals
    rw [←W.suborbit_card_relIndex]
    exact ne_of_gt (W.suborbit_card_pos _ _)
lemma ratio_self (x : X) : W.ratio x x=1 := by
  rw [W.ratio_relativeMass,Subgroup.relativeMass_self]
lemma ratio_aut (g : W.Aut) (x y : X) : W.ratio (g x) (g y)=W.ratio x y := by
  change W.ratio (g • x) (g • y)=_
  simp only [ratio,smul_suborbitCard]
lemma ratio_pow (g : W.Aut) (x : X) (n : ℕ) : W.ratio x ((g^n) x)=(W.ratio x (g x))^n := by
  induction n with
  | zero => change W.ratio x x=(W.ratio x (g x))^0; rw [W.ratio_self,pow_zero]
  | succ n ih =>
    have he : (g^(n+1)) x=(g^n) (g x) := by rw [pow_succ]; rfl
    rw [he,←W.ratio_cocycle x ((g^n) x),W.ratio_aut,ih,pow_succ]

lemma aut_pow_ball (g : W.Aut) (x : X) (L : ℕ) (hl : g x∈W.around x L) (n : ℕ) :
    (g^n) x∈W.around x (n*L) := by
  induction n with
  | zero => change x∈W.around x (0*L); simpa only [Nat.zero_mul] using W.self_mem_around x 0
  | succ n ih =>
    have hstep : (g^n) (g x)∈W.around ((g^n) x) L := by
      rw [←W.aut_around_image]
      exact Finset.mem_image.mpr ⟨g x,hl,rfl⟩
    have hh := W.mem_around_add ih hstep
    have he : (g^(n+1)) x=(g^n) (g x) := by rw [pow_succ]; rfl
    simpa only [Nat.add_mul,Nat.one_mul,←he] using hh

lemma ratio_power_card_bound (g : W.Aut) (x : X) (L : ℕ) (hl : g x∈W.around x L) (n : ℕ) :
    (W.ratio x (g x))^n≤((W.ball (n*L)).card:ℝ) := by
  rw [←W.ratio_pow]
  have hr : W.ratio x ((g^n) x)≤(suborbitCard W.Aut X x ((g^n) x):ℝ) := by
    apply div_le_self (Nat.cast_nonneg _)
    exact_mod_cast W.suborbit_card_pos ((g^n) x) x
  apply hr.trans
  have hsub : stabilizerOrbit W.Aut X x ((g^n) x)⊆(W.around x (n*L):Set X) := by
    intro y hy
    obtain ⟨k,hk,rfl⟩ := (mem_stabilizerOrbit W.Aut X).mp hy
    change k x=x at hk
    change k ((g^n) x)∈W.around x (n*L)
    simpa only [hk] using W.mem_around.mpr
      (GraphTopology.iso_reachBall W.graph k (W.mem_around.mp (W.aut_pow_ball g x L hl n)))
  have hc := Set.ncard_le_ncard hsub (W.around x (n*L)).finite_toSet
  rw [Set.ncard_coe_finset,W.card_around x (n*L)] at hc
  exact_mod_cast hc

lemma ratio_le_one (d : ℕ) (hg : W.HasDegree d) (x y : X) : W.ratio x y≤1 := by
  by_contra! hr
  obtain ⟨g,hgxy⟩ := W.transitive x y
  obtain ⟨k,hk⟩ := pow_unbounded_of_one_lt (2:ℝ) hr
  let a := g^k
  have ha : 2≤W.ratio x (a x) := by
    dsimp [a]
    rw [W.ratio_pow,hgxy]
    exact hk.le
  obtain ⟨p,_,_⟩ := W.connected.exists_path_of_dist x (a x)
  let L := max p.length 1
  have him : a x∈W.around x L := W.mem_around.mpr ⟨p,le_max_left _ _⟩
  apply W.not_quadratic_exponential_lower d hg L (lt_of_lt_of_le Nat.zero_lt_one (le_max_right _ _))
  intro n
  have hb := W.ratio_power_card_bound a x L him n
  have he : (2:ℝ)^n≤((W.ball (n*L)).card:ℝ) :=
    (pow_le_pow_left₀ (by norm_num) ha n).trans hb
  have hh : 2^n≤(W.ball (n*L)).card := by exact_mod_cast he
  apply hh.trans (Finset.card_le_card (W.ball_mono ?_))
  have hn : n≤n^2 := by nlinarith
  nlinarith

theorem balanced_suborbits (d : ℕ) (hg : W.HasDegree d) (x y : X) :
    suborbitCard W.Aut X x y=suborbitCard W.Aut X y x := by
  have h1 := W.ratio_le_one d hg x y
  have h2 := W.ratio_le_one d hg y x
  have hp : (0:ℝ)<suborbitCard W.Aut X y x := by exact_mod_cast W.suborbit_card_pos y x
  have hq : (0:ℝ)<suborbitCard W.Aut X x y := by exact_mod_cast W.suborbit_card_pos x y
  dsimp [ratio] at h1 h2
  have he : (suborbitCard W.Aut X x y:ℝ)=(suborbitCard W.Aut X y x:ℝ) := by
    apply le_antisymm
    · exact (div_le_one hp).mp h1
    · exact (div_le_one hq).mp h2
  exact_mod_cast he

end CriticalPercolation.HomogeneousAnalysis.Geometry
end
end

end OAI