import OAI.Probability.CriticalZ3.ExplorationProbability

namespace OAI

open _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical Filter Topology Function

open scoped ENNReal BigOperators Matrix

namespace CriticalZ3
open _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical InfiniteConditioning
namespace LatticeGraph

theorem Subgraph.containsBox {G H : LatticeGraph} (h : G.Subgraph H) {B : Box}
    (hB : G.ContainsBox B) : H.ContainsBox B :=
  ⟨hB.1.trans h.1,hB.2.trans h.2⟩

theorem seedReaches_witness (G : LatticeGraph) (m : Model) {c : Vertex} {a b : ℕ}
    (hab : a ≤ b) (hB : G.ContainsBox (Box.cube c b)) {T : Set Vertex} {ω : m.Config}
    (hE : ω ∈ m.SeedReaches c a b T) :
    ∃ x y : G.Node, x.1 ∈ cube c a ∧ y.1 ∈ T ∧ G.Conn m ω x y := by
  obtain ⟨x,hxa,hxo,y,hy,hpath⟩ := hE
  have hxb := cube_mono c hab hxa
  have hyb : y ∈ cube c b := by
    induction hpath with
    | refl => exact hxb
    | tail _ hab _ => exact hab.2.1
  let x' : G.Node := ⟨x,G.containsBox_node hB (Box.contains_cube_iff.mpr hxb)⟩
  let y' : G.Node := ⟨y,G.containsBox_node hB (Box.contains_cube_iff.mpr hyb)⟩
  refine ⟨x',y',hxa,hy,(G.conn_iff m ω x' y').mpr ⟨?_,?_⟩⟩
  · cases m <;> exact hxo
  · apply G.lift_path (r := Within (cube c b) (m.BasicAdj ω)) ?_ ?_ hpath
    · intro x y h
      exact G.containsBox_node hB (Box.contains_cube_iff.mpr h.2.1)
    · intro x y h
      exact G.basicAdj_lift m hB (Box.contains_cube_iff.mpr h.1)
        (Box.contains_cube_iff.mpr h.2.1) h.2.2
end LatticeGraph

namespace Coarse

def facingFace (d : Direction) : FaceIndex :=
  (if d = 0 ∨ d = 2 then 1 else 0,fun _ => decide (d = 0 ∨ d = 3))

theorem facing_neighbor (r : ℕ) (d : Direction) {y : Vertex}
    (hy : y ∈ QuarterFace (center r (outward d)) (10*r) (facingFace d)) :
    ∃ z : Vertex, (Q r 0).Contains z ∧ NearestNeighbor z y := by
  have hQ := (quarterFace_subset_boundary _ _ _ hy).1
  rw [mem_cube] at hQ
  have h0 := hQ 0
  have h1 := hQ 1
  have h2 := hQ 2
  have hface := hy.1
  have hr : (0:ℤ) ≤ r := Int.natCast_nonneg _
  fin_cases d <;>
    simp [facingFace,center,outward,PlanarBoundary.outward] at hface h0 h1 h2
  · refine ⟨step y 1,?_,1,Or.inr rfl⟩
    intro i
    fin_cases i <;> simp [Q,Box.cube,center,step] <;> omega
  · let z := Function.update y 0 (y 0-1)
    refine ⟨z,?_,0,Or.inl ?_⟩
    · intro i
      fin_cases i <;> simp [Q,Box.cube,center,z] <;> omega
    · ext i
      by_cases hi : i = 0
      · subst i; simp [z,step]
      · simp [z,step,hi,Ne.symm hi]
  · let z := Function.update y 1 (y 1-1)
    refine ⟨z,?_,1,Or.inl ?_⟩
    · intro i
      fin_cases i <;> simp [Q,Box.cube,center,z] <;> omega
    · ext i
      by_cases hi : i = 1
      · subst i; simp [z,step]
      · simp [z,step,hi,Ne.symm hi]
  · refine ⟨step y 0,?_,0,Or.inr rfl⟩
    intro i
    fin_cases i <;> simp [Q,Box.cube,center,step] <;> omega

noncomputable def rootPacket (r : ℕ) : Packet r where
  vertex := 0
  parent := 0
  graph := LatticeGraph.ofBox (Q r 0)
  contains := LatticeGraph.ofBox_contains _
  root_mem := (Box.mem_vertices _ _).mpr (zero_in_Q r)

