lean/OAI/LinearAlgebra/MatrixFields/Entropy/ParametersHalfLaws.lean

import Mathlib
import OAI.LinearAlgebra.MatrixFields.Parameters.ComplementSums
import OAI.LinearAlgebra.MatrixFields.Parameters.ParametersCompatibility

namespace OAI

namespace MatrixAllFields

open scoped BigOperators Topology Polynomial

namespace MatrixMultiplication.AllFieldParameters

open scoped BigOperators

theorem stageBLaw_nonnegative (t u : Shape) : 0 ≤ stageBLaw t u := by
  by_cases hu : u ∈ below t
  · exact (stageBLaw_positive t u hu).le
  · simp [stageBLaw, splitLaw, hu]

theorem orderedPairs_mem_iff (t : Shape) (i j : Fin 6) :
    (i,j) ∈ orderedPairs t ↔ statisticWeight i + statisticWeight j = shapeMax t := by
  constructor
  · exact orderedPairs_support t (i,j)
  · intro h
    apply List.mem_flatMap.mpr
    refine ⟨i, by simp, ?_⟩
    apply List.mem_filterMap.mpr
    exact ⟨j, by simp, by simp [h]⟩

theorem zeroPairLaw_nonnegative (t : Shape) (i j : Fin 6) : 0 ≤ zeroPairLaw t i j := by
  unfold zeroPairLaw
  split_ifs
  · exact div_nonneg (orderedPairWeight_positive t i j).le
      (list_sum_map_nonnegative _ _ (fun ij _ => (orderedPairWeight_positive t ij.1 ij.2).le))
  · exact le_rfl

theorem zeroPairLaw_full_normalized (t : Shape) (ht : t ∈ zeroSecond) :
    ∑ ij : PairSlot, zeroPairLaw t ij.1 ij.2 = 1 := by
  calc
    _ = ∑ ij ∈ (orderedPairs t).toFinset, zeroPairLaw t ij.1 ij.2 := by
      symm
      apply Finset.sum_subset (Finset.subset_univ _)
      intro ij _ hij
      have hs : statisticWeight ij.1 + statisticWeight ij.2 ≠ shapeMax t := by
        intro h
        exact hij (List.mem_toFinset.mpr ((orderedPairs_mem_iff t ij.1 ij.2).mpr h))
      simp [zeroPairLaw, hs]
    _ = ((orderedPairs t).map (fun ij => zeroPairLaw t ij.1 ij.2)).sum :=
      List.sum_toFinset _ (ordered_pairs_nodup t ht)
    _ = 1 := zeroPairLaw_normalized t ht

def positiveHalfLaw (t : Shape) (w : Fin 3) (ij : PairSlot) : ℚ :=
  ((below t).map fun u => stageBLaw t u * littleLaw t u w ij.1 *
    littleLaw t (complement t u) w ij.2).sum

theorem positiveHalfLaw_nonnegative (t : Shape) (w : Fin 3) (ij : PairSlot) :
    0 ≤ positiveHalfLaw t w ij := by
  apply list_sum_map_nonnegative
  intro u _
  exact mul_nonneg (mul_nonneg (stageBLaw_nonnegative t u)
    (littleLaw_nonnegative t u w ij.1))
    (littleLaw_nonnegative t (complement t u) w ij.2)

theorem sum_pair_mixture {A : Type*} (xs : List A) (mass : A → ℚ)
    (left right : A → Fin 6 → ℚ)
    (hl : ∀ x ∈ xs, ∑ i, left x i = 1)
    (hr : ∀ x ∈ xs, ∑ i, right x i = 1) :
    (∑ ij : PairSlot, (xs.map fun x => mass x * left x ij.1 * right x ij.2).sum) =
      (xs.map mass).sum := by
  induction xs with
  | nil => simp
  | cons x xs ih =>
    have hleft := hl x (by simp)
    have hright := hr x (by simp)
    have hhead : (∑ ij : PairSlot, mass x * left x ij.1 * right x ij.2) = mass x := by
      simp [Fintype.sum_prod_type, ← Finset.mul_sum, hleft, hright]
    have htail := ih (fun y hy => hl y (by simp [hy])) (fun y hy => hr y (by simp [hy]))
    simpa only [List.map_cons, List.sum_cons, Finset.sum_add_distrib, hhead] using
      congrArg (fun q : ℚ => mass x + q) htail

theorem positiveHalfLaw_normalized (t : Shape) (ht : t ∈ positiveSecond) (w : Fin 3) :
    ∑ ij : PairSlot, positiveHalfLaw t w ij = 1 := by
  unfold positiveHalfLaw
  rw [sum_pair_mixture _ _ _ _ (fun u _ => littleLaw_normalized t u w)
    (fun u _ => littleLaw_normalized t (complement t u) w)]
  exact stageBLaw_normalized t ht

