| import Mathlib |
| import OAI.Probability.CriticalPercolation.Criticality.Weight |
| import OAI.Probability.CriticalPercolation.GraphGeometry.Link2 |
|
|
| namespace OAI |
|
|
| section |
| section CurrentModule2 |
| noncomputable section |
| open Set |
| open scoped Classical BigOperators |
|
|
| namespace CriticalPercolation.Sharpness |
| open FiniteProduct ClusterDeletion |
|
|
| lemma expect_exposure_finiteRange {I A B : Type*} [Fintype I] [Fintype A] |
| (w : I → A → ℝ) (hw : ∀ e, ∑ a, w e a = 1) |
| (r : (I → A) → B) (D : B → Set I) |
| (hr : ∀ b, DependsOn (fun ω => r ω = b) (D b)) |
| (f : B → (I → A) → ℝ) (hf : ∀ b, DependsOn (f b) (D b)ᶜ) : |
| expect w (fun ω => f (r ω) ω) = |
| expect w (fun ω => expect w (f (r ω))) := by |
| let : Fintype (Set.range r) := (Set.finite_range r).fintype |
| let r' : (I → A) → Set.range r := fun ω => ⟨r ω,ω,rfl⟩ |
| exact expect_exposure w hw r' (fun b => D b.val) |
| (fun b ω ω' hω => by |
| apply propext |
| simpa only [r',Subtype.ext_iff] using (hr b.val hω).to_iff) |
| (fun b => f b.val) (fun b => hf b.val) |
|
|
| variable {V E : Type*} [Fintype E] (G : BondGraph V E) |
|
|
| lemma spatialMarkov (w : E → Prop → ℝ) (hw : ∀ e, ∑ b, w e b = 1) |
| (T : Set V) (F : Set V → SimpleGraph V → ℝ) : |
| expect w (fun ω => F (roots (G.openGraph ω) T) |
| (delete (G.openGraph ω) (roots (G.openGraph ω) T))) = |
| expect w (fun ω => expect w (fun ω' => F (roots (G.openGraph ω) T) |
| (delete (G.openGraph ω') (roots (G.openGraph ω) T)))) := by |
| refine expect_exposure_finiteRange w hw |
| (fun ω => roots (G.openGraph ω) T) G.incidentEdges |
| (G.dependsOn_exact_roots T) |
| (fun R ω => F R (delete (G.openGraph ω) R)) ?_ |
| intro R ω ω' hω |
| exact congrArg (F R) (G.delete_openGraph_dependsOn R hω) |
|
|
| def boundaryCount (o : V) (R : Set V) (H : SimpleGraph V) : ℝ := |
| ∑ e, if boundaryReach G R H o e then 1 else 0 |
|
|
| def boundaryFlux (p : ℝ) (o : V) (R : Set V) : ℝ := |
| p * expect (fun _ : E => weight p) |
| (fun ω => boundaryCount G o R (delete (G.openGraph ω) R)) |
|
|
| omit [Fintype E] in |
| lemma closedPivot_reachesTarget (o : V) (T : Set V) (ω : Set E) (e : E) : |
| closedPivot (reachesTarget G o T) e ω ↔ |
| o ∉ roots (G.openGraph ω) T ∧ |
| boundaryReach G (roots (G.openGraph ω) T) |
| (delete (G.openGraph ω) (roots (G.openGraph ω) T)) o e := by |
| constructor |
| · rintro ⟨_,ho,he⟩ |
| exact ⟨ho,(target_creating_iff G o T ω e ho).mp he⟩ |
| · rintro ⟨ho,he⟩ |
| exact ⟨boundaryReach_closed G o T ω e he,ho, |
| (target_creating_iff G o T ω e ho).mpr he⟩ |
|
|
| lemma sum_closedPivot_eq (p : ℝ) (o : V) (T : Set V) : |
| ∑ e, probability p (closedPivot (reachesTarget G o T) e) = |
| expect (fun _ : E => weight p) (fun ω => |
| if o ∉ roots (G.openGraph ω) T then |
| expect (fun _ : E => weight p) (fun ω' => boundaryCount G o |
| (roots (G.openGraph ω) T) |
| (delete (G.openGraph ω') (roots (G.openGraph ω) T))) else 0) := by |
| have hs := spatialMarkov G (fun _ : E => weight p) (fun _ => weight_sum p) |
| T (fun R H => if o ∉ R then boundaryCount G o R H else 0) |
| unfold probability |
| rw [← expect_sum] |
| calc |
| _ = expect (fun _ : E => weight p) (fun ω => |
| if o ∉ roots (G.openGraph ω) T then |
| boundaryCount G o (roots (G.openGraph ω) T) |
| (delete (G.openGraph ω) (roots (G.openGraph ω) T)) else 0) := by |
| congr 1 |
| funext ω |
| have he (e : E) : closedPivot (reachesTarget G o T) e ω ↔ |
| o ∉ roots (G.openGraph ω) T ∧ boundaryReach G (roots (G.openGraph ω) T) |
| (delete (G.openGraph ω) (roots (G.openGraph ω) T)) o e := |
| closedPivot_reachesTarget G o T ω e |
| simp only [he] |
| by_cases ho : o ∈ roots (G.openGraph ω) T |
| · simp [ho] |
| · simp [ho,boundaryCount] |
| _ = _ := by |
| rw [hs] |
| congr 1 |
| funext ω |
| split_ifs <;> simp only [expect_zero] |
|
|
| lemma exposedFlux_identity (p : ℝ) (o : V) (T : Set V) : |
| p * (∑ e, probability p (closedPivot (reachesTarget G o T) e)) = |
| expect (fun _ : E => weight p) (fun ω => |
| if o ∉ roots (G.openGraph ω) T then |
| boundaryFlux G p o (roots (G.openGraph ω) T) else 0) := by |
| rw [sum_closedPivot_eq, ← expect_const_mul] |
| congr 1 |
| funext ω |
| split_ifs <;> simp only [boundaryFlux,mul_zero] |
|
|
| theorem derivative_identity {p : ℝ} (hp : p ∈ Ioo 0 1) (o : V) (T : Set V) : |
| p * (1-p) * deriv (fun q => probability q (reachesTarget G o T)) p = |
| expect (fun _ : E => weight p) (fun ω => |
| if o ∉ roots (G.openGraph ω) T then |
| boundaryFlux G p o (roots (G.openGraph ω) T) else 0) := by |
| have hd := hasDerivAt_probability_closedPivot hp (reachesTarget G o T) |
| (fun _ _ h => reachesTarget_mono G o T h) |
| rw [hd.deriv, ← exposedFlux_identity] |
| field_simp [(sub_pos.mpr hp.2).ne'] |
|
|
| theorem differential_inequality {p a : ℝ} (hp : p ∈ Ioo 0 1) (o : V) (T : Set V) |
| (hflux : ∀ R : Set V, T ⊆ R → o ∉ R → a ≤ boundaryFlux G p o R) : |
| a * (1-probability p (reachesTarget G o T)) ≤ |
| p * (1-p) * deriv (fun q => probability q (reachesTarget G o T)) p := by |
| rw [derivative_identity G hp o T] |
| have hcomp : expect (fun _ : E => weight p) |
| (fun ω => if o ∉ roots (G.openGraph ω) T then (1:ℝ) else 0) = |
| 1-probability p (reachesTarget G o T) := by |
| calc |
| _ = expect (fun _ : E => weight p) (fun ω => |
| 1-(if reachesTarget G o T ω then (1:ℝ) else 0)) := by |
| congr 1 |
| funext ω |
| unfold reachesTarget |
| by_cases ho : o ∈ roots (G.openGraph ω) T <;> simp [ho] |
| _ = _ := by |
| rw [expect_sub,expect_const _ (fun _ => weight_sum p)] |
| rfl |
| rw [← hcomp, ← expect_const_mul] |
| apply expect_mono (fun _ b => weight_nonneg ⟨hp.1.le,hp.2.le⟩ b) |
| intro ω |
| by_cases ho : o ∈ roots (G.openGraph ω) T |
| · simp [ho] |
| · simp only [ho,not_false_eq_true,ite_true,mul_one] |
| exact hflux (roots (G.openGraph ω) T) (roots_self _ _) ho |
|
|
| end CriticalPercolation.Sharpness |
| end |
| end CurrentModule2 |
|
|
| end |
|
|
| end OAI |
|
|
