import OAI.LinearAlgebra.MatrixMultiplication.FieldGroups.PairWindows
import OAI.LinearAlgebra.MatrixMultiplication.JointExtraction.ConditionalCountEntropy

namespace OAI

/-! Group assignments, orbit counts and extraction capacities. -/

noncomputable section

namespace MatrixMultiplication.AllFieldGroupPairEntropy

open MatrixMultiplication.Foundation AllFieldParameters AllFieldHistory AllFieldActiveLaws
open AllFieldActiveCapacity AllFieldHistoryChildLaws AllFieldGroupOrbitData
open AllFieldGroupDegrees AllFieldGroupNativeLaws AllFieldGroupPairWindows
open JointCompatibilityScaling JointCompatibilityRateLimit JointPairClassWindows
open scoped BigOperators
attribute [local instance] Classical.propDecidable Classical.decEq

theorem sum_conditionalCenter_entropy {A B : Type*} [Fintype A] [Fintype B]
    [DecidableEq B] (p : FiniteLaw A) (f : A → B) :
    (∑ b, (p.map f).mass b * finiteEntropy
      (conditionalCenter f b p.mass ((p.map f).mass b))) =
        finiteEntropy p.mass - finiteEntropy (p.map f).mass := by
  have ht (b : B) :
      (p.map f).mass b * finiteEntropy
        (conditionalCenter f b p.mass ((p.map f).mass b)) =
      (p.map f).mass b * finiteEntropy (p.conditional f b).mass := by
    by_cases hz : (p.map f).mass b = 0
    · simp only [hz, zero_mul]
    · congr 1
      congr 1
      funext a
      simp only [conditionalCenter, FiniteLaw.conditional, dite_eq_right hz]
      split_ifs <;> simp
  simp_rw [ht]
  have he := p.entropy_eq_map_add_conditional f
  linarith

variable {K tick : ℕ} {sigma : Placement}

