import OAI.Probability.CriticalZ3.Relay

namespace OAI

universe uOmega

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

open scoped ENNReal BigOperators Matrix

namespace CriticalZ3
open _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
namespace Model

def Internal : (m : Model) → Set Vertex → m.Bit → Prop
  | .bond,D,e => e.1 ∈ D ∧ step e.1 e.2 ∈ D
  | .site,D,x => x ∈ D

def UniformOn (m : Model) (p : m.Bit → Set.Icc (0:ℝ) 1)
    (q : Set.Icc (0:ℝ) 1) (D : Set Vertex) : Prop := ∀ e, m.Internal D e → p e = q

theorem box_internal (m : Model) (B : Box) (e : m.Bit) :
    e ∈ B.bits m ↔ m.Internal {x | B.Contains x} e := by
  cases m <;> simp [Box.bits,Internal]

theorem internal_mono (m : Model) {D T : Set Vertex} (h : D ⊆ T) {e : m.Bit}
    (he : m.Internal D e) : m.Internal T e := by
  cases m
  · exact ⟨h he.1,h he.2⟩
  · exact h he

theorem UniformOn.box (m : Model) {p : m.Bit → Set.Icc (0:ℝ) 1} {q : Set.Icc (0:ℝ) 1}
    {D : Set Vertex} (h : m.UniformOn p q D) (B : Box) (hB : ∀ x, B.Contains x → x ∈ D) :
    ∀ e ∈ B.bits m, p e = q := fun e he => h e (m.internal_mono hB ((m.box_internal B e).mp he))

theorem seedReaches_target_mono (m : Model) (c : Vertex) (a b : ℕ) {T U : Set Vertex} (h : T ⊆ U) :
    m.SeedReaches c a b T ⊆ m.SeedReaches c a b U := by
  rintro ω ⟨x,hx,ho,y,hy,hp⟩
  exact ⟨x,hx,ho,y,h hy,hp⟩

theorem seedReaches_image_probability (m : Model) (S : SignedSymmetry) (q : Set.Icc (0:ℝ) 1)
    (c : Vertex) (a b : ℕ) (hab : a ≤ b) (T : Set Vertex) :
    (ProductCylinder.law (fun _ : m.Bit => q)).real
      (m.SeedReaches (S.vertex c) a b (S.vertex '' T)) =
    (ProductCylinder.law (fun _ : m.Bit => q)).real (m.SeedReaches c a b T) := by
  have he : S.vertex ⁻¹' (S.vertex '' T) = T := Set.preimage_image_eq T S.vertex.injective
  cases m
  · simp only [seedReaches_bond,Measure.real_def]
    have hh := ProductCylinder.reindex_probability S.bond q (bondSeedReaches c a b T)
      (measurableSet_bondSeedReaches _ _ _ _)
    rw [←hh]
    congr 2
    ext ω
    simpa only [Set.mem_preimage,he] using (S.bondSeedReaches_map ω c a b (S.vertex '' T)).symm
  · simp only [seedReaches_site,Measure.real_def]
    have hh := ProductCylinder.reindex_probability S.vertex q (siteSeedReaches c a b T)
      (measurableSet_siteSeedReaches _ _ _ hab _)
    rw [←hh]
    congr 2
    ext ω
    simpa only [Set.mem_preimage,he] using (S.siteSeedReaches_map ω c a b (S.vertex '' T)).symm
end Model

namespace LatticeGraph
variable (G : LatticeGraph)
def ContainsSet (D : Set Vertex) : Prop :=
  (∀ x ∈ D, x ∈ G.vertices) ∧ ∀ e : Bond, e.1 ∈ D → step e.1 e.2 ∈ D → e ∈ G.edges

theorem ContainsSet.box {D : Set Vertex} (h : G.ContainsSet D) (B : Box)
    (hB : ∀ x, B.Contains x → x ∈ D) : G.ContainsBox B := by
  constructor
  · intro x hx; exact h.1 x (hB x (Box.mem_vertices B x |>.mp hx))
  · intro e he
    have hh := (Box.mem_bonds B e).mp he
    exact h.2 e (hB _ hh.1) (hB _ hh.2)
end LatticeGraph

namespace Box

def rect (c w : Vertex) (hw : ∀ i, 0 ≤ w i) : Box :=
  ⟨fun i => c i-w i,fun i => c i+w i,fun i => by linarith [hw i]⟩

