math / data /lean /OAI /Probability /CriticalZ3 /Basic.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
28 kB
import OAI.Probability.CriticalZ3.Model
namespace OAI
universe uE uOmega uV
open MeasureTheory ProbabilityTheory
namespace CriticalZ3
@[simp] theorem parameter_coe {p : ℝ} (hp : p ∈ Set.Icc (0 : ℝ) 1) :
(parameter p : ℝ) = p := by
simp [parameter, min_eq_right hp.2, max_eq_right hp.1]
@[simp] theorem parameter_zero : parameter 0 = 0 := Subtype.ext (by simp [parameter])
@[simp] theorem parameter_one : parameter 1 = 1 := Subtype.ext (by simp [parameter])
instance bondLaw_probability (p : ℝ) : IsProbabilityMeasure (bondLaw p) := by
unfold bondLaw
infer_instance
instance siteLaw_probability (p : ℝ) : IsProbabilityMeasure (siteLaw p) := by
unfold siteLaw
infer_instance
@[simp] theorem bondLaw_zero : bondLaw 0 = Measure.dirac (fun _ => false) := by
simp [bondLaw]
@[simp] theorem siteLaw_zero : siteLaw 0 = Measure.dirac (fun _ => false) := by
simp [siteLaw]
@[simp] theorem bondLaw_one : bondLaw 1 = Measure.dirac (fun _ => true) := by
simp [bondLaw]
@[simp] theorem siteLaw_one : siteLaw 1 = Measure.dirac (fun _ => true) := by
simp [siteLaw]
theorem nearestNeighbor_symm {x y : Vertex} (h : NearestNeighbor x y) :
NearestNeighbor y x := by
obtain ⟨i, h⟩ := h
exact ⟨i, h.symm⟩
theorem bondOpen_symm {ω : BondConfig} {x y : Vertex} (h : BondOpen ω x y) :
BondOpen ω y x := h.symm
theorem siteOpen_symm {ω : SiteConfig} {x y : Vertex} (h : SiteOpen ω x y) :
SiteOpen ω y x := ⟨nearestNeighbor_symm h.1, h.2.2, h.2.1⟩
/-- Finite path length, used solely to prove measurability of reachability. -/
def PathLength {V : Type uV} (r : V → V → Prop) : ℕ → V → V → Prop
| 0, x, y => x = y
| n + 1, x, y => ∃ z, PathLength r n x z ∧ r z y
theorem pathLength_rtg {V : Type uV} {r : V → V → Prop} {n : ℕ} {x y : V}
(h : PathLength r n x y) : Relation.ReflTransGen r x y := by
induction n generalizing y with
| zero => cases h; exact .refl
| succ n ih =>
obtain ⟨z, hz, hy⟩ := h
exact (ih hz).tail hy
theorem rtg_iff_exists_pathLength {V : Type uV} {r : V → V → Prop} {x y : V} :
Relation.ReflTransGen r x y ↔ ∃ n, PathLength r n x y := by
constructor
· intro h
induction h with
| refl => exact ⟨0, rfl⟩
| @tail y z _ hy ih =>
obtain ⟨n, hn⟩ := ih
exact ⟨n + 1, y, hn, hy⟩
· rintro ⟨n, hn⟩
exact pathLength_rtg hn
theorem measurableSet_rtg {Ω : Type uOmega} {V : Type uV} [MeasurableSpace Ω] [Countable V]
(r : Ω → V → V → Prop) (hr : ∀ x y, MeasurableSet {ω | r ω x y}) (x y : V) :
MeasurableSet {ω | Relation.ReflTransGen (r ω) x y} := by
have hpath (n : ℕ) (x y : V) : MeasurableSet {ω | PathLength (r ω) n x y} := by
induction n generalizing x y with
| zero => simp only [PathLength]; exact MeasurableSet.const _
| succ n ih =>
simp only [PathLength, Set.ofPred_exists]
exact MeasurableSet.iUnion (fun z => (ih x z).inter (hr z y))
simp only [rtg_iff_exists_pathLength, Set.ofPred_exists]
exact MeasurableSet.iUnion (fun n => hpath n x y)
theorem measurableSet_bondOpen (x y : Vertex) :
MeasurableSet {ω : BondConfig | BondOpen ω x y} := by
unfold BondOpen
simp only [Set.ofPred_or, Set.ofPred_exists, Set.ofPred_and]
apply MeasurableSet.union
· exact MeasurableSet.iUnion (fun i => (MeasurableSet.const _).inter
(measurableSet_eq_fun (measurable_pi_apply (x, i)) measurable_const))
· exact MeasurableSet.iUnion (fun i => (MeasurableSet.const _).inter
(measurableSet_eq_fun (measurable_pi_apply (y, i)) measurable_const))
theorem measurableSet_siteOpen (x y : Vertex) :
MeasurableSet {ω : SiteConfig | SiteOpen ω x y} := by
exact (MeasurableSet.const _).inter
((measurableSet_eq_fun (measurable_pi_apply x) measurable_const).inter
(measurableSet_eq_fun (measurable_pi_apply y) measurable_const))
theorem measurableSet_bondConnected (x y : Vertex) :
MeasurableSet {ω : BondConfig | BondConnected ω x y} :=
measurableSet_rtg BondOpen measurableSet_bondOpen x y
theorem measurableSet_siteConnected (x y : Vertex) :
MeasurableSet {ω : SiteConfig | SiteConnected ω x y} :=
(measurableSet_eq_fun (measurable_pi_apply x) measurable_const).inter
(measurableSet_rtg SiteOpen measurableSet_siteOpen x y)
theorem infinite_iff_escape_finset {V : Type uV} (s : Set V) :
s.Infinite ↔ ∀ t : Finset V, ∃ y ∈ s, y ∉ t := by
classical
constructor
· exact fun hs t => hs.exists_notMem_finset t
· intro h hs
obtain ⟨y, hy, hn⟩ := h hs.toFinset
exact hn (hs.mem_toFinset.mpr hy)
theorem measurableSet_infinite_fiber {Ω : Type uOmega} {V : Type uV} [MeasurableSpace Ω] [Countable V]
(r : Ω → V → Prop) (hr : ∀ y, MeasurableSet {ω | r ω y}) :
MeasurableSet {ω | {y | r ω y}.Infinite} := by
simp only [infinite_iff_escape_finset, Set.mem_ofPred_eq]
rw [Set.ofPred_forall]
apply MeasurableSet.iInter
intro t
rw [Set.ofPred_exists]
exact MeasurableSet.iUnion (fun y => (hr y).inter (MeasurableSet.const _))
theorem measurableSet_bondInfiniteAt (x : Vertex) : MeasurableSet (bondInfiniteAt x) :=
measurableSet_infinite_fiber (fun ω y => BondConnected ω x y)
(measurableSet_bondConnected x)
theorem measurableSet_siteInfiniteAt (x : Vertex) : MeasurableSet (siteInfiniteAt x) :=
measurableSet_infinite_fiber (fun ω y => SiteConnected ω x y)
(measurableSet_siteConnected x)
/-- An infinite nearest-neighbor ray, used to certify supercriticality at one. -/
def ray (x : Vertex) (n : ℕ) : Vertex :=
fun j => x j + if j = 0 then (n : ℤ) else 0
@[simp] theorem ray_zero (x : Vertex) : ray x 0 = x := by
ext j
simp [ray]
@[simp] theorem ray_succ (x : Vertex) (n : ℕ) : ray x (n + 1) = step (ray x n) 0 := by
ext j
by_cases hj : j = 0
· subst j; simp [ray, step]; omega
· simp [ray, step, hj, Ne.symm hj]
theorem ray_injective (x : Vertex) : Function.Injective (ray x) := by
intro n m h
have he := congrFun h 0
simp only [ray] at he
exact Int.ofNat_inj.mp (add_left_cancel he)
theorem bondConnected_open_ray (x : Vertex) (n : ℕ) :
BondConnected (fun _ => true) x (ray x n) := by
induction n with
| zero => rw [ray_zero]; exact .refl
| succ n ih =>
apply ih.tail
exact Or.inl ⟨0, ray_succ x n, rfl⟩
theorem siteConnected_open_ray (x : Vertex) (n : ℕ) :
SiteConnected (fun _ => true) x (ray x n) := by
refine ⟨rfl, ?_⟩
induction n with
| zero => rw [ray_zero]
| succ n ih =>
apply ih.tail
exact ⟨⟨0, Or.inl (ray_succ x n)⟩, rfl, rfl⟩
theorem bondCluster_open_infinite (x : Vertex) : (bondCluster (fun _ => true) x).Infinite :=
(Set.infinite_range_of_injective (ray_injective x)).mono
(by rintro y ⟨n, rfl⟩; exact bondConnected_open_ray x n)
theorem siteCluster_open_infinite (x : Vertex) : (siteCluster (fun _ => true) x).Infinite :=
(Set.infinite_range_of_injective (ray_injective x)).mono
(by rintro y ⟨n, rfl⟩; exact siteConnected_open_ray x n)
@[simp] theorem bondCluster_closed (x : Vertex) : bondCluster (fun _ => false) x = {x} := by
ext y
change Relation.ReflTransGen (BondOpen (fun _ => false)) x y ↔ y = x
apply Relation.reflTransGen_iff_eq
intro y h
rcases h with ⟨i, _, hi⟩ | ⟨i, _, hi⟩ <;> cases hi
@[simp] theorem siteCluster_closed (x : Vertex) : siteCluster (fun _ => false) x = ∅ := by
ext y
simp [siteCluster, SiteConnected]
@[simp] theorem bondLaw_zero_infinite (x : Vertex) : bondLaw 0 (bondInfiniteAt x) = 0 := by
rw [bondLaw_zero, Measure.dirac_apply' _ (measurableSet_bondInfiniteAt x)]
simp [bondInfiniteAt]
@[simp] theorem siteLaw_zero_infinite (x : Vertex) : siteLaw 0 (siteInfiniteAt x) = 0 := by
rw [siteLaw_zero, Measure.dirac_apply' _ (measurableSet_siteInfiniteAt x)]
simp [siteInfiniteAt]
@[simp] theorem bondLaw_one_infinite (x : Vertex) : bondLaw 1 (bondInfiniteAt x) = 1 := by
rw [bondLaw_one, Measure.dirac_apply' _ (measurableSet_bondInfiniteAt x)]
simp [bondInfiniteAt, bondCluster_open_infinite]
@[simp] theorem siteLaw_one_infinite (x : Vertex) : siteLaw 1 (siteInfiniteAt x) = 1 := by
rw [siteLaw_one, Measure.dirac_apply' _ (measurableSet_siteInfiniteAt x)]
simp [siteInfiniteAt, siteCluster_open_infinite]
theorem bond_supercritical_nonempty :
{p : ℝ | p ∈ Set.Icc (0 : ℝ) 1 ∧ 0 < bondLaw p (bondInfiniteAt 0)}.Nonempty :=
⟨1, by norm_num only [Set.mem_ofPred_eq, Set.mem_Icc, bondLaw_one_infinite]; trivial⟩
theorem site_supercritical_nonempty :
{p : ℝ | p ∈ Set.Icc (0 : ℝ) 1 ∧ 0 < siteLaw p (siteInfiniteAt 0)}.Nonempty :=
⟨1, by norm_num only [Set.mem_ofPred_eq, Set.mem_Icc, siteLaw_one_infinite]; trivial⟩
theorem bondCritical_mem : bondCritical ∈ Set.Icc (0 : ℝ) 1 := by
constructor
· exact le_csInf bond_supercritical_nonempty (fun _ hp => hp.1.1)
· exact csInf_le ⟨0, fun _ hp => hp.1.1⟩ (by norm_num only [Set.mem_ofPred_eq, Set.mem_Icc, bondLaw_one_infinite]; trivial)
theorem siteCritical_mem : siteCritical ∈ Set.Icc (0 : ℝ) 1 := by
constructor
· exact le_csInf site_supercritical_nonempty (fun _ hp => hp.1.1)
· exact csInf_le ⟨0, fun _ hp => hp.1.1⟩ (by norm_num only [Set.mem_ofPred_eq, Set.mem_Icc, siteLaw_one_infinite]; trivial)
theorem bond_subcritical_origin {p : ℝ} (hp : p ∈ Set.Icc (0 : ℝ) 1)
(hlt : p < bondCritical) : bondLaw p (bondInfiniteAt 0) = 0 := by
by_contra h
have hpos := bot_lt_iff_ne_bot.mpr h
have hc : bondCritical ≤ p := csInf_le ⟨0, fun _ hr => hr.1.1⟩ ⟨hp, hpos⟩
exact (not_le_of_gt hlt) hc
theorem site_subcritical_origin {p : ℝ} (hp : p ∈ Set.Icc (0 : ℝ) 1)
(hlt : p < siteCritical) : siteLaw p (siteInfiniteAt 0) = 0 := by
by_contra h
have hpos := bot_lt_iff_ne_bot.mpr h
have hc : siteCritical ≤ p := csInf_le ⟨0, fun _ hr => hr.1.1⟩ ⟨hp, hpos⟩
exact (not_le_of_gt hlt) hc
/-! Finite alterations, tail invariance, and the infinite seed limit. -/
/-- A path with finitely many types of exceptional arrivals ends in the
unperturbed component of its starting point or of an exceptional vertex. -/
theorem rtg_covered_by_roots {V : Type uV} {r s : V → V → Prop} {F : Set V}
(h : ∀ a b, r a b → s a b ∨ b ∈ F) {x y : V}
(hxy : Relation.ReflTransGen r x y) :
∃ z ∈ insert x F, Relation.ReflTransGen s z y := by
induction hxy with
| refl => exact ⟨x, Set.mem_insert x F, .refl⟩
| @tail a b _ hab ih =>
rcases h a b hab with hs | hb
· obtain ⟨z,hz,hza⟩ := ih
exact ⟨z,hz,hza.tail hs⟩
· exact ⟨b,Set.mem_insert_of_mem x hb,.refl⟩
theorem finite_components_of_finite_perturbation {V : Type uV} {r s : V → V → Prop}
{F : Set V} (hF : F.Finite) (h : ∀ a b, r a b → s a b ∨ b ∈ F)
(hs : ∀ x, {y | Relation.ReflTransGen s x y}.Finite) (x : V) :
{y | Relation.ReflTransGen r x y}.Finite := by
apply ((hF.insert x).biUnion (fun z _ => hs z)).subset
intro y hy
obtain ⟨z,hz,hzy⟩ := rtg_covered_by_roots h hy
exact Set.mem_iUnion₂.mpr ⟨z,hz,hzy⟩
theorem infinite_component_of_perturbation {V : Type uV} {r s : V → V → Prop}
{F : Set V} (hF : F.Finite) (h : ∀ a b, r a b → s a b ∨ b ∈ F)
(hr : ∃ x, {y | Relation.ReflTransGen r x y}.Infinite) :
∃ x, {y | Relation.ReflTransGen s x y}.Infinite := by
by_contra hn
push Not at hn
obtain ⟨x,hx⟩ := hr
exact hx (finite_components_of_finite_perturbation hF h hn x)
/-- A negative coordinate step, needed only to list all finitely many neighbors. -/
def backstep (x : Vertex) (i : Fin 3) : Vertex := fun j => x j - if i = j then 1 else 0
@[simp] theorem step_backstep (x : Vertex) (i : Fin 3) : step (backstep x i) i = x := by
funext j
simp [step, backstep]
@[simp] theorem backstep_step (x : Vertex) (i : Fin 3) : backstep (step x i) i = x := by
funext j
simp [step, backstep]
theorem nearestNeighbor_iff_steps (x y : Vertex) :
NearestNeighbor x y ↔ ∃ i, y = step x i ∨ y = backstep x i := by
constructor
· rintro ⟨i, hi | hi⟩
· exact ⟨i,Or.inl hi⟩
· exact ⟨i,Or.inr (by rw [hi,backstep_step])⟩
· rintro ⟨i,hi | hi⟩
· exact ⟨i,Or.inl hi⟩
· exact ⟨i,Or.inr (by rw [hi,step_backstep])⟩
theorem finite_neighbors (x : Vertex) : {y | NearestNeighbor x y}.Finite := by
apply ((Set.finite_range (step x)).union (Set.finite_range (backstep x))).subset
intro y hy
obtain ⟨i,hi | hi⟩ := (nearestNeighbor_iff_steps x y).mp hy
· exact Or.inl ⟨i,hi.symm⟩
· exact Or.inr ⟨i,hi.symm⟩
def bondExistsInfinite : Set BondConfig := {ω | ∃ x, (bondCluster ω x).Infinite}
def siteExistsInfinite : Set SiteConfig := {ω | ∃ x, (siteCluster ω x).Infinite}
theorem measurableSet_bondExistsInfinite : MeasurableSet bondExistsInfinite := by
simpa only [bondExistsInfinite,bondInfiniteAt,Set.iUnion_ofPred] using
(MeasurableSet.iUnion (fun x => measurableSet_bondInfiniteAt x))
theorem measurableSet_siteExistsInfinite : MeasurableSet siteExistsInfinite := by
simpa only [siteExistsInfinite,siteInfiniteAt,Set.iUnion_ofPred] using
(MeasurableSet.iUnion (fun x => measurableSet_siteInfiniteAt x))
theorem bondExistsInfinite_of_finite_alteration {ω ω' : BondConfig}
(J : Finset Bond) (hagree : ∀ e ∉ J, ω' e = ω e) (hω : ω ∈ bondExistsInfinite) :
ω' ∈ bondExistsInfinite := by
let F : Set Vertex := ((fun e : Bond => e.1) '' (J : Set Bond)) ∪
((fun e : Bond => step e.1 e.2) '' (J : Set Bond))
have hF : F.Finite := (J.finite_toSet.image _).union (J.finite_toSet.image _)
apply infinite_component_of_perturbation hF (s := BondOpen ω') (r := BondOpen ω) _ hω
intro a b hab
rcases hab with ⟨i,hb,hi⟩ | ⟨i,ha,hi⟩
· by_cases hj : (a,i) ∈ J
· exact Or.inr (Or.inr ⟨(a,i),hj,hb.symm⟩)
· exact Or.inl (Or.inl ⟨i,hb,(hagree (a,i) hj).trans hi⟩)
· by_cases hj : (b,i) ∈ J
· exact Or.inr (Or.inl ⟨(b,i),hj,rfl⟩)
· exact Or.inl (Or.inr ⟨i,ha,(hagree (b,i) hj).trans hi⟩)
theorem bondExistsInfinite_finite_alteration {ω ω' : BondConfig}
(J : Finset Bond) (hagree : ∀ e ∉ J, ω' e = ω e) :
ω' ∈ bondExistsInfinite ↔ ω ∈ bondExistsInfinite :=
⟨bondExistsInfinite_of_finite_alteration J (fun e he => (hagree e he).symm),
bondExistsInfinite_of_finite_alteration J hagree⟩
theorem siteOpen_open_left {ω : SiteConfig} {x y : Vertex} (h : SiteOpen ω x y) :
ω x = true := h.2.1
theorem siteOpen_open_right {ω : SiteConfig} {x y : Vertex} (h : SiteOpen ω x y) :
ω y = true := h.2.2
theorem siteRtg_from_closed {ω : SiteConfig} {x y : Vertex} (hx : ω x ≠ true)
(h : Relation.ReflTransGen (SiteOpen ω) x y) : y = x := by
induction h with
| refl => rfl
| @tail a b _ hab ih =>
exact (hx (ih ▸ siteOpen_open_left hab)).elim
theorem siteInfinite_iff_rtg_infinite (ω : SiteConfig) (x : Vertex) :
(siteCluster ω x).Infinite ↔ {y | Relation.ReflTransGen (SiteOpen ω) x y}.Infinite := by
by_cases hx : ω x = true
· simp only [siteCluster,SiteConnected,hx,true_and]
· have he : {y | Relation.ReflTransGen (SiteOpen ω) x y} = {x} := by
ext y
exact ⟨siteRtg_from_closed hx, fun hy => by rw [Set.mem_singleton_iff.mp hy]; exact .refl⟩
simp [siteCluster,SiteConnected,hx,he]
theorem siteExistsInfinite_of_finite_alteration {ω ω' : SiteConfig}
(J : Finset Vertex) (hagree : ∀ e ∉ J, ω' e = ω e) (hω : ω ∈ siteExistsInfinite) :
ω' ∈ siteExistsInfinite := by
let F : Set Vertex := (J : Set Vertex) ∪ ⋃ x ∈ (J : Set Vertex), {y | NearestNeighbor x y}
have hF : F.Finite := J.finite_toSet.union
(J.finite_toSet.biUnion (fun x _ => finite_neighbors x))
have hh : ∀ a b, SiteOpen ω a b → SiteOpen ω' a b ∨ b ∈ F := by
intro a b hab
by_cases ha : a ∈ J
· exact Or.inr (Or.inr (Set.mem_iUnion₂.mpr ⟨a,ha,hab.1⟩))
by_cases hb : b ∈ J
· exact Or.inr (Or.inl hb)
· exact Or.inl ⟨hab.1,(hagree a ha).trans hab.2.1,(hagree b hb).trans hab.2.2⟩
obtain ⟨x,hx⟩ := hω
obtain ⟨y,hy⟩ := infinite_component_of_perturbation hF hh
⟨x,(siteInfinite_iff_rtg_infinite ω x).mp hx⟩
exact ⟨y,(siteInfinite_iff_rtg_infinite ω' y).mpr hy⟩
theorem siteExistsInfinite_finite_alteration {ω ω' : SiteConfig}
(J : Finset Vertex) (hagree : ∀ e ∉ J, ω' e = ω e) :
ω' ∈ siteExistsInfinite ↔ ω ∈ siteExistsInfinite :=
⟨siteExistsInfinite_of_finite_alteration J (fun e he => (hagree e he).symm),
siteExistsInfinite_of_finite_alteration J hagree⟩
open Filter
open scoped Topology
/-- Kolmogorov zero-one law in the finite-alteration form needed here. This
is proved for arbitrary independent bit coordinates, not assumed for clusters. -/
theorem zero_one_of_finite_alteration {E : Type uE} (μ : Measure (E → Bool))
(hi : iIndepFun (fun e (ω : E → Bool) => ω e) μ)
(A : Set (E → Bool)) (hA : MeasurableSet A)
(hinv : ∀ (J : Finset E) (ω ω' : E → Bool),
(∀ e ∉ J, ω' e = ω e) → (ω' ∈ A ↔ ω ∈ A)) : μ A = 0 ∨ μ A = 1 := by
classical
let M : E → MeasurableSpace (E → Bool) :=
fun e => MeasurableSpace.comap (fun ω => ω e) inferInstance
have hM : ∀ e, M e ≤ (inferInstance : MeasurableSpace (E → Bool)) := fun e => (measurable_pi_apply e).comap_le
have hmi : iIndep M μ := (iIndepFun_iff_iIndep _ _ _).mp hi
have htail : MeasurableSet[limsup M cofinite] A := by
rw [Filter.limsup_eq_iInf_iSup]
apply MeasurableSpace.measurableSet_iInf.mpr
intro s
apply MeasurableSpace.measurableSet_iInf.mpr
intro hs
have hc : sᶜ.Finite := Filter.mem_cofinite.mp hs
let f : (E → Bool) → (E → Bool) := fun ω e => if e ∈ s then ω e else false
have hf : @Measurable (E → Bool) (E → Bool) (⨆ e ∈ s, M e) inferInstance f := by
apply @Measurable.of_eval (E → Bool) E (fun _ => Bool) (⨆ e ∈ s, M e) _ f
intro e
by_cases he : e ∈ s
· simp only [f,ite_eq_left he]
exact Measurable.of_comap_le (le_iSup_of_le e (le_iSup_of_le he le_rfl))
· simp only [f,ite_eq_right he]
exact measurable_const
have heq : f ⁻¹' A = A := by
ext ω
apply hinv hc.toFinset ω (f ω)
intro e he
have hes : e ∈ s := by simpa only [Set.Finite.mem_toFinset,Set.mem_compl_iff,not_not] using he
simp only [f,ite_eq_left hes]
rw [← heq]
exact hf hA
apply measure_zero_or_one_of_measurableSet_limsup hM hmi
(p := fun s : Set E => s.Finite) (ns := fun J : Finset E => (J : Set E))
(fun s hs => Filter.mem_cofinite.mpr (by simpa only [compl_compl] using hs)) _
(fun J => J.finite_toSet) (fun e => ⟨{e},by simp⟩) htail
intro J K
exact ⟨J ∪ K, by simp, by simp⟩
theorem bondExistsInfinite_zero_one (p : ℝ) :
bondLaw p bondExistsInfinite = 0 ∨ bondLaw p bondExistsInfinite = 1 := by
apply zero_one_of_finite_alteration (bondLaw p)
(iIndepFun_infinitePi (X := fun _ => id) (fun _ => measurable_id))
bondExistsInfinite measurableSet_bondExistsInfinite
intro J ω ω' h
exact bondExistsInfinite_finite_alteration J h
theorem siteExistsInfinite_zero_one (p : ℝ) :
siteLaw p siteExistsInfinite = 0 ∨ siteLaw p siteExistsInfinite = 1 := by
apply zero_one_of_finite_alteration (siteLaw p)
(iIndepFun_infinitePi (X := fun _ => id) (fun _ => measurable_id))
siteExistsInfinite measurableSet_siteExistsInfinite
intro J ω ω' h
exact siteExistsInfinite_finite_alteration J h
theorem bondExistsInfinite_one {p : ℝ} (hp : 0 < bondLaw p (bondInfiniteAt 0)) :
bondLaw p bondExistsInfinite = 1 := by
apply (bondExistsInfinite_zero_one p).resolve_left
have h : 0 < bondLaw p bondExistsInfinite := hp.trans_le
(measure_mono (fun _ h => ⟨0,h⟩))
exact ne_of_gt h
theorem siteExistsInfinite_one {p : ℝ} (hp : 0 < siteLaw p (siteInfiniteAt 0)) :
siteLaw p siteExistsInfinite = 1 := by
apply (siteExistsInfinite_zero_one p).resolve_left
have h : 0 < siteLaw p siteExistsInfinite := hp.trans_le
(measure_mono (fun _ h => ⟨0,h⟩))
exact ne_of_gt h
def cube (c : Vertex) (n : ℕ) : Set Vertex :=
Set.Icc (fun i => c i - (n : ℤ)) (fun i => c i + (n : ℤ))
theorem mem_cube {c x : Vertex} {n : ℕ} :
x ∈ cube c n ↔ ∀ i, c i - (n : ℤ) ≤ x i ∧ x i ≤ c i + (n : ℤ) := by
simp only [cube,Set.mem_Icc,Pi.le_def,forall_and]
theorem cube_finite (c : Vertex) (n : ℕ) : (cube c n).Finite := Set.finite_Icc _ _
theorem cube_mono (c : Vertex) : Monotone (cube c) := by
intro m n h x hx
rw [mem_cube] at hx ⊢
intro i
have hn : (m : ℤ) ≤ n := by exact_mod_cast h
obtain ⟨h₁,h₂⟩ := hx i
constructor <;> omega
theorem exists_mem_cube (c x : Vertex) : ∃ n, x ∈ cube c n := by
let n := Finset.univ.sup (fun i : Fin 3 => (x i - c i).natAbs)
refine ⟨n,mem_cube.mpr (fun i => ?_)⟩
have hn : ((x i - c i).natAbs : ℤ) ≤ n := by
exact_mod_cast (Finset.le_sup (f := fun i : Fin 3 => (x i - c i).natAbs) (Finset.mem_univ i))
have hu := Int.le_natAbs (a := x i - c i)
have hl := Int.le_natAbs (a := -(x i - c i))
simp only [Int.natAbs_neg] at hl
constructor <;> omega
@[simp] theorem iUnion_cube (c : Vertex) : (⋃ n, cube c n) = Set.univ := by
ext x
simp only [Set.mem_iUnion,Set.mem_univ,iff_true]
exact exists_mem_cube c x
def bondSeedInfinite (c : Vertex) (n : ℕ) : Set BondConfig :=
{ω | ∃ x ∈ cube c n, ω ∈ bondInfiniteAt x}
def siteSeedInfinite (c : Vertex) (n : ℕ) : Set SiteConfig :=
{ω | ∃ x ∈ cube c n, ω ∈ siteInfiniteAt x}
theorem bondSeedInfinite_mono (c : Vertex) : Monotone (bondSeedInfinite c) := by
intro m n h ω ⟨x,hx,hi⟩
exact ⟨x,cube_mono c h hx,hi⟩
theorem siteSeedInfinite_mono (c : Vertex) : Monotone (siteSeedInfinite c) := by
intro m n h ω ⟨x,hx,hi⟩
exact ⟨x,cube_mono c h hx,hi⟩
theorem measurableSet_bondSeedInfinite (c : Vertex) (n : ℕ) :
MeasurableSet (bondSeedInfinite c n) := by
simp only [bondSeedInfinite,Set.ofPred_exists,Set.ofPred_and]
apply MeasurableSet.iUnion
intro x
by_cases hx : x ∈ cube c n
· simpa only [hx,Set.ofPred_true,Set.univ_inter,Set.ofPred_mem_eq] using measurableSet_bondInfiniteAt x
· simp only [hx,Set.ofPred_false,Set.empty_inter,MeasurableSet.empty]
theorem measurableSet_siteSeedInfinite (c : Vertex) (n : ℕ) :
MeasurableSet (siteSeedInfinite c n) := by
simp only [siteSeedInfinite,Set.ofPred_exists,Set.ofPred_and]
apply MeasurableSet.iUnion
intro x
by_cases hx : x ∈ cube c n
· simpa only [hx,Set.ofPred_true,Set.univ_inter,Set.ofPred_mem_eq] using measurableSet_siteInfiniteAt x
· simp only [hx,Set.ofPred_false,Set.empty_inter,MeasurableSet.empty]
theorem iUnion_bondSeedInfinite (c : Vertex) :
(⋃ n, bondSeedInfinite c n) = bondExistsInfinite := by
ext ω
simp only [Set.mem_iUnion,bondSeedInfinite,bondExistsInfinite,Set.mem_ofPred_eq]
constructor
· rintro ⟨n,x,_,hx⟩; exact ⟨x,hx⟩
· rintro ⟨x,hx⟩
obtain ⟨n,hn⟩ := exists_mem_cube c x
exact ⟨n,x,hn,hx⟩
theorem iUnion_siteSeedInfinite (c : Vertex) :
(⋃ n, siteSeedInfinite c n) = siteExistsInfinite := by
ext ω
simp only [Set.mem_iUnion,siteSeedInfinite,siteExistsInfinite,Set.mem_ofPred_eq]
constructor
· rintro ⟨n,x,_,hx⟩; exact ⟨x,hx⟩
· rintro ⟨x,hx⟩
obtain ⟨n,hn⟩ := exists_mem_cube c x
exact ⟨n,x,hn,hx⟩
theorem bondSeedInfinite_tendsto_one {p : ℝ}
(hp : 0 < bondLaw p (bondInfiniteAt 0)) (c : Vertex) :
Tendsto (fun n => bondLaw p (bondSeedInfinite c n)) atTop (𝓝 1) := by
have h := tendsto_measure_iUnion_atTop (μ := bondLaw p) (bondSeedInfinite_mono c)
simpa only [iUnion_bondSeedInfinite,bondExistsInfinite_one hp,Function.comp_def] using h
theorem siteSeedInfinite_tendsto_one {p : ℝ}
(hp : 0 < siteLaw p (siteInfiniteAt 0)) (c : Vertex) :
Tendsto (fun n => siteLaw p (siteSeedInfinite c n)) atTop (𝓝 1) := by
have h := tendsto_measure_iUnion_atTop (μ := siteLaw p) (siteSeedInfinite_mono c)
simpa only [iUnion_siteSeedInfinite,siteExistsInfinite_one hp,Function.comp_def] using h
/-- The closed-cube vertex boundary used by the finite-scale argument. -/
def cubeBoundary (c : Vertex) (n : ℕ) : Set Vertex :=
{x | x ∈ cube c n ∧ ∃ i, x i = c i - (n : ℤ) ∨ x i = c i + (n : ℤ)}
def Within {V : Type uV} (D : Set V) (r : V → V → Prop) (x y : V) : Prop :=
x ∈ D ∧ y ∈ D ∧ r x y
theorem rtg_first_exit {V : Type uV} {r : V → V → Prop} {D : Set V} {x y : V}
(h : Relation.ReflTransGen r x y) (hx : x ∈ D) (hy : y ∉ D) :
∃ a ∈ D, ∃ b ∉ D, Relation.ReflTransGen (Within D r) x a ∧ r a b := by
have hh : ∀ {z}, Relation.ReflTransGen r x z →
(z ∈ D ∧ Relation.ReflTransGen (Within D r) x z) ∨
∃ a ∈ D, ∃ b ∉ D, Relation.ReflTransGen (Within D r) x a ∧ r a b := by
intro z hz
induction hz with
| refl => exact Or.inl ⟨hx,.refl⟩
| @tail a b _ hab ih =>
rcases ih with ⟨ha,hi⟩ | he
· by_cases hb : b ∈ D
· exact Or.inl ⟨hb,hi.tail ⟨ha,hb,hab⟩⟩
· exact Or.inr ⟨a,ha,b,hb,hi,hab⟩
· exact Or.inr he
exact (hh h).resolve_left (fun h => hy h.1)
theorem nearestNeighbor_exit_boundary {c x y : Vertex} {n : ℕ}
(hx : x ∈ cube c n) (hy : y ∉ cube c n) (hxy : NearestNeighbor x y) :
x ∈ cubeBoundary c n := by
refine ⟨hx,?_⟩
rw [mem_cube] at hx hy
push Not at hy
obtain ⟨i,hi⟩ := hy
obtain ⟨k,hk | hk⟩ := hxy
· subst y
by_cases hki : k = i
· subst k
refine ⟨i,Or.inr ?_⟩
have hxi := hx i
simp only [step,ite_true] at hi
omega
· have hxi := hx i
simp only [step,ite_eq_right hki,add_zero] at hi
omega
· subst x
by_cases hki : k = i
· subst k
refine ⟨i,Or.inl ?_⟩
have hxi := hx i
simp only [step,ite_true] at hxi ⊢
omega
· have hxi := hx i
simp only [step,ite_eq_right hki,add_zero] at hxi
omega
theorem bondOpen_neighbor {ω : BondConfig} {x y : Vertex} (h : BondOpen ω x y) :
NearestNeighbor x y := by
rcases h with ⟨i,hi,_⟩ | ⟨i,hi,_⟩
· exact ⟨i,Or.inl hi⟩
· exact ⟨i,Or.inr hi⟩
def bondSeedReaches (c : Vertex) (m n : ℕ) (T : Set Vertex) : Set BondConfig :=
{ω | ∃ x ∈ cube c m, ∃ y ∈ T,
Relation.ReflTransGen (Within (cube c n) (BondOpen ω)) x y}
def siteSeedReaches (c : Vertex) (m n : ℕ) (T : Set Vertex) : Set SiteConfig :=
{ω | ∃ x ∈ cube c m, ω x = true ∧ ∃ y ∈ T,
Relation.ReflTransGen (Within (cube c n) (SiteOpen ω)) x y}
/-- An infinite component supplies a finite path to the cube boundary;
this uses no uniqueness or unproved infinite-path theorem. -/
theorem bondSeedInfinite_subset_reachesBoundary (c : Vertex) {m n : ℕ} (hmn : m ≤ n) :
bondSeedInfinite c m ⊆ bondSeedReaches c m n (cubeBoundary c n) := by
rintro ω ⟨x,hxm,hx⟩
have hnot : ¬bondCluster ω x ⊆ cube c n := fun h => hx ((cube_finite c n).subset h)
obtain ⟨y,hy,hyn⟩ := Set.not_subset.mp hnot
obtain ⟨a,ha,b,hb,hpath,hab⟩ := rtg_first_exit hy (cube_mono c hmn hxm) hyn
exact ⟨x,hxm,a,nearestNeighbor_exit_boundary ha hb (bondOpen_neighbor hab),hpath⟩
theorem siteSeedInfinite_subset_reachesBoundary (c : Vertex) {m n : ℕ} (hmn : m ≤ n) :
siteSeedInfinite c m ⊆ siteSeedReaches c m n (cubeBoundary c n) := by
rintro ω ⟨x,hxm,hx⟩
have hnot : ¬siteCluster ω x ⊆ cube c n := fun h => hx ((cube_finite c n).subset h)
obtain ⟨y,hy,hyn⟩ := Set.not_subset.mp hnot
obtain ⟨a,ha,b,hb,hpath,hab⟩ := rtg_first_exit hy.2 (cube_mono c hmn hxm) hyn
exact ⟨x,hxm,hy.1,a,nearestNeighbor_exit_boundary ha hb hab.1,hpath⟩
end CriticalZ3
end OAI