import Mathlib
import OAI.LinearAlgebra.MatrixFields.Entropy.InitialLeafRates

namespace OAI

namespace MatrixAllFields

open scoped BigOperators Topology Polynomial

noncomputable section

namespace MatrixMultiplication.AllFieldNativeCapacity

open MatrixMultiplication.Foundation AllFieldParameters AllFieldHistory
open scoped BigOperators
attribute [local instance] Classical.propDecidable Classical.decEq

variable {A : Type*} [Fintype A]

def marginal (support : List Shape) (p : Shape → ℝ) (side : Fin 3)
    (k : Fin 17) : ℝ :=
  (support.map fun u => if u side = k.val then p u else 0).sum

def pairLaw (support : List Shape) (s : Shape) (p : Shape → ℝ)
    (q : Shape → A → ℝ) (ij : A × A) : ℝ :=
  (support.map fun u => p u * q u ij.1 * q (complement s u) ij.2).sum

def designated (priority : Placement) (position : Fin 3) (u : Shape) : Prop :=
  if position = 1 then u (priority 2) = 0
  else u (priority 0) = 0 ∨ u (priority 1) = 0

def singletonEntropy (support : List Shape) (p : Shape → ℝ)
    (priority : Placement) (position : Fin 3) (q : Shape → A → ℝ) : ℝ :=
  (support.map fun u => if designated priority position u then
    p u * homogeneousEntropy (q u) else 0).sum

def residualLaw (support : List Shape) (p : Shape → ℝ)
    (priority : Placement) (position : Fin 3) (q : Shape → A → ℝ)
    (k : Fin 17) (a : A) : ℝ :=
  (support.map fun u =>
    if ¬ designated priority position u ∧ u (priority position) = k.val
    then p u * q u a else 0).sum

def groupedEntropy (support : List Shape) (p : Shape → ℝ)
    (priority : Placement) (position : Fin 3) (q : Shape → A → ℝ) : ℝ :=
  singletonEntropy support p priority position q +
    ∑ k : Fin 17, homogeneousEntropy (residualLaw support p priority position q k)

def nativeCapacity (support : List Shape) (s : Shape) (p : Shape → ℝ)
    (priority : Placement) (q : Shape → Fin 3 → A → ℝ) : Staggering.Capacity :=
  fun i => if i = 0 then homogeneousEntropy (marginal support p (priority 0))
    else homogeneousEntropy (pairLaw support s p (fun u => q u (priority i))) -
      2 * groupedEntropy support p priority i (fun u => q u (priority i))

@[simp] theorem nativeCapacity_first (support : List Shape) (s : Shape)
    (p : Shape → ℝ) (priority : Placement) (q : Shape → Fin 3 → A → ℝ) :
    nativeCapacity support s p priority q 0 =
      homogeneousEntropy (marginal support p (priority 0)) := by
  simp [nativeCapacity]

theorem nativeCapacity_sharing (support : List Shape) (s : Shape)
    (p : Shape → ℝ) (priority : Placement) (q : Shape → Fin 3 → A → ℝ)
    (i : Fin 3) (hi : i ≠ 0) :
    nativeCapacity support s p priority q i =
      homogeneousEntropy (pairLaw support s p (fun u => q u (priority i))) -
        2 * groupedEntropy support p priority i (fun u => q u (priority i)) := by
  simp only [nativeCapacity, ite_eq_right hi]

theorem residual_entropy_eq_mass_mul (support : List Shape) (p : Shape → ℝ)
    (priority : Placement) (position : Fin 3) (q : Shape → A → ℝ) (k : Fin 17)
    (hm : ∑ a, residualLaw support p priority position q k a ≠ 0) :
    homogeneousEntropy (residualLaw support p priority position q k) =
      (∑ a, residualLaw support p priority position q k a) *
        finiteEntropy (fun a => residualLaw support p priority position q k a /
          ∑ b, residualLaw support p priority position q k b) :=
  homogeneousEntropy_eq_mass_mul _ hm