noncomputable def initial (m : Model) (r : ℕ) : Exploration m r where
  history := ⟨rootBits m r,fun _ => true⟩
  processed := {0}
  queue := List.ofFn (fun d : Direction => (rootPacket r).child (outward d))
  good := {0}
  bad := ∅

theorem root_internal_disjoint (m : Model) (r : ℕ) (d : Direction) :
    Disjoint (rootBits m r) ((Q r (outward d)).bits m) := by
  rw [rootBits,Finset.disjoint_union_left]
  constructor
  · exact bits_disjoint m r (Ne.symm (by simpa only [zero_add] using neighbor_ne 0 d))
  · apply Finset.disjoint_left.mpr
    intro e he hi
    obtain ⟨j,_,he⟩ := Finset.mem_biUnion.mp he
    exact Finset.disjoint_left.mp
      (bits_link_disjoint m r (outward d) (Ne.symm (by simpa only [zero_add] using neighbor_ne 0 j))) hi he

theorem initial_seed_event (m : Model) (r a : ℕ) (ha : a ≤ 4*r) (d : Direction)
    {ω : m.Config} (hO : ω ∈ allValue (rootBits m r) true)
    (hE : ω ∈ m.SeedReaches (center r (outward d)) a (10*r)
      (QuarterFace (center r (outward d)) (10*r) (facingFace d))) :
    ω ∈ ((rootPacket r).child (outward d)).event m := by
  let t := (rootPacket r).child (outward d)
  let G := t.graph
  have hB : G.ContainsBox (Q r (outward d)) := t.contains
  have hroot : G.ContainsBox (Q r 0) :=
    (extendGraph_subgraph r (rootPacket r).graph 0 (outward d) (rootPacket r).contains).containsBox
      (rootPacket r).contains
  obtain ⟨x,y,hxa,hy,hxy⟩ := G.seedReaches_witness m (by omega) hB hE
  obtain ⟨z,hz,hzy⟩ := facing_neighbor r d hy
  let z' : G.Node := ⟨z,G.containsBox_node hroot hz⟩
  let o : G.Node := ⟨0,t.root_mem⟩
  have hrootOpen : ∀ e ∈ (Q r 0).bits m, ω e = true :=
    fun e he => hO e (Finset.mem_union_left _ he)
  have hoz : G.Conn m ω o z' := G.open_box_conn m hroot hrootOpen (zero_in_Q r) hz
  have hzy' : G.Adj m ω z' y := by
    obtain ⟨e,he⟩ := LatticeGraph.neighbor_incidence hzy
    have hi : e ∈ interface r 0 (outward d) := by
      rw [mem_interface]
      have hyQ : (Q r (outward d)).Contains y.1 :=
        Box.contains_cube_iff.mpr (quarterFace_subset_boundary _ _ _ hy).1
      rcases he with ⟨he0,he1⟩ | ⟨he0,he1⟩
      · exact Or.inl ⟨he0 ▸ hz,he1 ▸ hyQ⟩
      · exact Or.inr ⟨he0 ▸ hyQ,he1 ▸ hz⟩
    have hedge : e ∈ G.edges := Finset.mem_union_right _ hi
    cases m
    · exact ⟨e,hedge,he,hO e (Finset.mem_union_right _
        (Finset.mem_biUnion.mpr ⟨d,Finset.mem_univ _,hi⟩))⟩
    · exact ⟨⟨e,hedge,he⟩,(G.conn_open .site hoz).2,(G.conn_open .site hxy).2⟩
  refine ⟨x,Box.contains_cube_iff.mpr (cube_mono _ ha hxa),?_⟩
  exact G.conn_trans m hoz (G.conn_trans m (G.conn_adj m hzy') (G.conn_symm m hxy))

theorem initial_promise {m : Model} (sc : ScaleData m) (d : Direction) :
    1-sc.δ < (ProductCylinder.law ((initial m sc.r).history.parameter sc.q)).real
      (((rootPacket sc.r).child (outward d)).event m) := by
  let E := m.SeedReaches (center sc.r (outward d)) sc.seed (10*sc.r)
    (QuarterFace (center sc.r (outward d)) (10*sc.r) (facingFace d))
  have ha : sc.seed ≤ 4*sc.r := by have := sc.seed_R; have := sc.large_r; omega
  have hdet := m.seedReaches_determined (center sc.r (outward d)) sc.seed (10*sc.r)
    (by omega) (QuarterFace (center sc.r (outward d)) (10*sc.r) (facingFace d))
  have heq : (ProductCylinder.law ((initial m sc.r).history.parameter sc.q)).real E =
      (ProductCylinder.law (fun _ : m.Bit => sc.q)).real E :=
    fixed_determined_probability _ _ _ (root_internal_disjoint m sc.r d) _ _ hdet
  have hle : (ProductCylinder.law ((initial m sc.r).history.parameter sc.q)).real E ≤
      (ProductCylinder.law ((initial m sc.r).history.parameter sc.q)).real
        (((rootPacket sc.r).child (outward d)).event m) := by
    apply finite_measureReal_mono_ae
    filter_upwards [ae_fixed_pattern (fun _ : m.Bit => sc.q) (rootBits m sc.r) (fun _ => true)] with ω hω
    exact fun hE => initial_seed_event m sc.r sc.seed ha d hω hE
  have hh := sc.faces (10*sc.r) (by simp) (center sc.r (outward d)) (facingFace d)
  rw [heq] at hle
  exact (sub_lt_sub_left sc.γδ 1).trans (hh.trans_le hle)

@[simp] theorem mem_initial_queue (m : Model) (r : ℕ) (t : Packet r) :
    t ∈ (initial m r).queue ↔ ∃ d : Direction, (rootPacket r).child (outward d) = t := by
  simp only [initial,List.mem_ofFn]

theorem initial_valid {m : Model} (sc : ScaleData m) : (initial m sc.r).Valid sc.q sc.δ := by
  constructor
  · exact Finset.mem_singleton_self _
  · change ((List.ofFn (fun d : Direction => (rootPacket sc.r).child (outward d))).map Packet.vertex).Nodup
    rw [List.map_ofFn]
    exact List.nodup_ofFn.mpr outward_injective
  · intro t ht
    obtain ⟨d,rfl⟩ := (mem_initial_queue _ _ _).mp ht
    simpa only [initial,Packet.child,Finset.mem_singleton,zero_add] using neighbor_ne 0 d
  · intro t ht
    obtain ⟨d,rfl⟩ := (mem_initial_queue _ _ _).mp ht
    exact Finset.mem_singleton_self _
  · intro e he
    exact Finset.mem_union_left _ (Finset.mem_union_left _ he)
  · intro t ht
    obtain ⟨d,rfl⟩ := (mem_initial_queue _ _ _).mp ht
    rw [Packet.child_bits]
    apply Finset.union_subset_union ?_ (Finset.Subset.refl _)
    change (LatticeGraph.ofBox (Q sc.r 0)).bits m ⊆ rootBits m sc.r
    have he : (LatticeGraph.ofBox (Q sc.r 0)).bits m = (Q sc.r 0).bits m := by cases m <;> rfl
    rw [he]
    exact Finset.subset_union_left
  · intro t ht
    obtain ⟨d,rfl⟩ := (mem_initial_queue _ _ _).mp ht
    exact initial_promise sc d

theorem initial_colored (m : Model) (r : ℕ) : (initial m r).Colored := by
  constructor
  · simp only [initial,Finset.union_empty]
  · exact Finset.disjoint_empty_right _

theorem initial_closed (m : Model) (r : ℕ) : (initial m r).Closed := by
  intro v hv d
  have hv0 : v = 0 := Finset.mem_singleton.mp hv
  subst v
  rw [zero_add]
  apply Exploration.queue_visited (initial m r) (t := (rootPacket r).child (outward d))
  exact (mem_initial_queue _ _ _).mpr ⟨d,rfl⟩

theorem initial_covered (m : Model) (r : ℕ) : (initial m r).Covered := by
  intro v hv
  rcases Finset.mem_union.mp hv with hv|hv
  · exact Or.inl hv
  · obtain ⟨t,ht,rfl⟩ := List.mem_map.mp (List.mem_toFinset.mp hv)
    obtain ⟨d,rfl⟩ := (mem_initial_queue _ _ _).mp ht
    exact Or.inr ⟨0,Finset.mem_singleton_self _,d,(zero_add _).symm⟩

end Coarse
end CriticalZ3

end OAI