theorem stageB_complement_permutation : ∀ t ∈ positiveSecond,
    ((below t).map (complement t)).Perm (below t) := by decide +kernel

theorem stageB_complement_involution (t : Shape) (ht : t ∈ positiveSecond)
    (u : Shape) (hu : u ∈ below t) : complement t (complement t u) = u := by
  funext w
  exact Nat.sub_sub_self ((stageB_support_complement t ht u hu).2 w)

theorem positiveHalfLaw_swap (t : Shape) (ht : t ∈ positiveSecond)
    (w : Fin 3) (i j : Fin 6) : positiveHalfLaw t w (i,j) = positiveHalfLaw t w (j,i) := by
  let f := fun u => stageBLaw t u * littleLaw t u w i * littleLaw t (complement t u) w j
  let g := fun u => stageBLaw t u * littleLaw t u w j * littleLaw t (complement t u) w i
  have hp := (stageB_complement_permutation t ht).map f
  have hm : ((below t).map (complement t)).map f = (below t).map g := by
    rw [List.map_map]
    apply List.map_congr_left
    intro u hu
    dsimp only [Function.comp_def, f, g]
    rw [stageBLaw_complement t u ht hu, stageB_complement_involution t ht u hu]
    ring
  change ((below t).map f).sum = ((below t).map g).sum
  rw [← hp.sum_eq, hm]

def halfMaxAxis (t : Shape) : Fin 3 :=
  (([0,1,2] : List (Fin 3)).find? (fun w => t w == shapeMax t)).getD 0

def halfLaw (t : Shape) (w : Fin 3) (ij : PairSlot) : ℚ :=
  if positive t then positiveHalfLaw t w ij
  else if t w = 0 then if ij = (0,0) then 1 else 0
  else if w = halfMaxAxis t then zeroPairLaw t ij.1 ij.2
  else zeroPairLaw t (kappa ij.1) (kappa ij.2)

theorem halfLaw_positive_parent (t : Shape) (ht : t ∈ positiveSecond)
    (w : Fin 3) (ij : PairSlot) : halfLaw t w ij = positiveHalfLaw t w ij := by
  have hp : positive t = true := (List.mem_filter.mp ht).2
  simp [halfLaw, hp]

theorem halfLaw_swap (t : Shape) (ht : t ∈ shapes 8) (w : Fin 3) (i j : Fin 6) :
    halfLaw t w (i,j) = halfLaw t w (j,i) := by
  by_cases hp : positive t = true
  · simp only [halfLaw, hp, ite_true]
    exact positiveHalfLaw_swap t (List.mem_filter.mpr ⟨ht, hp⟩) w i j
  · unfold halfLaw
    simp only [hp, Bool.false_eq_true, ite_false]
    by_cases hw : t w = 0
    · simp [hw, Prod.mk.injEq, and_comm]
    · simp only [hw, ite_false]
      by_cases hm : w = halfMaxAxis t
      · simpa only [hm, ite_true] using zeroPairLaw_swap t i j
      · simpa only [hm, ite_false] using zeroPairLaw_swap t (kappa i) (kappa j)

theorem halfLaw_nonnegative (t : Shape) (w : Fin 3) (ij : PairSlot) :
    0 ≤ halfLaw t w ij := by
  unfold halfLaw
  split_ifs
  · exact positiveHalfLaw_nonnegative t w ij
  · norm_num
  · exact le_rfl
  · exact zeroPairLaw_nonnegative t ij.1 ij.2
  · exact zeroPairLaw_nonnegative t (kappa ij.1) (kappa ij.2)

def kappaEquiv : Fin 6 ≃ Fin 6 where
  toFun := kappa
  invFun := kappa
  left_inv := kappa_involution
  right_inv := kappa_involution

theorem sum_pair_kappa (f : PairSlot → ℚ) :
    (∑ ij : PairSlot, f (kappa ij.1, kappa ij.2)) = ∑ ij, f ij :=
  (Equiv.prodCongr kappaEquiv kappaEquiv).sum_comp f

theorem halfLaw_normalized (t : Shape) (ht : t ∈ shapes 8) (w : Fin 3) :
    ∑ ij : PairSlot, halfLaw t w ij = 1 := by
  by_cases hp : positive t = true
  · simp only [halfLaw, hp, ite_true]
    exact positiveHalfLaw_normalized t (List.mem_filter.mpr ⟨ht, hp⟩) w
  · have hz : t ∈ zeroSecond := by simp [zeroSecond, ht, hp]
    simp only [halfLaw, hp, Bool.false_eq_true, ite_false]
    by_cases hw : t w = 0
    · simp [hw]
    · simp only [hw, ite_false]
      by_cases hm : w = halfMaxAxis t
      · simpa only [hm, ite_true] using zeroPairLaw_full_normalized t hz
      · simp only [hm, ite_false]
        rw [sum_pair_kappa (fun ij => zeroPairLaw t ij.1 ij.2)]
        exact zeroPairLaw_full_normalized t hz