theorem contains_rect (c w : Vertex) (hw : ∀ i, 0 ≤ w i) (x : Vertex) :
    (rect c w hw).Contains x ↔ x ∈ LatticeRelay.Rect c w := by
  constructor <;> intro h i
  · have hh := h i
    change |x i-c i| ≤ w i
    rw [abs_le]
    dsimp [rect] at hh
    omega
  · have hh := h i
    change |x i-c i| ≤ w i at hh
    rw [abs_le] at hh
    change c i-w i ≤ x i ∧ x i ≤ c i+w i
    omega

def framedRect (S : SignedSymmetry) (c w : Vertex) (hw : ∀ i, 0 ≤ w i) : Box :=
  rect (S.vertex c) (fun i => w (S.perm i)) (fun i => hw (S.perm i))

theorem abs_vertex_sub (S : SignedSymmetry) (x c : Vertex) (i : Fin 3) :
    |S.vertex x i-S.vertex c i| = |x (S.perm i)-c (S.perm i)| := by
  dsimp [SignedSymmetry.vertex]
  cases S.signs i <;> simp only [Bool.false_eq_true,ite_false,ite_true]
  · have he : S.shift i+-x (S.perm i)-(S.shift i+-c (S.perm i)) =
        -(x (S.perm i)-c (S.perm i)) := by ring
    rw [he,abs_neg]
  · congr 1; ring

theorem framedRect_map (S : SignedSymmetry) (c w : Vertex) (hw : ∀ i, 0 ≤ w i) (x : Vertex) :
    (framedRect S c w hw).Contains (S.vertex x) ↔ x ∈ LatticeRelay.Rect c w := by
  rw [framedRect,contains_rect]
  change (∀ i, |S.vertex x i-S.vertex c i| ≤ w (S.perm i)) ↔ _
  simp_rw [abs_vertex_sub]
  constructor
  · intro h i; simpa only [Equiv.apply_symm_apply] using h (S.perm.symm i)
  · intro h i; exact h _

theorem framedRect_expand_map (S : SignedSymmetry) (c w : Vertex) (hw : ∀ i, 0 ≤ w i)
    (R : ℕ) (x : Vertex) :
    ((framedRect S c w hw).expand R).Contains (S.vertex x) ↔ x ∈ LatticeRelay.Expand c w R := by
  have he : (framedRect S c w hw).expand R =
      framedRect S c (fun i => w i+R) (fun i => by have := hw i; positivity) := by
    apply Box.ext <;> funext i <;> dsimp [expand,framedRect,rect] <;> ring
  rw [he,framedRect_map]
  rfl
end Box

namespace ScaleData
variable {model : Model} (s : ScaleData model)

theorem radius_seed {n : ℕ} (hn : n ∈ ({2*s.r,2*s.r+1,10*s.r} : Finset ℕ)) : s.seed ≤ n := by
  have := s.seed_R
  have := s.large_r
  simp only [Finset.mem_insert,Finset.mem_singleton] at hn
  omega

theorem extension_interface (G : LatticeGraph) (p : model.Bit → Set.Icc (0:ℝ) 1)
    (D : Set Vertex) (hG : G.ContainsSet D) (hp : model.UniformOn p s.q D)
    (o : G.Node) (ho : o.1 ∉ D) (B : Box) (T : Set Vertex)
    (hB : ∀ x, (B.expand s.R).Contains x → x ∈ D)
    (hI : ∀ u, (B.expand s.R).Contains u → ∃ n ∈ ({2*s.r,2*s.r+1,10*s.r}:Finset ℕ),
      ∃ S : SignedSymmetry, ∃ c : Vertex, ∃ f : FaceIndex, S.vertex c = u ∧
      (∀ x ∈ cube u n, x ∈ D) ∧ S.vertex '' QuarterFace c n f ⊆ T) :
    (ProductCylinder.law p).real {ω | G.Meets model ω o {x | B.Contains x} ∧
      ¬G.Meets model ω o T} < s.η := by
  refine (G.extension_bound model p s.q s.q_pos s.q_lt.le s.p_lt_one B s.seed s.K s.R
    s.K_pos s.seed_R (hG.box G _ hB) o T (fun h => ho (hB _ h))
    (hp.box model _ hB) s.γ_range.1.le s.τ_range.1 ?_).trans_lt s.extension_budget
  intro u hu
  obtain ⟨n,hn,S,c,f,hc,hcube,hface⟩ := hI u hu
  have hr := s.radius_seed hn
  refine ⟨n,hr,hG.box G _ (fun x hx => hcube x (Box.contains_cube_iff.mp hx)),?_⟩
  have he := ProductCylinder.probability_congr_parameters ((Box.cube u n).bits model)
    p (fun _ => s.q) (hp.box model _ (fun x hx => hcube x (Box.contains_cube_iff.mp hx)))
    (model.SeedReaches u s.seed n T) (model.seedReaches_determined _ _ _ hr _)
  rw [he]
  have hh := s.faces n hn c f
  rw [←model.seedReaches_image_probability S s.q c s.seed n hr (QuarterFace c n f),hc] at hh
  exact hh.le.trans (measureReal_mono (model.seedReaches_target_mono _ _ _ hface))
