lean/OAI/Probability/CriticalPercolation/Clusters/ClusterObject.lean

import Mathlib
import OAI.Probability.CriticalPercolation.GraphGeometry.VertexBall
import OAI.Probability.CriticalPercolation.ProductMeasure.Distribution

namespace OAI

section
section
open Set MeasureTheory ProbabilityTheory
open Set
open scoped BigOperators

namespace CriticalPercolation.BondGraph
open ClusterDeletion FiniteProduct
open scoped Classical

variable {V E : Type*} (G : BondGraph V E)

abbrev ClusterObject (V E : Type*) := Set V × Set E

def clusterObject (ω : Set E) (S : Set V) : ClusterObject V E :=
  (roots (G.openGraph ω) S, ω ∩ G.incidentEdges (roots (G.openGraph ω) S))

def eraseVertices (ω : Set E) (U : Set V) : Set E := ω \ G.incidentEdges U

lemma incidentEdges_mono {S T : Set V} (h : S ⊆ T) : G.incidentEdges S ⊆ G.incidentEdges T := by
  rintro e ⟨v, hv, he⟩
  exact ⟨v, h hv, he⟩

lemma clusterObject_mono {ω ω' : Set E} (h : ω ⊆ ω') (S : Set V) :
    G.clusterObject ω S ≤ G.clusterObject ω' S := by
  have hr := roots_mono (SimpleGraph.fromEdgeSet_mono (Set.image_mono (f := G.ends) h)) S
  exact ⟨hr, fun _ he => ⟨h he.1, G.incidentEdges_mono hr he.2⟩⟩

lemma eraseVertices_mono {ω ω' : Set E} (h : ω ⊆ ω') (U : Set V) :
    G.eraseVertices ω U ⊆ G.eraseVertices ω' U :=
  fun _ he => ⟨h he.1, he.2⟩

lemma eraseVertices_antitone {U U' : Set V} (h : U ⊆ U') (ω : Set E) :
    G.eraseVertices ω U' ⊆ G.eraseVertices ω U :=
  fun _ he => ⟨he.1, fun hh => he.2 (G.incidentEdges_mono h hh)⟩

lemma openGraph_eraseVertices (ω : Set E) (U : Set V) :
    G.openGraph (G.eraseVertices ω U) = delete (G.openGraph ω) U := by
  ext v w
  simp only [openGraph, SimpleGraph.fromEdgeSet_adj, Set.mem_image,
    eraseVertices, Set.mem_sdiff, delete]
  constructor
  · rintro ⟨⟨e, ⟨he, hU⟩, heq⟩, hne⟩
    refine ⟨⟨⟨e, he, heq⟩, hne⟩, ?_, ?_⟩
    · intro hv
      exact hU ⟨v, hv, by simp [heq]⟩
    · intro hw
      exact hU ⟨w, hw, by simp [heq]⟩
  · rintro ⟨⟨⟨e, he, heq⟩, hne⟩, hv, hw⟩
    refine ⟨⟨e, ⟨he, ?_⟩, heq⟩, hne⟩
    rintro ⟨t, ht, hte⟩
    rw [heq] at hte
    rcases (by simpa using hte : t = v ∨ t = w) with rfl | rfl
    · exact hv ht
    · exact hw ht

