import OAI.Combinatorics.PlanarL1.MainCells

namespace OAI

section

namespace PlanarL1.Columns.Model
open MeasureTheory
open scoped NNReal

namespace SetSystem
variable {n : ℕ} {M : Model n} {Ω Ω' : Type*} [MeasurableSpace Ω]
  [MeasurableSpace Ω'] {μ : Measure Ω} {μ' : Measure Ω'}

/-- Change label coordinates only: every individual set and component graph is
pulled back, and the upper invariant is transported by the actual measure. -/
noncomputable def pullback (A : SetSystem M Ω μ) {g : Ω' → Ω}
    (hg : MeasurePreserving g μ' μ) : SetSystem M Ω' μ' where
  activity ω := A.activity (g ω)
  measurable_active i H := (A.measurable_active i H).preimage hg.measurable
  vertical_integrable i s t := hg.integrable_comp_of_integrable (A.vertical_integrable i s t)
  vertical_bound i s t := by
    have he : (∫ ω, |(A.activity (g ω)).indicator i s-(A.activity (g ω)).indicator i t| ∂μ') =
        ∫ ω, |(A.activity ω).indicator i s-(A.activity ω).indicator i t| ∂μ := by
      calc
        _ = ∫ ω, |(A.activity ω).indicator i s-(A.activity ω).indicator i t|
            ∂Measure.map g μ' :=
          (integral_map_of_stronglyMeasurable hg.measurable
            (((A.measurable_indicator i s).sub
              (A.measurable_indicator i t)).abs.stronglyMeasurable)).symm
        _ = _ := congrArg (fun ν => ∫ ω,
          |(A.activity ω).indicator i s-(A.activity ω).indicator i t| ∂ν) hg.map_eq
    exact he.trans_le (A.vertical_bound i s t)

noncomputable def lift (A : SetSystem M Ω μ) : SetSystem M (Ω × Bool) (μ.prod Threshold.fair) :=
  A.pullback (measurePreserving_fst (μ := μ) (ν := Threshold.fair))

@[simp] lemma lift_active (A : SetSystem M Ω μ) (z : Ω × Bool) (i : Fin n) (H : ℝ) :
    (A.lift.activity z).active i H ↔ (A.activity z.1).active i H := Iff.rfl

end SetSystem

namespace Field
variable {n : ℕ} (M : Model n) (I : Set ℝ)
noncomputable def constant (c : ℝ) : M.Field I 1 where
  value _ _ := c
  vertical _ := (LipschitzWith.const c).weaken (by norm_num)
  switch _ _ _ _ := rfl
end Field

/-- The literal ordinary-chart scalar data. A nonconstant chart remembers its
old band component and its one point source, rather than just a Lipschitz bound.
The zero extension outside that component is never used on the chart's region. -/
structure OrdinaryData {n : ℕ} (M : Model n) where
  band : Set ℝ
  closed : IsClosed band
  convex : band.OrdConnected
  origin : Option (Σ r : Fin n, M.Point band r)
  constant : ℝ
  orientation : ℝ
  unit_orientation : |orientation| = 1

namespace OrdinaryData
variable {n : ℕ} {M : Model n}

noncomputable def comparison (D : OrdinaryData M) : M.Field D.band 1 :=
  match D.origin with
  | none => Field.constant M D.band 0
  | some o => o.2.radialField

noncomputable def value (D : OrdinaryData M) (i : Fin n) (H : D.band) : ℝ :=
  D.constant + D.orientation * D.comparison.value i H

lemma vertical (D : OrdinaryData M) (i : Fin n) : LipschitzWith 1 (D.value i) := by
  apply LipschitzWith.of_dist_le_mul
  intro s t
  rw [Real.dist_eq]
  change |D.constant+D.orientation*D.comparison.value i s-
    (D.constant+D.orientation*D.comparison.value i t)| ≤ _
  rw [show D.constant+D.orientation*D.comparison.value i s-
    (D.constant+D.orientation*D.comparison.value i t) =
    D.orientation*(D.comparison.value i s-D.comparison.value i t) by ring,
    abs_mul,D.unit_orientation,one_mul]
  exact (D.comparison.vertical i).dist_le_mul s t

lemma switch (D : OrdinaryData M) (i j : Fin n) (H : D.band)
    (h : H.val ∈ M.heights i j) : D.value i H = D.value j H := by
  simp only [value,D.comparison.switch i j H h]

noncomputable def field (D : OrdinaryData M) : M.Field D.band 1 :=
  ⟨D.value,D.vertical,D.switch⟩

noncomputable def initial (M : Model n) : OrdinaryData M where
  band := Set.univ
  closed := isClosed_univ
  convex := Set.ordConnected_univ
  origin := none
  constant := 0
  orientation := 1
  unit_orientation := by norm_num

@[simp] lemma initial_value (M : Model n) (i : Fin n) (H : ℝ) :
    (initial M).value i ⟨H,Set.mem_univ H⟩ = 0 := by
  simp [initial,value,comparison,Field.constant]

/-- Conversion of an actual signed atom back to the old ordinary orientation. -/
noncomputable def atom (D : OrdinaryData M) (J : Set ℝ) (hJ : IsClosed J)
    (hc : J.OrdConnected) {r : Fin n} (o : M.Point J r) (c η : ℝ) (hη : |η| = 1) :
    OrdinaryData M where
  band := J
  closed := hJ
  convex := hc
  origin := some ⟨r,o⟩
  constant := D.constant+D.orientation*c
  orientation := D.orientation*η
  unit_orientation := by rw [abs_mul,D.unit_orientation,hη,mul_one]

lemma atom_value (D : OrdinaryData M) (J : Set ℝ) (hJ : IsClosed J)
    (hc : J.OrdConnected) {r : Fin n} (o x : M.Point J r) (c η : ℝ) (hη : |η| = 1) :
    (D.atom J hJ hc o c η hη).value x.column ⟨x.height,x.inBand⟩ =
      D.constant+D.orientation*(c+η*dist o x) := by
  have he : o.radialField.value x.column ⟨x.height,x.inBand⟩=dist o x := o.radialField_eval x
  simp only [value,atom,comparison,he]
  ring

end OrdinaryData

/-- A finite ordinary chart partition for system A, with the actual globally
nested sets and actual jointly distributed label variables. Chart regions may
be disconnected; no artificial connected-component identifiers are introduced. -/
structure OrdinaryState {n : ℕ} (M : Model n) (κ : ℝ) (Ω : Type*)
    [MeasurableSpace Ω] (μ : Measure Ω) where
  sets : SetSystem M Ω μ
  count : ℕ
  chart : Fin (count+1) → OrdinaryData M
  labels : Fin (count+1) → Threshold.Variables Ω μ
  name : Fin n → ℝ → Fin (count+1)
  height_in : ∀ i H, H ∈ (chart (name i H)).band
  component_in : ∀ i H r o, (chart (name i H)).origin = some ⟨r,o⟩ →
    (M.activeGraph (chart (name i H)).band).Reachable r i
  switch_name : ∀ i j H, H ∈ M.heights i j → name i H = name j H
  represents : ∀ ω i H,
    (sets.activity ω).active i H ↔ Threshold.active (labels (name i H)) H
      (κ*(chart (name i H)).value i ⟨H,height_in i H⟩) ω

namespace OrdinaryState
variable {n : ℕ} {M : Model n} {κ : ℝ} {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω}

noncomputable def initial (M : Model n) (κ : ℝ) :
    OrdinaryState M κ (Bool × ℝ) Threshold.labelMeasure where
  sets := Threshold.chartSystem (Field.constant M Set.univ 0) (by norm_num)
  count := 0
  chart _ := OrdinaryData.initial M
  labels _ := Threshold.Variables.initial
  name _ _ := 0
  height_in _ _ := Set.mem_univ _
  component_in _ _ r o h := by cases h
  switch_name _ _ _ _ := rfl
  represents ω i H := by
    simp only [Threshold.chartSystem,Threshold.chartActivity,OrdinaryData.initial_value,
      mul_zero,Field.constant,Threshold.active,Threshold.Variables.initial]
    rfl

noncomputable def lift (S : OrdinaryState M κ Ω μ) :
    OrdinaryState M κ (Ω × Bool) (μ.prod Threshold.fair) where
  sets := S.sets.lift
  count := S.count
  chart := S.chart
  labels j := (S.labels j).lift
  name := S.name
  height_in := S.height_in
  component_in := S.component_in
  switch_name := S.switch_name
  represents ω i H := S.represents ω.1 i H

/-- Deterministic chart distance on a common identifier, with no independence
assumed between different identifiers. -/
lemma chart_distance (S : OrdinaryState M κ Ω μ) (i j : Fin n) (H T : ℝ)
    (he : S.name i H=S.name j T) :
    (∫ ω, |(S.sets.activity ω).indicator i H-(S.sets.activity ω).indicator j T| ∂μ) =
      max |H-T| |κ*(S.chart (S.name i H)).value i ⟨H,S.height_in i H⟩-
        κ*(S.chart (S.name j T)).value j ⟨T,S.height_in j T⟩| := by
  have hid (i : Fin n) (H : ℝ) (ω : Ω) :
      (S.sets.activity ω).indicator i H = Threshold.chartValue H
        (κ*(S.chart (S.name i H)).value i ⟨H,S.height_in i H⟩)
        ((S.labels (S.name i H)).value ω) := by
    simp only [Activity.indicator,S.represents,Threshold.active,Threshold.chartValue,Threshold.half]
  simp_rw [hid]
  rw [show S.labels (S.name j T)=S.labels (S.name i H) from congrArg S.labels he.symm]
  exact (S.labels (S.name i H)).distance _ _ _ _

end OrdinaryState
end PlanarL1.Columns.Model


namespace PlanarL1.Columns.Model.Point.RadialTree
open PlanarL1.Interpolation
variable {n : ℕ} {M : Model n} {J : Set ℝ} {root : Fin n}
variable (R : RadialTree (M := M) (J := J) (root := root))

lemma atomName_depth_eq {k l : ℕ} (u v : M.Point J root) (t t' : Fin 3)
    (he : atomName k u t = atomName l v t') : k = l := by
  have hu := atomName_bounds k u t
  have hv := atomName_bounds l v t'
  rcases lt_trichotomy k l with h | h | h
  · have hm := Nat.mul_le_mul_left (3*n) (Nat.succ_le_of_lt h)
    simp only [Nat.succ_eq_add_one] at hm
    omega
  · exact h
  · have hm := Nat.mul_le_mul_left (3*n) (Nat.succ_le_of_lt h)
    simp only [Nat.succ_eq_add_one] at hm
    omega

lemma portalAt_mem {k : ℕ} (C : R.Node k) (i : Fin 2) :
    (R.portalAt C i).column ∈ ColumnOrder.componentColumns C := by
  by_cases hi : i = 0
  · simpa only [portalAt,ite_eq_left hi] using (R.portals C).left_mem
  · simpa only [portalAt,ite_eq_right hi] using (R.portals C).right_mem

lemma node_eq_of_portal_column {k : ℕ} (C D : R.Node k) (i j : Fin 2)
    (he : (R.portalAt C i).column=(R.portalAt D j).column) : C = D := by
  apply ColumnOrder.component_eq_of_column (R.portalAt_mem C i)
  rw [he]
  exact R.portalAt_mem D j

/-- A name is global to the whole interpolation tree, not only a chosen chain.
Different node occurrences cannot silently give one identifier two fields. -/
lemma nodeAtom_eq_global (p : M.Point J root → ℝ) (α : Noise (n := n))
    {k l : ℕ} (C : R.Node k) (D : R.Node l) (i j : Fin 2) (t t' : Fin 3)
    (he : atomName k (R.portalAt C i) t = atomName l (R.portalAt D j) t') :
    R.nodeAtom p α C i t = R.nodeAtom p α D j t' := by
  have hk := atomName_depth_eq (R.portalAt C i) (R.portalAt D j) t t' he
  subst l
  obtain ⟨hc,ht⟩ := atomName_same_depth _ _ _ _ he
  have hC := R.node_eq_of_portal_column C D i j hc
  subst D
  exact R.nodeAtom_eq_of_name p α C i j t t' he

/-- The exact portal occurrence from which an atom identifier originates. -/
structure AtomSource (a : ℕ) where
  depth : ℕ
  node : R.Node depth
  portal : Fin 2
  kind : Fin 3
  name_eq : atomName depth (R.portalAt node portal) kind = a

lemma pasted_has_source (p : M.Point J root → ℝ) (α : Noise (n := n))
    (x : M.Point J root) : Nonempty (R.AtomSource (R.pasted p α x).name) := by
  obtain ⟨k,hk,i,t,he⟩ := R.formula_eq_atom p α (R.layerDepth x) (R.layerNode x) x
  refine ⟨⟨k,R.ancestor (R.layerNode x) k hk,i,t,?_⟩⟩
  exact (congrArg NamedValue.name he).symm

lemma pasted_name_lt (p : M.Point J root → ℝ) (α : Noise (n := n))
    (x : M.Point J root) : (R.pasted p α x).name < 3*n*R.depthCap := by
  exact (R.formula_name_bound p α (R.layerDepth x) (R.layerNode x) x).trans_le
    (Nat.mul_le_mul_left (3*n) (R.layerDepth_lt_cap x))

namespace AtomSource
variable {R} {a : ℕ}

noncomputable def eval (S : R.AtomSource a) (p : M.Point J root → ℝ)
    (α : Noise (n := n)) : M.Point J root → NamedValue :=
  R.nodeAtom p α S.node S.portal S.kind

lemma eval_eq (S T : R.AtomSource a) (p : M.Point J root → ℝ) (α : Noise (n := n)) :
    S.eval p α = T.eval p α :=
  R.nodeAtom_eq_global p α S.node T.node S.portal T.portal S.kind T.kind
    (S.name_eq.trans T.name_eq.symm)

noncomputable def center (S : R.AtomSource a) : M.Point J root := R.portalAt S.node S.portal

noncomputable def intercept (S : R.AtomSource a) (p : M.Point J root → ℝ)
    (α : Noise (n := n)) : ℝ :=
  (if S.kind = 0 then p S.center else R.parentValue p α S.depth S.node S.center) +
    (if S.kind = 1 then -α S.depth S.center.column S.kind else α S.depth S.center.column S.kind)

noncomputable def sign (S : R.AtomSource a) : ℝ := if S.kind = 2 then -1 else 1

lemma sign_unit (S : R.AtomSource a) : |S.sign| = 1 := by
  unfold sign
  split_ifs <;> norm_num

lemma eval_formula (S : R.AtomSource a) (p : M.Point J root → ℝ)
    (α : Noise (n := n)) (x : M.Point J root) :
    (S.eval p α x).value = S.intercept p α+S.sign*dist S.center x := by
  simp only [eval,nodeAtom,atomIntercept,intercept,sign,center]
  split_ifs <;> ring

/-- Convert back to the old ordinary orientation, as in /main-packing.
The -4E proposal shift is part of the literal atom constant. -/
noncomputable def chart (S : R.AtomSource a) (D : OrdinaryData M)
    (p : M.Point J root → ℝ) (α : Noise (n := n)) (E : ℝ) : OrdinaryData M :=
  D.atom J R.closed_band R.interval_band S.center (S.intercept p α-4*E) S.sign S.sign_unit

lemma chart_value (S : R.AtomSource a) (D : OrdinaryData M)
    (p : M.Point J root → ℝ) (α : Noise (n := n)) (E : ℝ) (x : M.Point J root) :
    (S.chart D p α E).value x.column ⟨x.height,x.inBand⟩ =
      D.constant+D.orientation*((S.eval p α x).value-4*E) := by
  calc _ = D.constant+D.orientation*((S.intercept p α-4*E)+S.sign*dist S.center x) :=
         OrdinaryData.atom_value D J R.closed_band R.interval_band S.center x _ _ _
       _ = _ := by rw [S.eval_formula]; ring

end AtomSource

/-- A finite globally consistent chart table for every possible spatial atom.
Unused identifiers get a constant chart and can never be selected by pasted. -/
noncomputable def atomChart (D : OrdinaryData M) (p : M.Point J root → ℝ)
    (α : Noise (n := n)) (E : ℝ) (a : ℕ) : OrdinaryData M := by
  classical
  exact if h : Nonempty (R.AtomSource a) then h.some.chart D p α E else OrdinaryData.initial M

lemma source_eval_pasted (p : M.Point J root → ℝ) (α : Noise (n := n))
    (x : M.Point J root) (S : R.AtomSource (R.pasted p α x).name) :
    S.eval p α x = R.pasted p α x := by
  obtain ⟨k,hk,i,t,he⟩ := R.formula_eq_atom p α (R.layerDepth x) (R.layerNode x) x
  have hn : atomName k (R.portalAt (R.ancestor (R.layerNode x) k hk) i) t =
      (R.pasted p α x).name := (congrArg NamedValue.name he).symm
  have hsame := R.nodeAtom_eq_global p α S.node (R.ancestor (R.layerNode x) k hk)
    S.portal i S.kind t (S.name_eq.trans hn.symm)
  exact (congrFun hsame x).trans he.symm

lemma atomChart_value (D : OrdinaryData M) (p : M.Point J root → ℝ)
    (α : Noise (n := n)) (E : ℝ) (x : M.Point J root) :
    ∃ h : x.height ∈ (R.atomChart D p α E (R.pasted p α x).name).band,
      (R.atomChart D p α E (R.pasted p α x).name).value x.column ⟨x.height,h⟩ =
        D.constant+D.orientation*((R.pasted p α x).value-4*E) := by
  have h := R.pasted_has_source p α x
  let Q : OrdinaryData M → Prop := fun T => ∃ hi : x.height ∈ T.band,
    T.value x.column ⟨x.height,hi⟩ =
      D.constant+D.orientation*((R.pasted p α x).value-4*E)
  change Q (R.atomChart D p α E (R.pasted p α x).name)
  have he : R.atomChart D p α E (R.pasted p α x).name = h.some.chart D p α E := dite_eq_left h
  rw [he]
  exact ⟨x.inBand,(AtomSource.chart_value h.some D p α E x).trans
    (by rw [R.source_eval_pasted])⟩

end PlanarL1.Columns.Model.Point.RadialTree


namespace PlanarL1.Columns.Model
open MeasureTheory
namespace OrdinaryState
variable {n : ℕ} {M : Model n} {κ : ℝ} {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω}

/-- Finite chart-table extension. Old identifiers are literally retained in the
right summand; installing a fresh chart never refines the old regions. -/
noncomputable def append (S : OrdinaryState M κ Ω μ) (B : SetSystem M Ω μ)
    (k : ℕ) (D : Fin k → OrdinaryData M) (Z : Fin k → Threshold.Variables Ω μ)
    (choose : Fin n → ℝ → Option (Fin k))
    (hin : ∀ i H a, choose i H = some a → H ∈ (D a).band)
    (hcomp : ∀ i H a (_hc : choose i H = some a) r o,
      (D a).origin = some ⟨r,o⟩ → (M.activeGraph (D a).band).Reachable r i)
    (hswitch : ∀ i j H, H ∈ M.heights i j → choose i H = choose j H)
    (hold : ∀ ω i H, choose i H = none →
      ((B.activity ω).active i H ↔ (S.sets.activity ω).active i H))
    (hnew : ∀ ω i H a (hc : choose i H = some a),
      ((B.activity ω).active i H ↔ Threshold.active (Z a) H
        (κ*(D a).value i ⟨H,hin i H a hc⟩) ω)) : OrdinaryState M κ Ω μ where
  sets := B
  count := k+S.count
  chart := Fin.addCases (m := k) (n := S.count+1) D S.chart
  labels := Fin.addCases (m := k) (n := S.count+1) Z S.labels
  name i H := match choose i H with
    | none => Fin.natAdd k (S.name i H)
    | some a => Fin.castAdd (S.count+1) a
  height_in i H := by
    cases hc : choose i H with
    | none => simpa only [hc,Fin.addCases_right] using S.height_in i H
    | some a => simpa only [hc,Fin.addCases_left] using hin i H a hc
  component_in i H := by
    let Uses (D : OrdinaryData M) : Prop := ∀ r o,
      D.origin = some ⟨r,o⟩ → (M.activeGraph D.band).Reachable r i
    change Uses (Fin.addCases (m := k) (n := S.count+1) D S.chart
      (match choose i H with
      | none => Fin.natAdd k (S.name i H)
      | some a => Fin.castAdd (S.count+1) a))
    cases hc : choose i H with
    | none =>
      simp only [Fin.addCases_right]
      exact S.component_in i H
    | some a =>
      simp only [Fin.addCases_left]
      exact hcomp i H a hc
  switch_name i j H hh := by
    have hc := hswitch i j H hh
    rw [hc]
    cases choose j H with
    | none => exact congrArg (Fin.natAdd k) (S.switch_name i j H hh)
    | some a => rfl
  represents ω i H := by
    let Rep (D : OrdinaryData M) (Z : Threshold.Variables Ω μ) : Prop :=
      ∀ hi : H ∈ D.band, (B.activity ω).active i H ↔
        Threshold.active Z H (κ*D.value i ⟨H,hi⟩) ω
    have hr : Rep
        (Fin.addCases (m := k) (n := S.count+1) D S.chart
          (match choose i H with
          | none => Fin.natAdd k (S.name i H)
          | some a => Fin.castAdd (S.count+1) a))
        (Fin.addCases (m := k) (n := S.count+1) Z S.labels
          (match choose i H with
          | none => Fin.natAdd k (S.name i H)
          | some a => Fin.castAdd (S.count+1) a)) := by
      cases hc : choose i H with
      | none =>
        simp only [Fin.addCases_right]
        intro hi
        exact (hold ω i H hc).trans (S.represents ω i H)
      | some a =>
        simp only [Fin.addCases_left]
        intro hi
        exact hnew ω i H a hc
    exact hr _

end OrdinaryState
end PlanarL1.Columns.Model


end

section

namespace PlanarL1.Columns.Model.OrdinaryData
variable {n : ℕ} {M : Model n}

/-- The actual chart domain, with the connected-component requirement made
explicit. Different copies of a quotient point satisfy the same condition. -/
def Contains (D : OrdinaryData M) (i : Fin n) (H : ℝ) : Prop :=
  H ∈ D.band ∧ ∀ r o, D.origin = some ⟨r,o⟩ → (M.activeGraph D.band).Reachable r i

lemma initial_contains (i : Fin n) (H : ℝ) : (initial M).Contains i H := by
  refine ⟨Set.mem_univ _,?_⟩
  intro r o he
  cases he

lemma atom_contains (D : OrdinaryData M) (J : Set ℝ) (hJ : IsClosed J)
    (hc : J.OrdConnected) {r : Fin n} (o x : M.Point J r) (c η : ℝ) (hη : |η|=1) :
    (D.atom J hJ hc o c η hη).Contains x.column x.height := by
  refine ⟨x.inBand,?_⟩
  intro r' o' he
  have hr : r=r' := congrArg (fun z : Option (Σ r : Fin n, M.Point J r) =>
    z.map Sigma.fst) he |> Option.some.inj
  subst r'
  exact x.reachable

end PlanarL1.Columns.Model.OrdinaryData

namespace PlanarL1.Columns.Model.Point.RadialTree
open PlanarL1.Interpolation
variable {n : ℕ} {M : Model n} {J : Set ℝ} {root : Fin n}
variable (R : RadialTree (M := M) (J := J) (root := root))

lemma atomChart_contains (D : OrdinaryData M) (p : M.Point J root → ℝ)
    (α : Noise (n := n)) (E : ℝ) (x : M.Point J root) :
    (R.atomChart D p α E (R.pasted p α x).name).Contains x.column x.height := by
  have h := R.pasted_has_source p α x
  have he : R.atomChart D p α E (R.pasted p α x).name = h.some.chart D p α E := dite_eq_left h
  rw [he]
  exact OrdinaryData.atom_contains D J R.closed_band R.interval_band h.some.center x _ _ _

end PlanarL1.Columns.Model.Point.RadialTree


end

end OAI