def stageACapacity (g : Shape) : Staggering.Capacity :=
  nativeCapacity (below g) g (fun u => (stageALaw g u : ℝ))
    (Equiv.refl (Fin 3)) (fun u w a => (halfLaw u w a : ℝ))

def stageBCapacity (t : Shape) : Staggering.Capacity :=
  nativeCapacity (below t) t (fun u => (stageBLaw t u : ℝ))
    (stageBPriority t) (fun u w a => (littleLaw t u w a : ℝ))

def stageCCapacity (t u : Shape) (part : Fin 3) : Staggering.Capacity :=
  fun i => if i = part then binaryEntropyRate (binaryParameter t u) else Real.log 2

def nativeLA : Staggering.Capacity := fun i =>
  (positiveInitial.map fun g => (initialLaw g : ℝ) * stageACapacity g i).sum

def nativeLB : Staggering.Capacity := fun i =>
  (positiveSecond.map fun t => (secondMass t : ℝ) * stageBCapacity t i).sum

def interiorPairs : List (Shape × Shape) :=
  positiveSecond.flatMap fun t =>
    ((below t).filter positive).map fun u => (t, u)

def interiorMass (tu : Shape × Shape) : ℝ := littleMass tu.1 tu.2

def interiorEntropy (tu : Shape × Shape) : ℝ :=
  binaryEntropyRate (binaryParameter tu.1 tu.2)

def nativeT : ℝ := (interiorPairs.map interiorMass).sum

def nativeB : ℝ :=
  (interiorPairs.map fun tu => interiorMass tu *
    (2 * Real.log 2 + interiorEntropy tu)).sum / 3

def nativeHigh : ℝ := nativeT * Real.log 2

def nativeCstar : ℝ := Staggering.totalCapacity nativeLA nativeLB nativeB

def nativeLambda : Fin 3 → ℝ :=
  Staggering.balanceFraction nativeLA nativeLB nativeHigh nativeB

def nativeLC (allocation : Fin 3 → ℝ) : Staggering.Capacity := fun i =>
  (interiorPairs.map fun tu => interiorMass tu *
    ((1 - allocation i) * Real.log 2 + allocation i * interiorEntropy tu)).sum

theorem nativeLC_expansion (allocation : Fin 3 → ℝ) (i : Fin 3) :
    nativeLC allocation i = nativeHigh - 3 * allocation i * (nativeHigh - nativeB) := by
  unfold nativeLC nativeHigh nativeT nativeB
  have h : ∀ xs : List (Shape × Shape),
      (xs.map fun tu => interiorMass tu *
        ((1 - allocation i) * Real.log 2 + allocation i * interiorEntropy tu)).sum =
      (xs.map interiorMass).sum * Real.log 2 - 3 * allocation i *
        ((xs.map interiorMass).sum * Real.log 2 -
          (xs.map fun tu => interiorMass tu *
            (2 * Real.log 2 + interiorEntropy tu)).sum / 3) := by
    intro xs
    induction xs with
    | nil => simp
    | cons tu xs ih => simp only [List.map_cons, List.sum_cons]; rw [ih]; ring
  exact h interiorPairs

theorem nativeLC_balanced (hgap : nativeB < nativeHigh) (i : Fin 3) :
    nativeLC nativeLambda i = nativeCstar - (nativeLA i + nativeLB i) := by
  rw [nativeLC_expansion]
  exact Staggering.thirdCapacity_eq nativeLA nativeLB nativeHigh nativeB hgap i

theorem native_balanced (hgap : nativeB < nativeHigh) (i : Fin 3) :
    nativeLA i + nativeLB i + nativeLC nativeLambda i = nativeCstar := by
  rw [nativeLC_balanced hgap]
  ring

def nativeBeta : ℝ :=
  Staggering.boundaryDeficit nativeLA nativeLB (nativeLC nativeLambda) nativeCstar

theorem nativeBeta_nonnegative (hgap : nativeB < nativeHigh) : 0 ≤ nativeBeta :=
  Staggering.boundaryDeficit_nonneg _ _ _ _ (native_balanced hgap)

end MatrixMultiplication.AllFieldNativeCapacity

end

end MatrixAllFields

end OAI