end ScaleData
end CriticalZ3

namespace MeasureTheory
open scoped _root_.MeasureTheory
open Classical
variable {Ω : Type uOmega} [MeasurableSpace Ω]
theorem finite_relay_bound (μ : _root_.MeasureTheory.Measure Ω) [_root_.MeasureTheory.IsProbabilityMeasure μ] (A : ℕ → Set Ω)
    (η : ℝ) (n : ℕ) (h : ∀ i < n, μ.real (A i \ A (i+1)) ≤ η) :
    μ.real (A 0 \ A n) ≤ n*η := by
  induction n with
  | zero => simp only [Nat.cast_zero,zero_mul,Set.sdiff_self,_root_.MeasureTheory.measureReal_empty,le_refl]
  | succ n ih =>
    have hs : A 0 \ A (n+1) ⊆ (A 0 \ A n) ∪ (A n \ A (n+1)) := by
      intro ω hω
      by_cases hn : ω ∈ A n
      · exact Or.inr ⟨hn,hω.2⟩
      · exact Or.inl ⟨hω.1,hn⟩
    have hh := (_root_.MeasureTheory.measureReal_mono (μ := μ) hs).trans (_root_.MeasureTheory.measureReal_union_le _ _)
    have hi := ih (fun i hi => h i (by omega))
    have hn := h n (by omega)
    rw [Nat.cast_add,Nat.cast_one]
    nlinarith
end MeasureTheory

namespace CriticalZ3
open _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical
namespace ScaleData
variable {model : Model} (s : ScaleData model)

theorem R_pos : 0 < s.R := s.seed_pos.trans s.seed_R

theorem route_width_nonneg (i : ℕ) (j : Fin 3) : 0 ≤ LatticeRelay.routeWidths s.r s.R i j := by
  unfold LatticeRelay.routeWidths
  split_ifs
  · dsimp [LatticeRelay.contractionWidths]
    split_ifs <;> positivity
  · positivity

def routeBox (S : SignedSymmetry) (i : ℕ) : Box :=
  Box.framedRect S (LatticeRelay.routeCenter s.r i) (LatticeRelay.routeWidths s.r s.R i)
    (s.route_width_nonneg i)

theorem routeBox_contains (S : SignedSymmetry) (i : ℕ) (x : Vertex) :
    (s.routeBox S i).Contains x ↔ x ∈ S.vertex '' LatticeRelay.P s.r s.R i := by
  rw [←S.vertex.apply_symm_apply x,routeBox,Box.framedRect_map]
  simp only [Set.mem_image,Equiv.apply_eq_iff_eq,exists_eq_right]
  rfl