theorem positiveHalfLaw_outside_support (t : Shape) (ht : t ∈ positiveSecond)
    (w : Fin 3) (ij : PairSlot)
    (h : statisticWeight ij.1 + statisticWeight ij.2 ≠ t w) :
    positiveHalfLaw t w ij = 0 := by
  unfold positiveHalfLaw
  have he : (below t).map (fun u => stageBLaw t u * littleLaw t u w ij.1 *
      littleLaw t (complement t u) w ij.2) = (below t).map (fun _ => (0 : ℚ)) := by
    apply List.map_congr_left
    intro u hu
    obtain ⟨hc, hb⟩ := stageB_support_complement t ht u hu
    by_cases hi : statisticWeight ij.1 = u w
    · have hj : statisticWeight ij.2 ≠ complement t u w := by
        intro hj
        apply h
        rw [hi, hj]
        change u w + (t w - u w) = t w
        have hw := hb w
        omega
      rw [littleLaw_outside_support t (complement t u) w
        (child_statistic_weight_bounded t ht (complement t u) hc w) ij.2 hj, mul_zero]
    · rw [littleLaw_outside_support t u w
        (child_statistic_weight_bounded t ht u hu w) ij.1 hi, mul_zero, zero_mul]
  rw [he]
  simp

theorem halfMaxAxis_spec : ∀ t ∈ shapes 8, t (halfMaxAxis t) = shapeMax t := by
  decide +kernel

theorem zero_other_axis_spec : ∀ t ∈ zeroSecond, ∀ w : Fin 3,
    t w ≠ 0 → w ≠ halfMaxAxis t → t w + shapeMax t = 8 := by decide +kernel

theorem statisticWeight_le_four (i : Fin 6) : statisticWeight i ≤ 4 := by
  revert i
  decide +kernel

theorem halfLaw_outside_support (t : Shape) (ht : t ∈ shapes 8)
    (w : Fin 3) (ij : PairSlot)
    (h : statisticWeight ij.1 + statisticWeight ij.2 ≠ t w) :
    halfLaw t w ij = 0 := by
  by_cases hp : positive t = true
  · simp only [halfLaw, hp, ite_true]
    exact positiveHalfLaw_outside_support t (List.mem_filter.mpr ⟨ht, hp⟩) w ij h
  · have hz : t ∈ zeroSecond := by simp [zeroSecond, ht, hp]
    simp only [halfLaw, hp, Bool.false_eq_true, ite_false]
    by_cases hw : t w = 0
    · have hij : ij ≠ (0,0) := by
        intro hij
        apply h
        rw [hij, hw]
        rfl
      rw [ite_eq_left hw, ite_eq_right hij]
    · simp only [hw, ite_false]
      by_cases hm : w = halfMaxAxis t
      · have hs : statisticWeight ij.1 + statisticWeight ij.2 ≠ shapeMax t := by
          simpa only [hm, halfMaxAxis_spec t ht] using h
        simp [hm, zeroPairLaw, hs]
      · have hs : statisticWeight (kappa ij.1) + statisticWeight (kappa ij.2) ≠
            shapeMax t := by
          have htotal := zero_other_axis_spec t hz w hw hm
          have hi := statisticWeight_le_four ij.1
          have hj := statisticWeight_le_four ij.2
          simp only [statisticWeight_kappa]
          omega
        simp [hm, zeroPairLaw, hs]

theorem zero_nonzero_axes_distinguished : ∀ t ∈ zeroSecond, ∀ w v : Fin 3,
    t w ≠ 0 → t v ≠ 0 → w ≠ v →
      (w = halfMaxAxis t ↔ v ≠ halfMaxAxis t) := by decide +kernel

theorem halfLaw_zero_complement (t : Shape) (ht : t ∈ zeroSecond)
    (w v : Fin 3) (hw : t w ≠ 0) (hv : t v ≠ 0) (hwv : w ≠ v) (ij : PairSlot) :
    halfLaw t w (kappa ij.1, kappa ij.2) = halfLaw t v ij := by
  have hp : positive t ≠ true := by
    have h := (List.mem_filter.mp ht).2
    simpa using h
  have hm := zero_nonzero_axes_distinguished t ht w v hw hv hwv
  by_cases ha : w = halfMaxAxis t
  · have hb : v ≠ halfMaxAxis t := hm.mp ha
    have hmax : t (halfMaxAxis t) ≠ 0 := by simpa only [ha] using hw
    simp [halfLaw, hp, hv, ha, hb, hmax]
  · have hb : v = halfMaxAxis t := by
      by_contra hne
      exact ha (hm.mpr hne)
    have hmax : t (halfMaxAxis t) ≠ 0 := by simpa only [hb] using hv
    simp [halfLaw, hp, hw, ha, hb, hmax, kappa_involution]

end MatrixMultiplication.AllFieldParameters

end MatrixAllFields

end OAI