import Mathlib
import OAI.LinearAlgebra.MatrixFields.Entropy.StageCLaw
import OAI.LinearAlgebra.MatrixFields.Parameters.JointPopulation

namespace OAI

namespace MatrixAllFields

open scoped BigOperators Topology Polynomial

namespace MatrixMultiplication.AllFieldHistory

open AllFieldParameters
open scoped BigOperators

def shapeTotal (u : Shape) : ℕ := u 0 + u 1 + u 2

def ShapeBounded (u : Shape) : Prop := ∀ i, u i ≤ 16

def encodeShape (u : Shape) (h : ShapeBounded u) : JointPopulation.Shape :=
  (⟨u 0, Nat.lt_succ_of_le (h 0)⟩,
    ⟨u 1, Nat.lt_succ_of_le (h 1)⟩, ⟨u 2, Nat.lt_succ_of_le (h 2)⟩)

def decodeShape (u : JointPopulation.Shape) : Shape :=
  fun i => (JointPopulation.shapeSide i u).val

@[simp] theorem decode_encodeShape (u : Shape) (h : ShapeBounded u) :
    decodeShape (encodeShape u h) = u := by
  funext i
  fin_cases i <;> rfl

@[simp] theorem encodeShape_side (u : Shape) (h : ShapeBounded u) (i : Fin 3) :
    (JointPopulation.shapeSide i (encodeShape u h)).val = u i :=
  congrFun (decode_encodeShape u h) i

theorem decodeShape_bounded (u : JointPopulation.Shape) : ShapeBounded (decodeShape u) := by
  intro i
  have h := (JointPopulation.shapeSide i u).isLt
  change (JointPopulation.shapeSide i u).val ≤ 16
  omega

@[simp] theorem encode_decodeShape (u : JointPopulation.Shape) :
    encodeShape (decodeShape u) (decodeShape_bounded u) = u := by
  apply Prod.ext
  · apply Fin.ext
    rfl
  · apply Prod.ext <;> apply Fin.ext <;> rfl

theorem encodeShape_inj {u v : Shape} {hu : ShapeBounded u} {hv : ShapeBounded v}
    (h : encodeShape u hu = encodeShape v hv) : u = v := by
  simpa only [decode_encodeShape] using congrArg decodeShape h