theorem relay_in_frame (G : LatticeGraph) (p : model.Bit → Set.Icc (0:ℝ) 1)
    (S : SignedSymmetry) (hG : G.ContainsSet (S.vertex '' LatticeRelay.Prism s.r))
    (hp : model.UniformOn p s.q (S.vertex '' LatticeRelay.Prism s.r))
    (o : G.Node) (ho : o.1 ∉ S.vertex '' LatticeRelay.Prism s.r) :
    (ProductCylinder.law p).real
      {ω | G.Meets model ω o (cube (S.vertex 0) (4*s.r)) ∧
        ¬G.Meets model ω o (cube (S.vertex (LatticeRelay.axisCenter (20*s.r+1))) (4*s.r))}
      ≤ 13*s.η := by
  have hR : (0:ℤ) < s.R := by exact_mod_cast s.R_pos
  have hr : (100:ℤ)*(s.R+1) < s.r := by exact_mod_cast s.large_r
  have hcube (c : Vertex) (n : ℕ) : S.vertex '' LatticeRelay.Cube c n = cube (S.vertex c) n := by
    ext x
    rw [←S.vertex.apply_symm_apply x]
    simp only [Set.mem_image,Equiv.apply_eq_iff_eq,exists_eq_right]
    rw [←S.cube_map]
    rw [mem_cube]
    constructor <;> intro h i
    · have hh := h i
      change |S.vertex.symm x i-c i| ≤ (n:ℤ) at hh
      rw [abs_le] at hh
      change c i-n ≤ S.vertex.symm x i ∧ S.vertex.symm x i ≤ c i+n
      omega
    · have hh := h i
      change c i-n ≤ S.vertex.symm x i ∧ S.vertex.symm x i ≤ c i+n at hh
      change |S.vertex.symm x i-c i| ≤ (n:ℤ)
      rw [abs_le]
      omega
  let A (i : ℕ) : Set model.Config := {ω | G.Meets model ω o {x | (s.routeBox S i).Contains x}}
  have hi (i : ℕ) (hi : i < 13) : (ProductCylinder.law p).real (A i \ A (i+1)) ≤ s.η := by
    apply le_of_lt
    apply s.extension_interface G p (S.vertex '' LatticeRelay.Prism s.r) hG hp o ho
      (s.routeBox S i) {x | (s.routeBox S (i+1)).Contains x}
    · intro x hx
      refine ⟨S.vertex.symm x,?_,S.vertex.apply_symm_apply x⟩
      apply LatticeRelay.expanded_route_subset_prism hR hr hi
      apply (Box.framedRect_expand_map S _ _ (s.route_width_nonneg i) s.R (S.vertex.symm x)).mp
      simpa only [routeBox,Equiv.apply_symm_apply] using hx
    · intro u hu
      have huu : S.vertex.symm u ∈ LatticeRelay.Expand
          (LatticeRelay.routeCenter s.r i) (LatticeRelay.routeWidths s.r s.R i) s.R := by
        apply (Box.framedRect_expand_map S _ _ (s.route_width_nonneg i) s.R (S.vertex.symm u)).mp
        simpa only [routeBox,Equiv.apply_symm_apply] using hu
      obtain ⟨n,hn,hsub,j,signs,hface⟩ := LatticeRelay.thirteen_interfaces hR hr hi _ huu
      have hn' : ∃ l ∈ ({2*s.r,2*s.r+1,10*s.r}:Finset ℕ), (l:ℤ) = n := by
        simp only [Set.mem_insert_iff,Set.mem_singleton_iff] at hn
        rcases hn with rfl|rfl|rfl
        · exact ⟨2*s.r,by simp,by push_cast; rfl⟩
        · exact ⟨2*s.r+1,by simp,by push_cast; rfl⟩
        · exact ⟨10*s.r,by simp,by push_cast; rfl⟩
      obtain ⟨l,hl,rfl⟩ := hn'
      refine ⟨l,hl,S,S.vertex.symm u,(j,signs),S.vertex.apply_symm_apply u,?_,?_⟩
      · intro x hx
        have hx' : x ∈ S.vertex '' LatticeRelay.Cube (S.vertex.symm u) l := by
          rw [hcube,S.vertex.apply_symm_apply]
          exact hx
        obtain ⟨y,hy,rfl⟩ := hx'
        exact ⟨y,hsub hy,rfl⟩
      · rintro x ⟨y,hy,rfl⟩
        apply (s.routeBox_contains S (i+1) _).mpr
        exact ⟨y,hface hy,rfl⟩
  have h := finite_relay_bound (ProductCylinder.law p) A s.η 13 hi
  norm_num only [Nat.cast_ofNat] at h
  apply le_trans (measureReal_mono (μ := ProductCylinder.law p) ?_) h
  intro ω hω
  constructor
  · obtain ⟨y,hy,hconn⟩ := hω.1
    refine ⟨y,?_,hconn⟩
    apply (s.routeBox_contains S 0 _).mpr
    rw [LatticeRelay.P_zero,show (4:ℤ)*s.r = (4*s.r:ℕ) by push_cast; rfl,hcube]
    exact hy
  · intro hh
    apply hω.2
    obtain ⟨y,hy,hconn⟩ := hh
    refine ⟨y,?_,hconn⟩
    have hy' := (s.routeBox_contains S 13 _).mp hy
    obtain ⟨z,hz,hzy⟩ := hy'
    rw [←hzy]
    have hz' := LatticeRelay.P_thirteen_subset hR hr hz
    have hm : S.vertex z ∈ S.vertex '' LatticeRelay.Cube (LatticeRelay.axisCenter (20*s.r+1)) (4*s.r:ℕ) :=
      ⟨z,by simpa only [Nat.cast_mul,Nat.cast_ofNat] using hz',rfl⟩
    rwa [hcube] at hm
end ScaleData
end CriticalZ3

end OAI