lemma eraseVertices_dependsOn (U : Set V) :
    DependsOn (fun ω : Set E => G.eraseVertices ω U) (G.incidentEdges U)ᶜ := by
  intro ω ω' hω
  ext e
  change (ω e ∧ e ∉ G.incidentEdges U) ↔ (ω' e ∧ e ∉ G.incidentEdges U)
  by_cases he : e ∈ G.incidentEdges U
  · simp [he]
  · rw [(hω e he).to_iff]

lemma clusterObject_eq_of_incident {S : Set V} {C : ClusterObject V E} {ω ω' : Set E}
    (hC : G.clusterObject ω S = C)
    (hω : ∀ e ∈ G.incidentEdges C.1, e ∈ ω ↔ e ∈ ω') :
    G.clusterObject ω' S = C := by
  have hr : roots (G.openGraph ω) S = C.1 := congrArg Prod.fst hC
  have hr' := G.roots_eq_of_incident hr hω
  apply Prod.ext hr'
  change ω' ∩ G.incidentEdges (roots (G.openGraph ω') S) = C.2
  have he : ω ∩ G.incidentEdges (roots (G.openGraph ω) S) = C.2 := congrArg Prod.snd hC
  rw [hr] at he
  rw [hr', ← he]
  ext e
  constructor
  · intro hh
    exact ⟨(hω e hh.2).mpr hh.1, hh.2⟩
  · intro hh
    exact ⟨(hω e hh.2).mp hh.1, hh.2⟩

lemma dependsOn_exact_clusterObject (S : Set V) (C : ClusterObject V E) :
    DependsOn (fun ω : Set E => G.clusterObject ω S = C) (G.incidentEdges C.1) := by
  intro ω ω' hω
  apply propext
  constructor
  · exact fun h => G.clusterObject_eq_of_incident h (fun e he => (hω e he).to_iff)
  · exact fun h => G.clusterObject_eq_of_incident h (fun e he => (hω e he).symm.to_iff)

lemma roots_disjoint_symm (ω : Set E) (A B : Set V) :
    Disjoint (roots (G.openGraph ω) A) B ↔ Disjoint (roots (G.openGraph ω) B) A := by
  simp only [Set.disjoint_left]
  constructor
  · rintro h a ⟨b, hb, hba⟩ ha
    exact h ⟨a, ha, hba.symm⟩ hb
  · rintro h b ⟨a, ha, hab⟩ hb
    exact h ⟨b, hb, hab.symm⟩ ha

lemma roots_disjoint_roots (ω : Set E) {A B : Set V}
    (h : Disjoint (roots (G.openGraph ω) A) B) :
    Disjoint (roots (G.openGraph ω) A) (roots (G.openGraph ω) B) := by
  rw [Set.disjoint_left] at h ⊢
  rintro v ⟨a, ha, hav⟩ ⟨b, hb, hbv⟩
  exact h ⟨a, ha, hav.trans hbv.symm⟩ hb

lemma roots_erase_roots (ω : Set E) {A B : Set V}
    (h : Disjoint (roots (G.openGraph ω) A) B) :
    roots (G.openGraph (G.eraseVertices ω (roots (G.openGraph ω) A))) B =
      roots (G.openGraph ω) B := by
  rw [G.openGraph_eraseVertices]
  ext v
  constructor
  · exact fun hv => roots_mono (delete_le _ _) _ hv
  · rintro ⟨b, hb, hbv⟩
    refine ⟨b, hb, ?_⟩
    change v ∈ component (delete (G.openGraph ω) (roots (G.openGraph ω) A)) b
    rw [delete_roots_component _ _ _ (fun hh => Set.disjoint_left.mp h hh hb)]
    exact hbv

lemma openBond_roots {ω : Set E} {S : Set V} {e : E} (he : e ∈ ω)
    {v w : V} (hv : v ∈ G.ends e) (hw : w ∈ G.ends e)
    (hr : v ∈ roots (G.openGraph ω) S) : w ∈ roots (G.openGraph ω) S := by
  by_cases hvw : v = w
  · simpa [← hvw] using hr
  · have heq : G.ends e = s(v,w) := Sym2.eq_of_ne_mem hvw hv hw (by simp) (by simp)
    exact roots_closed hr ((SimpleGraph.fromEdgeSet_adj _).mpr
      ⟨⟨e, he, heq⟩, hvw⟩)

lemma clusterObject_erase_other (ω : Set E) {A B : Set V}
    (h : Disjoint (G.clusterObject ω A).1 B) :
    G.clusterObject (G.eraseVertices ω (G.clusterObject ω A).1) B = G.clusterObject ω B := by
  have hr := G.roots_erase_roots ω h
  apply Prod.ext hr
  change G.eraseVertices ω (roots (G.openGraph ω) A) ∩
    G.incidentEdges (roots (G.openGraph (G.eraseVertices ω (roots (G.openGraph ω) A))) B) =
    ω ∩ G.incidentEdges (roots (G.openGraph ω) B)
  rw [hr]
  ext e
  constructor
  · exact fun hh => ⟨hh.1.1, hh.2⟩
  · rintro ⟨he, hi⟩
    refine ⟨⟨he, ?_⟩, hi⟩
    rintro ⟨a, ha, hae⟩
    obtain ⟨b, hb, hbe⟩ := hi
    exact Set.disjoint_left.mp (G.roots_disjoint_roots ω h) ha
      (G.openBond_roots he hbe hae hb)

lemma clusterObject_exposure [Fintype V] [Fintype E]
    (w : E → Prop → ℝ) (hw : ∀ e, ∑ b, w e b = 1)
    (S : Set V) (F : ClusterObject V E → Set E → ℝ) :
    expect w (fun ω => F (G.clusterObject ω S)
      (G.eraseVertices ω (G.clusterObject ω S).1)) =
    expect w (fun ω => expect w (fun ω' => F (G.clusterObject ω S)
      (G.eraseVertices ω' (G.clusterObject ω S).1))) := by
  classical
  exact expect_exposure w hw (fun ω => G.clusterObject ω S)
    (fun C => G.incidentEdges C.1) (G.dependsOn_exact_clusterObject S)
    (fun C ω => F C (G.eraseVertices ω C.1))
    (fun C _ _ hω => congrArg (F C) (G.eraseVertices_dependsOn C.1 hω))

lemma clusterObject_avoidance_exposure [Fintype V] [Fintype E]
    (w : E → Prop → ℝ) (hw : ∀ e, ∑ b, w e b = 1)
    (A B : Set V) (F : ClusterObject V E → ClusterObject V E → ℝ) :
    expect w (fun ω => if Disjoint (G.clusterObject ω A).1 B then
      F (G.clusterObject ω A) (G.clusterObject ω B) else 0) =
    expect w (fun ω => if Disjoint (G.clusterObject ω A).1 B then
      expect w (fun ω' => F (G.clusterObject ω A)
        (G.clusterObject (G.eraseVertices ω' (G.clusterObject ω A).1) B)) else 0) := by
  classical
  have he := G.clusterObject_exposure w hw A
    (fun C ω => if Disjoint C.1 B then F C (G.clusterObject ω B) else 0)
  have hl : (fun ω : E → Prop => if Disjoint (G.clusterObject ω A).1 B then
      F (G.clusterObject ω A)
        (G.clusterObject (G.eraseVertices ω (G.clusterObject ω A).1) B) else 0) =
      (fun ω => if Disjoint (G.clusterObject ω A).1 B then
        F (G.clusterObject ω A) (G.clusterObject ω B) else 0) := by
    funext ω
    split_ifs with h
    · rw [G.clusterObject_erase_other ω h]
    · rfl
  rw [hl] at he
  refine he.trans ?_
  congr 1
  funext ω
  split_ifs <;> simp [expect_zero]

end CriticalPercolation.BondGraph

end
end

end OAI