theorem encodeShape_injective :
    Function.Injective (fun u : {u : Shape // ShapeBounded u} => encodeShape u.val u.property) := by
  intro u v h
  apply Subtype.ext
  exact encodeShape_inj h

@[simp] theorem encodeShape_total (u : Shape) (h : ShapeBounded u) :
    (encodeShape u h).1.val + (encodeShape u h).2.1.val +
      (encodeShape u h).2.2.val = shapeTotal u := rfl

def physicalShape (phi : Equiv.Perm (Fin 3)) (u : Shape) : Shape :=
  fun i => u (phi.symm i)

@[simp] theorem physicalShape_source (phi : Equiv.Perm (Fin 3)) (u : Shape) (i : Fin 3) :
    physicalShape phi u (phi i) = u i := by
  simp only [physicalShape, Equiv.symm_apply_apply]

theorem physicalShape_bounded (phi : Equiv.Perm (Fin 3)) (u : Shape)
    (h : ShapeBounded u) : ShapeBounded (physicalShape phi u) :=
  fun i => h (phi.symm i)

theorem physicalShape_le (phi : Equiv.Perm (Fin 3)) {u v : Shape}
    (h : ∀ i, v i ≤ u i) : ∀ i, physicalShape phi v i ≤ physicalShape phi u i :=
  fun i => h (phi.symm i)

@[simp] theorem physicalShape_complement (phi : Equiv.Perm (Fin 3)) (u v : Shape) :
    physicalShape phi (complement u v) =
      complement (physicalShape phi u) (physicalShape phi v) := rfl

theorem physicalShape_total (phi : Equiv.Perm (Fin 3)) (u : Shape) :
    shapeTotal (physicalShape phi u) = shapeTotal u := by
  simpa [shapeTotal, physicalShape, Fin.sum_univ_succ, Nat.add_assoc] using
    (Equiv.sum_comp phi.symm u)

theorem physicalShape_injective (phi : Equiv.Perm (Fin 3)) :
    Function.Injective (physicalShape phi) := by
  intro u v h
  funext i
  simpa only [physicalShape_source] using congrFun h (phi i)

def encodePhysicalShape (phi : Equiv.Perm (Fin 3)) (u : Shape) (h : ShapeBounded u) :
    JointPopulation.Shape := encodeShape (physicalShape phi u) (physicalShape_bounded phi u h)

@[simp] theorem decode_encodePhysicalShape (phi : Equiv.Perm (Fin 3))
    (u : Shape) (h : ShapeBounded u) :
    decodeShape (encodePhysicalShape phi u h) = physicalShape phi u :=
  decode_encodeShape _ _

@[simp] theorem encodePhysicalShape_side (phi : Equiv.Perm (Fin 3))
    (u : Shape) (h : ShapeBounded u) (i : Fin 3) :
    (JointPopulation.shapeSide i (encodePhysicalShape phi u h)).val = u (phi.symm i) :=
  encodeShape_side _ _ i

theorem encodePhysicalShape_inj (phi : Equiv.Perm (Fin 3))
    {u v : Shape} {hu : ShapeBounded u} {hv : ShapeBounded v}
    (h : encodePhysicalShape phi u hu = encodePhysicalShape phi v hv) : u = v :=
  physicalShape_injective phi (encodeShape_inj h)

theorem encodePhysicalShape_total (phi : Equiv.Perm (Fin 3))
    (u : Shape) (h : ShapeBounded u) :
    (encodePhysicalShape phi u h).1.val + (encodePhysicalShape phi u h).2.1.val +
      (encodePhysicalShape phi u h).2.2.val = shapeTotal u :=
  physicalShape_total phi u

theorem mem_shapes_total {n : ℕ} {u : Shape} (hu : u ∈ shapes n) : shapeTotal u = n := by
  simp only [shapes, List.mem_flatMap, List.mem_map, List.mem_range] at hu
  obtain ⟨a, ha, b, hb, rfl⟩ := hu
  change a + b + (n - a - b) = n
  omega

theorem coordinate_le_total (u : Shape) (i : Fin 3) : u i ≤ shapeTotal u := by
  fin_cases i
  · change u 0 ≤ u 0 + u 1 + u 2
    omega
  · change u 1 ≤ u 0 + u 1 + u 2
    omega
  · change u 2 ≤ u 0 + u 1 + u 2
    omega

theorem mem_shapes_bound {n : ℕ} {u : Shape} (hu : u ∈ shapes n) (i : Fin 3) : u i ≤ n := by
  simpa only [mem_shapes_total hu] using coordinate_le_total u i

theorem mem_shapes_bounded {n : ℕ} {u : Shape} (hu : u ∈ shapes n) (hn : n ≤ 16) :
    ShapeBounded u := fun i => (mem_shapes_bound hu i).trans hn

theorem below_mem_shapes {u v : Shape} (hv : v ∈ below u) :
    v ∈ shapes (shapeTotal u / 2) := (List.mem_filter.mp hv).1

theorem below_total {u v : Shape} (hv : v ∈ below u) :
    shapeTotal v = shapeTotal u / 2 := mem_shapes_total (below_mem_shapes hv)

theorem below_le {u v : Shape} (hv : v ∈ below u) : ∀ i, v i ≤ u i := by
  have h := (List.mem_filter.mp hv).2
  have hb : v 0 ≤ u 0 ∧ v 1 ≤ u 1 ∧ v 2 ≤ u 2 := by
    simpa only [Bool.and_eq_true, decide_eq_true_eq, and_assoc] using h
  intro i
  fin_cases i
  · exact hb.1
  · exact hb.2.1
  · exact hb.2.2

theorem below_bounded {u v : Shape} (hu : ShapeBounded u) (hv : v ∈ below u) :
    ShapeBounded v := fun i => (below_le hv i).trans (hu i)

theorem complement_bounded {u v : Shape} (hu : ShapeBounded u) :
    ShapeBounded (complement u v) := fun i => (Nat.sub_le (u i) (v i)).trans (hu i)

theorem complement_total {u v : Shape} (h : ∀ i, v i ≤ u i) :
    shapeTotal (complement u v) = shapeTotal u - shapeTotal v := by
  have h0 := h 0
  have h1 := h 1
  have h2 := h 2
  simp only [shapeTotal, complement]
  omega

theorem root_shape_spec (s : Shape) (hs : s ∈ sortedInitial) :
    ShapeBounded s ∧ shapeTotal s = 16 := by
  have hm : s ∈ shapes 16 := (List.mem_filter.mp hs).1
  exact ⟨mem_shapes_bounded hm (by omega), mem_shapes_total hm⟩

theorem root_shapes_nodup : sortedInitial.Nodup := by decide +kernel

theorem stageA_below_nodup : ∀ s ∈ positiveInitial, (below s).Nodup := by
  decide +kernel

theorem stageB_below_nodup : ∀ t ∈ positiveSecond, (below t).Nodup := by
  decide +kernel

theorem stageA_get_injective (s : Shape) (hs : s ∈ positiveInitial) :
    Function.Injective (below s).get :=
  List.nodup_iff_injective_get.mp (stageA_below_nodup s hs)

theorem stageB_get_injective (t : Shape) (ht : t ∈ positiveSecond) :
    Function.Injective (below t).get :=
  List.nodup_iff_injective_get.mp (stageB_below_nodup t ht)

theorem positiveInitial_shape_spec (s : Shape) (hs : s ∈ positiveInitial) :
    ShapeBounded s ∧ shapeTotal s = 16 :=
  root_shape_spec s (List.mem_filter.mp hs).1

theorem positiveSecond_shape_spec (t : Shape) (ht : t ∈ positiveSecond) :
    ShapeBounded t ∧ shapeTotal t = 8 := by
  have hm : t ∈ shapes 8 := (List.mem_filter.mp ht).1
  exact ⟨mem_shapes_bounded hm (by omega), mem_shapes_total hm⟩

theorem stageA_shape_spec (s t : Shape) (hs : s ∈ positiveInitial) (ht : t ∈ below s) :
    ShapeBounded t ∧ shapeTotal t = 8 := by
  obtain ⟨hb, hsum⟩ := positiveInitial_shape_spec s hs
  exact ⟨below_bounded hb ht, by simpa only [hsum] using below_total ht⟩

theorem stageA_complement_spec (s t : Shape) (hs : s ∈ positiveInitial)
    (ht : t ∈ below s) : ShapeBounded (complement s t) ∧ shapeTotal (complement s t) = 8 := by
  obtain ⟨hb, hsum⟩ := positiveInitial_shape_spec s hs
  obtain ⟨_, hchild⟩ := stageA_shape_spec s t hs ht
  exact ⟨complement_bounded hb, by rw [complement_total (below_le ht), hsum, hchild]⟩

theorem stageB_shape_spec (t u : Shape) (ht : t ∈ positiveSecond) (hu : u ∈ below t) :
    ShapeBounded u ∧ shapeTotal u = 4 := by
  obtain ⟨hb, hsum⟩ := positiveSecond_shape_spec t ht
  exact ⟨below_bounded hb hu, by simpa only [hsum] using below_total hu⟩

theorem stageB_complement_spec (t u : Shape) (ht : t ∈ positiveSecond)
    (hu : u ∈ below t) : ShapeBounded (complement t u) ∧ shapeTotal (complement t u) = 4 := by
  obtain ⟨hb, hsum⟩ := positiveSecond_shape_spec t ht
  obtain ⟨_, hchild⟩ := stageB_shape_spec t u ht hu
  exact ⟨complement_bounded hb, by rw [complement_total (below_le hu), hsum, hchild]⟩

theorem stageC_shape_spec (u : Shape) (hu : u ∈ shapes 4) (hpos : positive u = true)
    (i : Fin 4) : ShapeBounded (stageCAtom u i) ∧ shapeTotal (stageCAtom u i) = 2 := by
  have hi := stageCAtom_mem u hu hpos i
  exact ⟨below_bounded (mem_shapes_bounded hu (by omega)) hi,
    by simpa only [mem_shapes_total hu] using below_total hi⟩

theorem stageC_complement_spec (u : Shape) (hu : u ∈ shapes 4) (hpos : positive u = true)
    (i : Fin 4) : ShapeBounded (complement u (stageCAtom u i)) ∧
      shapeTotal (complement u (stageCAtom u i)) = 2 := by
  have hi := stageCAtom_mem u hu hpos i
  obtain ⟨_, hchild⟩ := stageC_shape_spec u hu hpos i
  exact ⟨complement_bounded (mem_shapes_bounded hu (by omega)),
    by rw [complement_total (below_le hi), mem_shapes_total hu, hchild]⟩

end MatrixMultiplication.AllFieldHistory

end MatrixAllFields

end OAI