lean/OAI/Probability/CriticalZ3/EntryLayers.lean

import OAI.Probability.CriticalZ3.LatticePaths

namespace OAI

open MeasureTheory ProbabilityTheory Classical Filter

open scoped ENNReal BigOperators Matrix

namespace CriticalZ3
open Classical

theorem step_ge (x : Vertex) (i : Fin 3) : x ≤ step x i := by
  intro j; simp only [step]; split_ifs <;> omega

theorem step_direction_injective (x : Vertex) : Function.Injective (step x) := by
  intro i j h
  by_contra hij
  have hh := congrFun h i
  simp only [step,ite_true,ite_eq_right (Ne.symm hij),add_zero] at hh
  omega

theorem step_no_reverse (x y : Vertex) (i j : Fin 3)
    (h : y = step x i) : x ≠ step y j := by
  intro hh
  have hle : y i ≤ x i := by rw [hh]; exact step_ge y j i
  have hlt : x i < y i := by simp [h,step]
  exact not_lt_of_ge hle hlt

theorem incidence_unique {e f : Bond} {x y : Vertex}
    (he : Incidence e x y) (hf : Incidence f x y) : e = f := by
  rcases he with ⟨hx,hy⟩ | ⟨hy,hx⟩ <;> rcases hf with ⟨hx',hy'⟩ | ⟨hy',hx'⟩
  · apply Prod.ext
    · exact hx.symm.trans hx'
    · apply step_direction_injective x
      simpa only [←hx,←hx'] using hy.symm.trans hy'
  · exact False.elim (step_no_reverse x y e.2 f.2 (by simpa [←hx] using hy)
      (by simpa [←hy'] using hx'))
  · exact False.elim (step_no_reverse y x e.2 f.2 (by simpa [←hy] using hx)
      (by simpa [←hx'] using hy'))
  · apply Prod.ext
    · exact hy.symm.trans hy'
    · apply step_direction_injective y
      simpa only [←hy,←hy'] using hx.symm.trans hx'

noncomputable def neighborBond (x y : Vertex) : Bond :=
  if h : NearestNeighbor x y then (LatticeGraph.neighbor_incidence h).choose else (x,0)

theorem neighborBond_incidence {x y : Vertex} (h : NearestNeighbor x y) :
    Incidence (neighborBond x y) x y := by
  simp only [neighborBond,dite_eq_left h]
  exact (LatticeGraph.neighbor_incidence h).choose_spec

theorem neighborBond_eq {e : Bond} {x y : Vertex} (he : Incidence e x y) :
    neighborBond x y = e := incidence_unique (neighborBond_incidence (incidence_neighbor he)) he

namespace Box

def Exterior (C : Box) (y : Vertex) : Prop :=
  ¬C.Contains y ∧ ∃ z, C.Contains z ∧ NearestNeighbor y z

noncomputable def entry (C : Box) (y : Vertex) : Vertex :=
  if h : C.Exterior y then h.2.choose else C.lower

theorem entry_spec {C : Box} {y : Vertex} (h : C.Exterior y) :
    C.Contains (C.entry y) ∧ NearestNeighbor y (C.entry y) := by
  simp only [entry,dite_eq_left h]
  exact h.2.choose_spec

theorem entry_eq {C : Box} {y z : Vertex} (hy : ¬C.Contains y)
    (hz : C.Contains z) (h : NearestNeighbor y z) : C.entry y = z := by
  have hey : C.Exterior y := ⟨hy,z,hz,h⟩
  exact C.exterior_neighbor_unique hy (entry_spec hey).1 hz (entry_spec hey).2 h

noncomputable def entryBit (C : Box) : (m : Model) → Vertex → m.Bit
  | .bond,y => neighborBond y (C.entry y)
  | .site,y => C.entry y

theorem exterior_expand {C : Box} {y : Vertex} (h : C.Exterior y) :
    (C.expand 1).Contains y := by
  obtain ⟨z,hz,hzy⟩ := h.2
  apply C.neighbor_in_expand hz
  obtain ⟨i,hi | hi⟩ := hzy
  · exact ⟨i,Or.inr hi⟩
  · exact ⟨i,Or.inl hi⟩

theorem entryBit_internal (m : Model) {C : Box} {y : Vertex} (h : C.Exterior y) :
    C.entryBit m y ∈ (C.expand 1).bits m := by
  have he := C.contains_expand 1 (entry_spec h).1
  cases m
  · exact LatticeGraph.incidence_internal (exterior_expand h) he
      (neighborBond_incidence (entry_spec h).2)
  · exact (mem_vertices _ _).mpr he

end Box

namespace LatticeGraph
variable (G : LatticeGraph)

def OutsideAdj (m : Model) (C : Box) (ω : m.Config) (x y : G.Node) : Prop :=
  ¬C.Contains x.1 ∧ ¬C.Contains y.1 ∧ G.Adj m ω x y

def OutsideReach (m : Model) (C : Box) (ω : m.Config) (o y : G.Node) : Prop :=
  ¬C.Contains o.1 ∧ G.Open m ω o ∧ Relation.ReflTransGen (G.OutsideAdj m C ω) o y

noncomputable def entrants (m : Model) (C : Box) (ω : m.Config) (o : G.Node) : Finset Vertex :=
  G.vertices.filter (fun y => ∃ hy : y ∈ G.vertices,
    C.Exterior y ∧ G.OutsideReach m C ω o ⟨y,hy⟩)

@[simp] theorem mem_entrants (m : Model) (C : Box) (ω : m.Config) (o y : G.Node) :
    y.1 ∈ G.entrants m C ω o ↔ C.Exterior y.1 ∧ G.OutsideReach m C ω o y := by
  simp only [entrants,Finset.mem_filter,y.2,true_and]
  exact ⟨fun ⟨_,h⟩ => h,fun h => ⟨trivial,h⟩⟩

theorem outsideReach_conn (m : Model) {C : Box} {ω : m.Config} {o y : G.Node}
    (h : G.OutsideReach m C ω o y) : G.Conn m ω o y :=
  (G.conn_iff m ω o y).mpr ⟨h.2.1,Relation.ReflTransGen.mono (fun _ _ (hh : G.OutsideAdj m C ω _ _) => hh.2.2) o y h.2.2⟩

theorem first_entry (m : Model) {C : Box} {ω : m.Config} {o z : G.Node}
    (ho : ¬C.Contains o.1) (hz : C.Contains z.1) (h : G.Conn m ω o z) :
    ∃ y w : G.Node, y.1 ∈ G.entrants m C ω o ∧ C.Contains w.1 ∧ G.Adj m ω y w := by
  have hp := ((G.conn_iff m ω o z).mp h).2
  have hop := ((G.conn_iff m ω o z).mp h).1
  have hh : ∀ {x : G.Node}, Relation.ReflTransGen (G.Adj m ω) o x →
      (¬C.Contains x.1 ∧ Relation.ReflTransGen (G.OutsideAdj m C ω) o x) ∨
      ∃ y w : G.Node, y.1 ∈ G.entrants m C ω o ∧ C.Contains w.1 ∧ G.Adj m ω y w := by
    intro x hx
    induction hx with
    | refl => exact Or.inl ⟨ho,.refl⟩
    | @tail a b _ hab ih =>
      rcases ih with ⟨ha,hi⟩ | he
      · by_cases hb : C.Contains b.1
        · exact Or.inr ⟨a,b,(G.mem_entrants m C ω o a).mpr
            ⟨⟨ha,b.1,hb,G.adj_neighbor m hab⟩,ho,hop,hi⟩,hb,hab⟩
        · exact Or.inl ⟨hb,hi.tail ⟨ha,hb,hab⟩⟩
      · exact Or.inr he
  exact (hh hp).resolve_left (fun h => h.1 hz)

theorem meets_entrants_nonempty (m : Model) {C : Box} {ω : m.Config} {o : G.Node}
    (ho : ¬C.Contains o.1) (h : G.Meets m ω o {x | C.Contains x}) :
    (G.entrants m C ω o).Nonempty := by
  obtain ⟨z,hz,hz'⟩ := h
  obtain ⟨y,w,hy,_,_⟩ := G.first_entry m ho hz hz'
  exact ⟨y.1,hy⟩

theorem entryBit_open (m : Model) {C : Box} {ω : m.Config} {y z : G.Node}
    (hy : ¬C.Contains y.1) (hz : C.Contains z.1) (h : G.Adj m ω y z) :
    ω (C.entryBit m y.1) = true := by
  have he := C.entry_eq hy hz (G.adj_neighbor m h)
  cases m
  · obtain ⟨e,_,hi,ho⟩ := h
    simpa only [Box.entryBit,he,neighborBond_eq hi] using ho
  · simpa only [Box.entryBit,he] using h.2.2

noncomputable def entryBits (m : Model) (C : Box) (ω : m.Config) (o : G.Node) : Finset m.Bit :=
  (G.entrants m C ω o).image (C.entryBit m)

def Blocked (m : Model) (C : Box) (ω : m.Config) (o : G.Node) : Prop :=
  ∀ e ∈ G.entryBits m C ω o, ω e = false

theorem entryBits_card (m : Model) (C : Box) (ω : m.Config) (o : G.Node) :
    (G.entryBits m C ω o).card ≤ (G.entrants m C ω o).card := Finset.card_image_le

theorem blocked_not_meets (m : Model) {C : Box} {ω : m.Config} {o : G.Node}
    (ho : ¬C.Contains o.1) (hb : G.Blocked m C ω o) :
    ¬G.Meets m ω o {x | C.Contains x} := by
  rintro ⟨z,hz,hp⟩
  obtain ⟨y,w,hy,hw,hyw⟩ := G.first_entry m ho hz hp
  have hyout := ((G.mem_entrants m C ω o y).mp hy).1.1
  have hopen := G.entryBit_open m hyout hw hyw
  have hclosed := hb (C.entryBit m y.1) (Finset.mem_image.mpr ⟨y.1,hy,rfl⟩)
  exact Bool.noConfusion (hopen.symm.trans hclosed)

/-- The shell blocking events are disjoint for the actual induced-outside
paths. This is the pathwise argument, not a probabilistic assumption. -/
theorem blocked_earlier_entrants (m : Model) {B : Box} {i j : ℕ} (hij : i < j)
    {ω : m.Config} {o : G.Node} (ho : ¬(B.expand j).Contains o.1)
    (hb : G.Blocked m (B.expand j) ω o) : G.entrants m (B.expand i) ω o = ∅ := by
  apply Finset.eq_empty_iff_forall_notMem.mpr
  intro y hy
  have hyG : y ∈ G.vertices := (Finset.mem_filter.mp hy).1
  obtain ⟨hey,hry⟩ := (G.mem_entrants m (B.expand i) ω o ⟨y,hyG⟩).mp hy
  have hyj : (B.expand j).Contains y := by
    have he := Box.exterior_expand hey
    rw [Box.expand_expand] at he
    exact B.expand_mono (by omega) he
  exact G.blocked_not_meets m ho hb ⟨⟨y,hyG⟩,hyj,G.outsideReach_conn m hry⟩

end LatticeGraph
end CriticalZ3

namespace CriticalZ3.LatticeGraph
open Classical
variable (G : LatticeGraph)

noncomputable def outsideBits : (m : Model) → Box → Finset m.Bit
  | .bond,C => G.edges.filter (fun e => ¬C.Contains e.1 ∧ ¬C.Contains (step e.1 e.2))
  | .site,C => G.vertices.filter (fun x => ¬C.Contains x)

theorem outsideAdj_determined (m : Model) (C : Box) (ω ω' : m.Config)
    (h : ∀ e ∈ G.outsideBits m C, ω' e = ω e) (x y : G.Node) :
    G.OutsideAdj m C ω' x y ↔ G.OutsideAdj m C ω x y := by
  have hh (ω ω' : m.Config) (h : ∀ e ∈ G.outsideBits m C, ω' e = ω e)
      (ha : G.OutsideAdj m C ω' x y) : G.OutsideAdj m C ω x y := by
    refine ⟨ha.1,ha.2.1,?_⟩
    cases m
    · obtain ⟨e,he,hi,ho⟩ := ha.2.2
      refine ⟨e,he,hi,?_⟩
      have hem : e ∈ G.outsideBits .bond C := by
        apply Finset.mem_filter.mpr
        refine ⟨he,?_⟩
        rcases hi with ⟨hx,hy⟩ | ⟨hy,hx⟩
        · exact ⟨hx ▸ ha.1,hy ▸ ha.2.1⟩
        · exact ⟨hy ▸ ha.2.1,hx ▸ ha.1⟩
      rw [←h e hem]; exact ho
    · exact ⟨ha.2.2.1,(h x.1 (Finset.mem_filter.mpr ⟨x.2,ha.1⟩)) ▸ ha.2.2.2.1,
        (h y.1 (Finset.mem_filter.mpr ⟨y.2,ha.2.1⟩)) ▸ ha.2.2.2.2⟩
  exact ⟨hh ω ω' h, hh ω' ω (fun e he => (h e he).symm)⟩

theorem outsideReach_determined (m : Model) (C : Box) (ω ω' : m.Config)
    (h : ∀ e ∈ G.outsideBits m C, ω' e = ω e) (o y : G.Node) :
    G.OutsideReach m C ω' o y ↔ G.OutsideReach m C ω o y := by
  by_cases ho : C.Contains o.1
  · simp only [OutsideReach,ho,not_true_eq_false,false_and]
  have hr : G.OutsideAdj m C ω' = G.OutsideAdj m C ω := by
    funext x y; exact propext (G.outsideAdj_determined m C ω ω' h x y)
  have hop : G.Open m ω' o ↔ G.Open m ω o := by
    cases m
    · rfl
    · change (ω' o.1 = true) ↔ (ω o.1 = true)
      rw [h o.1 (Finset.mem_filter.mpr ⟨o.2,ho⟩)]
  simp only [OutsideReach,hr,hop]

theorem entrants_determined (m : Model) (C : Box) (o : G.Node) :
    ProductCylinder.DeterminedBy (G.outsideBits m C) (fun ω => G.entrants m C ω o) := by
  intro ω ω' h
  ext y
  simp only [entrants,Finset.mem_filter,G.outsideReach_determined m C ω ω' h]

theorem entryBits_determined (m : Model) (C : Box) (o : G.Node) :
    ProductCylinder.DeterminedBy (G.outsideBits m C) (fun ω => G.entryBits m C ω o) := by
  intro ω ω' h
  simp only [entryBits,G.entrants_determined m C o ω ω' h]

theorem outsideBits_disjoint_inside (m : Model) (C : Box) :
    Disjoint (G.outsideBits m C) (C.bits m) := by
  rw [Finset.disjoint_left]
  intro e he he'
  cases m
  · exact (Finset.mem_filter.mp he).2.1 ((Box.mem_bonds C e).mp he').1
  · exact (Finset.mem_filter.mp he).2 ((Box.mem_vertices C e).mp he')

theorem entryBit_not_outside (m : Model) {C : Box} {y : Vertex} (hy : C.Exterior y) :
    C.entryBit m y ∉ G.outsideBits m C := by
  intro he
  have hentry := (Box.entry_spec hy).1
  cases m
  · have hi := neighborBond_incidence (Box.entry_spec hy).2
    obtain ⟨_,hout,hout'⟩ := Finset.mem_filter.mp he
    rcases hi with ⟨_,hz⟩ | ⟨hz,_⟩
    · exact hout' (hz ▸ hentry)
    · exact hout (hz ▸ hentry)
  · exact (Finset.mem_filter.mp he).2 hentry

theorem entryBits_disjoint_outside (m : Model) (C : Box) (ω : m.Config) (o : G.Node) :
    Disjoint (G.entryBits m C ω o) (G.outsideBits m C) := by
  rw [Finset.disjoint_left]
  intro e he he'
  obtain ⟨y,hy,rfl⟩ := Finset.mem_image.mp he
  have hyG : y ∈ G.vertices := (Finset.mem_filter.mp hy).1
  exact G.entryBit_not_outside m ((G.mem_entrants m C ω o ⟨y,hyG⟩).mp hy).1 he'

end CriticalZ3.LatticeGraph

end OAI