theorem baseSize_eq_parentBase_mul_sideMass (allocation : Allocation)
    (sigma : Placement) (side : Fin 3) (h : ActiveOrder K tick sigma) (k : Fin 17) :
    (baseSize (base allocation sigma side) (h, k) : ℝ) =
      (parentBase allocation h : ℝ) *
        JointPopulationRates.sideMass (orderLaw h).mass (sigma side) k := by
  simp only [baseSize, base, JointPopulationCompatibility.classCounts,
    Nat.cast_sum, Nat.cast_ite, Nat.cast_zero, JointPopulationRates.sideMass,
    Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro u _
  by_cases hu : JointPopulation.shapeSide (sigma side) u = k
  · simp only [hu, ite_true]
    exact jointCounts_cast allocation 1 h.val.val u
  · simp only [hu, ite_false, mul_zero]

theorem classMass_eq_sideMass (allocation : Allocation) (sigma : Placement)
    (side : Fin 3) (c : Class (K := K) (tick := tick) sigma) :
    classMass allocation sigma side c =
      JointPopulationRates.sideMass (orderLaw c.1).mass (sigma side) c.2 := by
  rcases c with ⟨h, k⟩
  unfold classMass
  rw [baseSize_eq_parentBase_mul_sideMass]
  exact mul_div_cancel_left₀ _ (by exact_mod_cast (parentBase_pos allocation h).ne')

theorem nativePair_weight_marginal {K : ℕ} (w : Work K) (side : Fin 3)
    (hs : w.stage ≠ 2) :
    ((nativePairLaw w side).map (fun a => weightCode w a.1)).mass =
      canonicalSideMass w side := by
  cases w with
  | stageA h =>
      rw [canonicalSideMass_stageA]
      exact congrArg FiniteLaw.mass
        (AllFieldPairMarginals.stageAPairLaw_leftWeight_marginal _ h.property side)
  | stageB h =>
      rw [canonicalSideMass_stageB]
      exact congrArg FiniteLaw.mass
        (AllFieldPairMarginals.stageBPairLaw_leftWeight_marginal _ h.property side)
  | stageC h => exact False.elim (hs rfl)

theorem orderPair_weight_marginal (h : ActiveOrder K tick sigma) (side : Fin 3)
    (hs : h.val.val.1.stage ≠ 2) :
    ((nativePairLaw h.val.val.1 (h.val.val.1.priority side)).map
      (fun a => weightCode h.val.val.1 a.1)).mass =
      JointPopulationRates.sideMass (orderLaw h).mass (sigma side) := by
  rw [nativePair_weight_marginal _ _ hs]
  have hm := placedLaw_priority_sideMass h.val.val side
  rw [h.property] at hm
  exact hm.symm

theorem q_eq_native_conditionalCenter (allocation : Allocation) (sigma : Placement)
    (side : Fin 3) (c : Class (K := K) (tick := tick) sigma)
    (hs : c.1.val.val.1.stage ≠ 2) :
    q allocation sigma side c = conditionalCenter
      (fun a => weightCode c.1.val.val.1 a.1) c.2
      (nativePairLaw c.1.val.val.1 (c.1.val.val.1.priority side)).mass
      (((nativePairLaw c.1.val.val.1 (c.1.val.val.1.priority side)).map
        (fun a => weightCode c.1.val.val.1 a.1)).mass c.2) := by
  rw [q_eq_conditionalCenter allocation sigma side c hs, classMass_eq_sideMass,
    orderPair_weight_marginal _ _ hs]
  have hp : parentPair allocation sigma side c.1 =
      (nativePairLaw c.1.val.val.1 (c.1.val.val.1.priority side)).mass := by
    funext a
    rw [parentPair_eq_native, orderPairMixture_eq_native]
  rw [hp]

theorem history_pair_entropy_of_sharing (allocation : Allocation) (sigma : Placement)
    (side : Fin 3) (h : ActiveOrder K tick sigma) (hs : h.val.val.1.stage ≠ 2) :
    (∑ k : Fin 17, (baseSize (base allocation sigma side) (h, k) : ℝ) *
      finiteEntropy (q allocation sigma side (h, k))) =
      (parentBase allocation h : ℝ) *
        (finiteEntropy (nativePairLaw h.val.val.1 (h.val.val.1.priority side)).mass -
          finiteEntropy (JointPopulationRates.sideMass (orderLaw h).mass (sigma side))) := by
  have hq (k : Fin 17) := q_eq_native_conditionalCenter allocation sigma side (h, k) hs
  simp_rw [baseSize_eq_parentBase_mul_sideMass, hq, mul_assoc]
  rw [← Finset.mul_sum]
  simpa only [orderPair_weight_marginal h side hs] using
    congrArg (fun x : ℝ => (parentBase allocation h : ℝ) * x)
      (sum_conditionalCenter_entropy
        (nativePairLaw h.val.val.1 (h.val.val.1.priority side))
        (fun a => weightCode h.val.val.1 a.1))

theorem history_pair_entropy_of_ordinary (allocation : Allocation) (sigma : Placement)
    (side : Fin 3) (h : ActiveOrder K tick sigma) (hs : h.val.val.1.stage = 2) :
    (∑ k : Fin 17, (baseSize (base allocation sigma side) (h, k) : ℝ) *
      finiteEntropy (q allocation sigma side (h, k))) = 0 := by
  have : Subsingleton (Statistic h.val) := by
    change Subsingleton h.val.val.1.Statistic
    cases he : h.val.val.1 with
    | stageA a => simp [he, Work.stage] at hs
    | stageB a => simp [he, Work.stage] at hs
    | stageC a => dsimp [Work.Statistic]; infer_instance
  apply Finset.sum_eq_zero
  intro k _
  by_cases hz : baseSize (base allocation sigma side) (h, k) = 0
  · simp only [hz, Nat.cast_zero, zero_mul]
  · have hq : q allocation sigma side (h, k) = fun _ => 1 := by
      funext a
      exact q_eq_one_of_subsingleton allocation sigma side (h, k)
        (Nat.pos_of_ne_zero hz) a
    simp only [hq, finiteEntropy, entropyTerm, Real.log_one, mul_zero,
      Finset.sum_const_zero]

theorem pairReferenceEntropy_eq (allocation : Allocation) (sigma : Placement)
    (side : Fin 3) :
    pairReferenceEntropy (base (K := K) (tick := tick) allocation sigma side)
      (q allocation sigma side) =
      ∑ h : ActiveOrder K tick sigma, (parentBase allocation h : ℝ) *
        (if h.val.val.1.stage ≠ 2 then
          finiteEntropy (nativePairLaw h.val.val.1 (h.val.val.1.priority side)).mass -
            finiteEntropy (JointPopulationRates.sideMass (orderLaw h).mass (sigma side))
        else 0) := by
  unfold pairReferenceEntropy
  rw [Fintype.sum_prod_type]
  apply Finset.sum_congr rfl
  intro h _
  by_cases hs : h.val.val.1.stage ≠ 2
  · rw [ite_eq_left hs]
    exact history_pair_entropy_of_sharing allocation sigma side h hs
  · rw [ite_eq_right hs, mul_zero]
    exact history_pair_entropy_of_ordinary allocation sigma side h (not_not.mp hs)

theorem baseEntropy_eq (allocation : Allocation) (sigma : Placement) (side : Fin 3) :
    baseEntropy (base (K := K) (tick := tick) allocation sigma side) =
      ∑ h : ActiveOrder K tick sigma, (parentBase allocation h : ℝ) *
        (finiteEntropy (orderLaw h).mass -
          finiteEntropy (JointPopulationRates.sideMass (orderLaw h).mass (sigma side))) := by
  unfold baseEntropy
  rw [Fintype.sum_prod_type]
  apply Finset.sum_congr rfl
  intro h _
  have hb (k : Fin 17) : base allocation sigma side (h, k) =
      JointConditionalCountEntropy.classCounts (Counts allocation 1 sigma h)
        (JointPopulation.shapeSide (sigma side)) k := by
    funext u
    by_cases hu : JointPopulation.shapeSide (sigma side) u = k
    · simp only [base, JointPopulationCompatibility.classCounts,
        JointConditionalCountEntropy.classCounts, hu, ite_true]
    · simp only [base, JointPopulationCompatibility.classCounts,
        JointConditionalCountEntropy.classCounts, hu, ite_false]
  have hs (k : Fin 17) : baseSize (base allocation sigma side) (h, k) =
      JointConditionalCountEntropy.classSize (Counts allocation 1 sigma h)
        (JointPopulation.shapeSide (sigma side)) k := by
    simp only [baseSize, JointConditionalCountEntropy.classSize, hb k]
  have hm : ((orderLaw h).map (JointPopulation.shapeSide (sigma side))).mass =
      JointPopulationRates.sideMass (orderLaw h).mass (sigma side) := by
    funext k
    rw [FiniteLaw.map_mass]
    rfl
  have he := JointConditionalCountEntropy.sum_classSize_mul_entropy_of_law
    (Counts allocation 1 sigma h) (JointPopulation.shapeSide (sigma side))
    (orderLaw h) (parentBase allocation h : ℝ)
    (fun u => jointCounts_cast allocation 1 h.val.val u)
  rw [hm] at he
  simpa only [hs, hb] using he

def observedEntropy (h : ActiveOrder K tick sigma) (side : Fin 3) : ℝ :=
  if h.val.val.1.stage ≠ 2 then
    finiteEntropy (nativePairLaw h.val.val.1 (h.val.val.1.priority side)).mass
  else finiteEntropy (JointPopulationRates.sideMass (orderLaw h).mass (sigma side))

theorem baseEntropy_sub_pairReferenceEntropy (allocation : Allocation)
    (sigma : Placement) (side : Fin 3) :
    baseEntropy (base (K := K) (tick := tick) allocation sigma side) -
      pairReferenceEntropy (base (K := K) (tick := tick) allocation sigma side)
        (q allocation sigma side) =
      ∑ h : ActiveOrder K tick sigma, (parentBase allocation h : ℝ) *
        (finiteEntropy (orderLaw h).mass - observedEntropy h side) := by
  rw [baseEntropy_eq, pairReferenceEntropy_eq, ← Finset.sum_sub_distrib]
  apply Finset.sum_congr rfl
  intro h _
  unfold observedEntropy
  split_ifs <;> ring

end MatrixMultiplication.AllFieldGroupPairEntropy

end

end OAI