| import Mathlib |
| import OAI.Probability.CriticalPercolation.Model |
| import OAI.Probability.CriticalPercolation.GraphGeometry.FiniteInduced |
| import OAI.Probability.CriticalPercolation.Exploration.BallIncidence |
| import OAI.Probability.CriticalPercolation.Exploration.LayerExposure |
| import OAI.Probability.CriticalPercolation.Gluing.StripMoves |
| import OAI.Probability.CriticalPercolation.Criticality.BlockLocalization |
| import OAI.Probability.CriticalPercolation.Modular.ModularClusterMass |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| open Set MeasureTheory ProbabilityTheory |
| open scoped Classical ENNReal BigOperators |
|
|
| namespace CriticalPercolation.BondGraph |
| variable {V E : Type*} (G : BondGraph V E) |
|
|
| def layerComponent (D H : Set V) (ω : Set E) (x : V) : Set V := |
| G.cluster ((ω∩G.inducedEdges D)∩G.inducedEdges Hᶜ) x |
|
|
| def openLayerExits (D H : Set V) (ω : Set E) (x : V) : Set E := |
| G.freshClusterBoundary (G.inducedEdges Hᶜ) x (ω∩G.inducedEdges D)∩(ω∩G.inducedEdges D) |
|
|
| lemma openLayerExit_endpoints {D H : Set V} {ω : Set E} {x : V} (hx : x∉H) |
| {e : E} (he : e∈G.openLayerExits D H ω x) : |
| ∃ u v, G.ends e=s(u,v) ∧ u∈H ∧ v∉H ∧ v∈G.layerComponent D H ω x ∧ e∈ω ∧ |
| e∈G.inducedEdges D := by |
| obtain ⟨⟨⟨u,v,heuv,hu,hv⟩,heH⟩,heω,heD⟩ := he |
| have hvH := G.cluster_induced_subset (ω∩G.inducedEdges D) Hᶜ hx hv |
| refine ⟨u,v,heuv,?_,hvH,hv,heω,heD⟩ |
| by_contra huH |
| apply heH |
| intro z hz |
| rw [heuv] at hz |
| rcases Sym2.mem_iff.mp hz with rfl|rfl |
| · exact huH |
| · exact hvH |
|
|
| lemma openLayerExit_child {D H : Set V} (hHD : H⊆D) {o x : V} {ω : Set E} |
| (hx : x∈G.entrySeeds D o ω) (hxH : x∉H) {e : E} |
| (he : e∈G.openLayerExits D H ω x) : |
| e∈G.incidentEdges (G.entrySeeds H o ω) := by |
| obtain ⟨u,v,heuv,huH,hvH,hv,heω,heD⟩ := G.openLayerExit_endpoints hxH he |
| have hprevious : x∈G.cluster (ω∩(G.inducedEdges H)ᶜ) o := by |
| apply G.cluster_mono _ o hx.1 |
| intro f hf |
| exact ⟨hf.1,fun hh => hf.2 (G.inducedEdges_monotone hHD hh)⟩ |
| have hmiddle : v∈G.cluster (ω∩(G.inducedEdges H)ᶜ) x := by |
| apply G.cluster_mono _ x hv |
| intro f hf |
| refine ⟨hf.1.1,?_⟩ |
| intro hh |
| obtain ⟨a,b,hab⟩ : ∃ a b, G.ends f=s(a,b) := Sym2.exists.mp ⟨G.ends f,rfl⟩ |
| have ha : a∈G.ends f := by rw [hab]; simp |
| exact hf.2 a ha (hh a ha) |
| have hneq : v≠u := by intro hh; subst v; exact hvH huH |
| have hedge : (G.openGraph (ω∩(G.inducedEdges H)ᶜ)).Adj v u := by |
| apply (SimpleGraph.fromEdgeSet_adj _).mpr |
| refine ⟨⟨e,⟨heω,?_⟩,?_⟩,hneq⟩ |
| · intro hh |
| exact hvH (hh v (by rw [heuv]; simp)) |
| · rw [heuv,Sym2.eq_swap] |
| exact ⟨u,⟨hprevious.trans (hmiddle.trans hedge.reachable),huH⟩,by rw [heuv]; simp⟩ |
|
|
| lemma openLayerExit_common_component {D H : Set V} {ω : Set E} {x y : V} |
| (hx : x∉H) (hy : y∉H) {e : E} |
| (hex : e∈G.openLayerExits D H ω x) (hey : e∈G.openLayerExits D H ω y) : |
| y∈G.layerComponent D H ω x := by |
| obtain ⟨u,v,heuv,huH,hvH,hv,_,_⟩ := G.openLayerExit_endpoints hx hex |
| obtain ⟨a,b,heab,haH,hbH,hb,_,_⟩ := G.openLayerExit_endpoints hy hey |
| have hevb : v=b := by |
| have heq : s(u,v)=s(a,b) := heuv.symm.trans heab |
| rcases Sym2.eq_iff.mp heq with hh|hh |
| · exact hh.2 |
| · exact False.elim (hvH (hh.2 ▸ haH)) |
| subst b |
| exact hv.trans hb.symm |
|
|
| lemma comparable_parents_card_le (hc : G.fullGraph.Connected) (hl : G.LocallyFinite) |
| (o x : V) (C : Set V) (A : Finset V) (hAC : (A : Set V)⊆C) |
| (a T : ℝ) (ha : 0<a) (hT : 0<T) |
| (hband : ∀ y∈A, a*T≤G.modularRatio y o) |
| (hx : G.modularRatio x o≤T) (M K : ℕ) (hMK : (M:ℝ)≤a*K) |
| (hm : G.modularMass x C≤M) : A.card≤K := by |
| have hlow := G.finset_weight_lower o C A hAC (ENNReal.ofReal (a*T)) |
| (fun y hy => ENNReal.ofReal_le_ofReal (hband y hy)) |
| have hmass : G.modularMass o C≤ENNReal.ofReal T*M := by |
| rw [G.modularMass_change_base hc hl o x C] |
| exact mul_le_mul' (ENNReal.ofReal_le_ofReal hx) hm |
| have hh := hlow.trans hmass |
| have hh' : a*T*(A.card:ℝ)≤T*M := by |
| rw [←ENNReal.ofReal_natCast,←ENNReal.ofReal_mul (mul_pos ha hT).le, |
| ←ENNReal.ofReal_natCast,←ENNReal.ofReal_mul hT.le] at hh |
| exact (ENNReal.ofReal_le_ofReal_iff (by positivity : (0:ℝ)≤T*M)).mp hh |
| apply Nat.cast_le.mp (show (A.card:ℝ)≤K from ?_) |
| have hc' : a*(A.card:ℝ)≤M := (mul_le_mul_iff_right₀ hT).mp (by |
| calc |
| T*(a*(A.card:ℝ))=a*T*(A.card:ℝ) := by ring |
| _ ≤ T*M := hh') |
| exact (mul_le_mul_iff_right₀ ha).mp (hc'.trans hMK) |
|
|
| lemma finite_relation_count {α β : Type*} (A : Finset α) (B : Finset β) |
| (r : α → β → Prop) (N K : ℕ) |
| (hN : ∀ x∈A, N≤(B.filter (r x)).card) |
| (hK : ∀ y∈B, (A.filter (fun x => r x y)).card≤K) : |
| N*A.card≤K*B.card := by |
| calc |
| N*A.card = ∑ _x∈A, N := by simp [Nat.mul_comm] |
| _ ≤ ∑ x∈A, (B.filter (r x)).card := Finset.sum_le_sum hN |
| _ = ∑ y∈B, (A.filter (fun x => r x y)).card := by |
| simp only [Finset.card_eq_sum_ones,Finset.sum_filter] |
| exact Finset.sum_comm |
| _ ≤ ∑ _y∈B, K := Finset.sum_le_sum hK |
| _ = K*B.card := by simp [Nat.mul_comm] |
|
|
| lemma layer_exit_fiber_card (hc : G.fullGraph.Connected) (hl : G.LocallyFinite) |
| (D H : Set V) (ω : Set E) (o : V) (A : Finset V) |
| (a T : ℝ) (ha : 0<a) (hT : 0<T) (M N K : ℕ) (hMK : (M:ℝ)≤a*K) |
| (hA : ∀ x∈A, x∉H ∧ a*T≤G.modularRatio x o ∧ G.modularRatio x o≤T ∧ |
| ω∈G.boundedDomainFreshExitEvent D Hᶜ x N M) (e : E) : |
| (A.filter (fun x => e∈G.openLayerExits D H ω x)).card≤K := by |
| let F := A.filter (fun x => e∈G.openLayerExits D H ω x) |
| by_cases hF : F.Nonempty |
| · obtain ⟨x,hx⟩ := hF |
| have hxA := (Finset.mem_filter.mp hx).1 |
| apply G.comparable_parents_card_le hc hl o x (G.layerComponent D H ω x) F _ |
| a T ha hT _ (hA x hxA).2.2.1 M K hMK (hA x hxA).2.2.2.2 |
| · intro y hy |
| exact G.openLayerExit_common_component (hA x hxA).1 |
| (hA y (Finset.mem_filter.mp hy).1).1 (Finset.mem_filter.mp hx).2 (Finset.mem_filter.mp hy).2 |
| · intro y hy |
| exact (hA y (Finset.mem_filter.mp hy).1).2.1 |
| · have he : F=∅ := Finset.not_nonempty_iff_eq_empty.mp hF |
| change F.card≤K |
| rw [he,Finset.card_empty] |
| exact Nat.zero_le K |
|
|
| lemma layer_seed_counting (hc : G.fullGraph.Connected) (hl : G.LocallyFinite) |
| (D H : Set V) (hHD : H⊆D) (ω : Set E) (o : V) (A : Finset V) |
| (a T : ℝ) (ha : 0<a) (hT : 0<T) (M N K d : ℕ) (hMK : (M:ℝ)≤a*K) |
| (hd : ∀ v, (G.incidentEdges {v}).ncard≤d) |
| (hfinite : (G.entrySeeds H o ω).Finite) |
| (hA : ∀ x∈A, x∈G.entrySeeds D o ω ∧ x∉H ∧ a*T≤G.modularRatio x o ∧ |
| G.modularRatio x o≤T ∧ ω∈G.boundedDomainFreshExitEvent D Hᶜ x N M) : |
| N*A.card≤K*d*(G.entrySeeds H o ω).ncard := by |
| let F := (G.finite_incident hl hfinite).toFinset |
| have hN : ∀ x∈A, N≤(F.filter (fun e => e∈G.openLayerExits D H ω x)).card := by |
| intro x hx |
| obtain ⟨B,hB,hBx⟩ := (hA x hx).2.2.2.2.1 |
| apply hB.trans (Finset.card_le_card _) |
| intro e he |
| apply Finset.mem_filter.mpr |
| have hh : e∈G.openLayerExits D H ω x := hBx he |
| exact ⟨(G.finite_incident hl hfinite).mem_toFinset.mpr |
| (G.openLayerExit_child hHD (hA x hx).1 (hA x hx).2.1 hh),hh⟩ |
| have hK : ∀ e∈F, (A.filter (fun x => e∈G.openLayerExits D H ω x)).card≤K := |
| fun e _ => G.layer_exit_fiber_card hc hl D H ω o A a T ha hT M N K hMK |
| (fun x hx => (hA x hx).2) e |
| have hcount := finite_relation_count A F (fun x e => e∈G.openLayerExits D H ω x) N K hN hK |
| have hF : F.card≤(G.entrySeeds H o ω).ncard*d := by |
| rw [←Set.ncard_eq_toFinset_card _ (G.finite_incident hl hfinite)] |
| exact G.incident_ncard_le _ hfinite d (fun v _ => hd v) |
| calc |
| N*A.card ≤ K*F.card := hcount |
| _ ≤ K*((G.entrySeeds H o ω).ncard*d) := Nat.mul_le_mul_left K hF |
| _ = K*d*(G.entrySeeds H o ω).ncard := by ring |
|
|
| end CriticalPercolation.BondGraph |
| end |
| end |
|
|
| end OAI |
|
|
