lean/OAI/LinearAlgebra/MatrixFields/Construction/ExactStatisticWords.lean

import Mathlib
import OAI.LinearAlgebra.MatrixFields.Histories.InheritedMaskMargins
import OAI.LinearAlgebra.MatrixFields.Tensors.TerminalRelabel

namespace OAI

namespace MatrixAllFields

open scoped BigOperators Topology Polynomial

section
namespace MatrixMultiplication.LeafVolumes

open MatrixMultiplication.Foundation
open scoped BigOperators

variable {F U : Type*} [CommSemiring F] [DecidableEq U]

def zeroXMatching : Tensor F Unit U U := fun _ y z => if y = z then 1 else 0
def zeroYMatching : Tensor F U Unit U := fun x _ z => if x = z then 1 else 0
def zeroZMatching : Tensor F U U Unit := fun x y _ => if x = y then 1 else 0

theorem zeroXMatching_matrixCoefficients :
    Tensor.pullback (fun _ : Unit × Unit => ())
      (fun y : Unit × U => y.2) (fun z : U × Unit => z.1)
      (zeroXMatching (F := F) (U := U)) =
    Tensor.matrixCoefficients Unit Unit U := by
  funext x y z
  simp [Tensor.pullback, zeroXMatching, Tensor.matrixCoefficients]

theorem zeroYMatching_matrixCoefficients :
    Tensor.pullback (fun x : U × Unit => x.1)
      (fun _ : Unit × Unit => ()) (fun z : Unit × U => z.2)
      (zeroYMatching (F := F) (U := U)) =
    Tensor.matrixCoefficients U Unit Unit := by
  funext x y z
  simp [Tensor.pullback, zeroYMatching, Tensor.matrixCoefficients, eq_comm]

theorem zeroZMatching_matrixCoefficients :
    Tensor.pullback (fun x : Unit × U => x.2)
      (fun y : U × Unit => y.1) (fun _ : Unit × Unit => ())
      (zeroZMatching (F := F) (U := U)) =
    Tensor.matrixCoefficients Unit U Unit := by
  funext x y z
  simp [Tensor.pullback, zeroZMatching, Tensor.matrixCoefficients]

def complementaryMatching {V : Type*} [DecidableEq V] (e : U ≃ V) :
    Tensor F Unit U V := fun _ y z => if e y = z then 1 else 0

theorem complementaryMatching_pullback {V : Type*} [DecidableEq V] (e : U ≃ V) :
    Tensor.pullback id id e (complementaryMatching (F := F) e) =
      zeroXMatching (F := F) (U := U) := by
  funext x y z
  simp [Tensor.pullback, complementaryMatching, zeroXMatching]

theorem zeroXMatching_subtype (p : U → Prop) [DecidablePred p] :
    Tensor.pullback id (Subtype.val : {u // p u} → U) Subtype.val
      (zeroXMatching (F := F) (U := U)) =
      zeroXMatching (F := F) (U := {u // p u}) := by
  funext x y z
  simp [Tensor.pullback, zeroXMatching, Subtype.ext_iff]

theorem matchingPower_leaf {X Y Z : Type*} [DecidableEq Y]
    (T : Tensor F X Y Z) (x₀ : X) (e : Y ≃ Z)
    (hmatch : ∀ y z, T x₀ y (e z) = if y = z then 1 else 0)
    (n : ℕ) (p : (Fin n → Y) → Prop) [DecidablePred p] :
    Tensor.pullback (fun _ : Unit => fun _ : Fin n => x₀)
      (Subtype.val : {w // p w} → (Fin n → Y))
      (fun w : {w // p w} => fun i => e (w.val i)) (Tensor.power T n) =
      zeroXMatching (F := F) (U := {w // p w}) := by
  funext x y z
  simp only [Tensor.pullback, Tensor.power, hmatch, zeroXMatching,
    Fintype.prod_boole, ← funext_iff, Subtype.ext_iff]

theorem matchingPower_matrixCoefficients {X Y Z : Type*} [DecidableEq Y]
    (T : Tensor F X Y Z) (x₀ : X) (e : Y ≃ Z)
    (hmatch : ∀ y z, T x₀ y (e z) = if y = z then 1 else 0)
    (n : ℕ) (p : (Fin n → Y) → Prop) [DecidablePred p] :
    Tensor.pullback (fun _ : Unit × Unit => fun _ : Fin n => x₀)
      (fun y : Unit × {w // p w} => y.2.val)
      (fun z : {w // p w} × Unit => fun i => e (z.1.val i))
      (Tensor.power T n) =
      Tensor.matrixCoefficients Unit Unit {w // p w} := by
  have h := matchingPower_leaf T x₀ e hmatch n p
  have hp := congrArg (Tensor.pullback (fun _ : Unit × Unit => ())
    (fun y : Unit × {w // p w} => y.2)
    (fun z : {w // p w} × Unit => z.1)) h
  rw [zeroXMatching_matrixCoefficients] at hp
  exact hp

theorem rankAtMost_matchingPower_leaf {X Y Z : Type*} [DecidableEq Y]
    (T : Tensor F X Y Z) (x₀ : X) (e : Y ≃ Z)
    (hmatch : ∀ y z, T x₀ y (e z) = if y = z then 1 else 0)
    (n : ℕ) (p : (Fin n → Y) → Prop) [DecidablePred p]
    {r : ℕ} (hT : Tensor.RankAtMost (Tensor.power T n) r) :
    Tensor.RankAtMost (Tensor.matrixCoefficients (K := F) Unit Unit {w // p w}) r := by
  rw [← matchingPower_matrixCoefficients T x₀ e hmatch n p]
  exact hT.pullback _ _ _

section ExactLabeledWords

variable {A : Type*} [Fintype A] [DecidableEq A]

abbrev LabeledExactWords (counts b : A → ℕ) :=
  Σ w : ExactWords counts, ∀ i : Fin (∑ a, counts a), Fin (b (w.val i))

theorem labelings_card {I : Type*} [Fintype I] [DecidableEq I]
    (w : I → A) (b : A → ℕ) :
    Fintype.card (∀ i, Fin (b (w i))) =
      ∏ a, b a ^ wordPopulation w a := by
  classical
  simp only [Fintype.card_pi, Fintype.card_fin]
  calc
    (∏ i, b (w i)) = ∏ s : Σ a, {i // w i = a}, b s.1 := by
      rw [← (Equiv.sigmaFiberEquiv w).prod_comp (fun i => b (w i))]
      apply Finset.prod_congr rfl
      intro s _
      exact congrArg b s.2.property
    _ = ∏ a, b a ^ wordPopulation w a := by
      simp [Fintype.prod_sigma, wordPopulation]

theorem labeledExactWords_card (counts b : A → ℕ) :
    Fintype.card (LabeledExactWords counts b) =
      Nat.multinomial Finset.univ counts * ∏ a, b a ^ counts a := by
  classical
  rw [Fintype.card_sigma]
  have hcard : ∀ w : ExactWords counts,
      Fintype.card (∀ i : Fin (∑ a, counts a), Fin (b (w.val i))) =
        ∏ a, b a ^ counts a := by
    intro w
    rw [labelings_card]
    simp only [w.property]
  simp only [hcard, Finset.sum_const, Finset.card_univ, smul_eq_mul,
    exactWords_card]

theorem labeledExactWords_card_pos (counts b : A → ℕ)
    (hb : ∀ a, counts a ≠ 0 → 0 < b a) :
    0 < Fintype.card (LabeledExactWords counts b) := by
  classical
  rw [labeledExactWords_card]
  apply Nat.mul_pos (Nat.multinomial_pos Finset.univ counts)
  apply Finset.prod_pos
  intro a _
  by_cases h : counts a = 0
  · simp [h]
  · exact pow_pos (hb a h) _

end ExactLabeledWords

structure Dimensions where
  rows : ℕ
  inner : ℕ
  cols : ℕ
  deriving DecidableEq

def Dimensions.volume (d : Dimensions) : ℕ := d.rows * d.inner * d.cols

def Dimensions.product (d e : Dimensions) : Dimensions :=
  ⟨d.rows * e.rows, d.inner * e.inner, d.cols * e.cols⟩

theorem Dimensions.volume_product (d e : Dimensions) :
    (d.product e).volume = d.volume * e.volume := by
  simp only [Dimensions.product, Dimensions.volume]
  ring

def historyDimensions {C : Type*} [Fintype C] (d : C → Dimensions) : Dimensions :=
  ⟨∏ c, (d c).rows, ∏ c, (d c).inner, ∏ c, (d c).cols⟩

theorem historyDimensions_volume {C : Type*} [Fintype C] (d : C → Dimensions) :
    (historyDimensions d).volume = ∏ c, (d c).volume := by
  simp [historyDimensions, Dimensions.volume, Finset.prod_mul_distrib]

end MatrixMultiplication.LeafVolumes





noncomputable section

namespace MatrixMultiplication.ExactStatisticWords

open MatrixMultiplication.Foundation
open scoped BigOperators

variable {A U : Type*} [Fintype A] [DecidableEq A] [Fintype U] [DecidableEq U]

abbrev Words (statistic : U → A) (counts : A → ℕ) :=
  {w : Fin (∑ a, counts a) → U //
    ∀ a, wordPopulation (statistic ∘ w) a = counts a}

def statisticWord (statistic : U → A) (counts : A → ℕ)
    (w : Words statistic counts) : ExactWords counts :=
  ⟨statistic ∘ w.val, w.property⟩

omit [Fintype U] [DecidableEq U] in
theorem empiricalLaw_eq (statistic : U → A) (counts : A → ℕ)
    (w : Words statistic counts) :
    InheritedMasks.empiricalLaw (statistic ∘ w.val) =
      fun a => (counts a : ℝ) / (∑ a, counts a : ℕ) := by
  funext a
  simp only [InheritedMasks.empiricalLaw, w.property, Fintype.card_fin]

omit [Fintype U] [DecidableEq U] in
theorem typeWindow_of_counts (statistic : U → A) (counts : A → ℕ)
    (w : Words statistic counts) (ν : A → ℝ) (η : ℝ)
    (happrox : ∀ a, |(counts a : ℝ) / (∑ a, counts a : ℕ) - ν a| ≤ η) :
    InheritedMasks.typeWindow ν η (statistic ∘ w.val) := by
  intro a
  rw [empiricalLaw_eq]
  exact happrox a

omit [Fintype U] [DecidableEq U] in
theorem sum_statistic_weight (statistic : U → A) (counts q : A → ℕ)
    (w : Words statistic counts) :
    (∑ i, q (statistic (w.val i))) = ∑ a, counts a * q a := by
  let e := Equiv.sigmaFiberEquiv (statistic ∘ w.val)
  calc
    (∑ i, q (statistic (w.val i))) =
        ∑ p : (Σ a, {i // (statistic ∘ w.val) i = a}), q p.1 := by
      rw [← Equiv.sum_comp e (fun i => q (statistic (w.val i)))]
      apply Finset.sum_congr rfl
      intro p _
      exact congrArg q p.2.property
    _ = ∑ a, counts a * q a := by
      rw [Fintype.sum_sigma]
      apply Finset.sum_congr rfl
      intro a _
      simp only [Finset.sum_const, Finset.card_univ, smul_eq_mul]
      change wordPopulation (statistic ∘ w.val) a * q a = counts a * q a
      rw [w.property]

def fiberEquiv (statistic : U → A) (counts : A → ℕ) (w : ExactWords counts) :
    {v : Words statistic counts // statisticWord statistic counts v = w} ≃
      {v : Fin (∑ a, counts a) → U // ∀ i, statistic (v i) = w.val i} where
  toFun v := ⟨v.val.val, fun i => congrFun (congrArg Subtype.val v.property) i⟩
  invFun v := by
    have heq : statistic ∘ v.val = w.val := funext v.property
    let v' : Words statistic counts := ⟨v.val, fun a => by
      rw [heq]
      exact w.property a⟩
    exact ⟨v', Subtype.ext heq⟩
  left_inv v := by
    apply Subtype.ext
    apply Subtype.ext
    rfl
  right_inv v := by
    apply Subtype.ext
    rfl

omit [DecidableEq U] in
theorem card (statistic : U → A) (counts b : A → ℕ)
    (hb : ∀ a, Fintype.card {u : U // statistic u = a} = b a) :
    Fintype.card (Words statistic counts) =
      Nat.multinomial Finset.univ counts * ∏ a, b a ^ counts a := by
  classical
  have hfiber (w : ExactWords counts) :
      Fintype.card {v : Words statistic counts // statisticWord statistic counts v = w} =
        ∏ a, b a ^ counts a := by
    let e : {v : Fin (∑ a, counts a) → U // ∀ i, statistic (v i) = w.val i} ≃
        (∀ i : Fin (∑ a, counts a), {u : U // statistic u = w.val i}) :=
      { toFun := fun v i => ⟨v.val i, v.property i⟩
        invFun := fun v => ⟨fun i => (v i).val, fun i => (v i).property⟩
        left_inv := by intro v; rfl
        right_inv := by intro v; rfl }
    rw [Fintype.card_congr (fiberEquiv statistic counts w),
      Fintype.card_congr e, Fintype.card_pi]
    simp only [hb]
    have h := LeafVolumes.labelings_card w.val b
    simpa only [Fintype.card_pi, Fintype.card_fin, w.property] using h
  calc
    Fintype.card (Words statistic counts) =
        Fintype.card (Σ w : ExactWords counts,
          {v : Words statistic counts // statisticWord statistic counts v = w}) :=
      (Fintype.card_congr (Equiv.sigmaFiberEquiv (statisticWord statistic counts))).symm
    _ = Nat.multinomial Finset.univ counts * ∏ a, b a ^ counts a := by
      simp only [Fintype.card_sigma, hfiber, Finset.sum_const, Finset.card_univ,
        smul_eq_mul, exactWords_card]

omit [DecidableEq U] in
theorem card_of_supported (statistic : U → A) (counts b : A → ℕ)
    (hb : ∀ a, 0 < counts a → Fintype.card {u : U // statistic u = a} = b a) :
    Fintype.card (Words statistic counts) =
      Nat.multinomial Finset.univ counts * ∏ a, b a ^ counts a := by
  rw [card statistic counts (fun a => Fintype.card {u : U // statistic u = a})
    (fun _ => rfl)]
  congr 1
  apply Finset.prod_congr rfl
  intro a _
  by_cases ha : counts a = 0
  · simp [ha]
  · rw [hb a (Nat.pos_of_ne_zero ha)]

omit [Fintype A] [DecidableEq U] in
theorem card_fixedWeight_fiber (statistic : U → A) (weight : U → ℕ)
    (statisticWeight : A → ℕ) (hweight : ∀ u, weight u = statisticWeight (statistic u))
    (a : ℕ) (s : A) (hs : statisticWeight s = a) :
    Fintype.card {u : {u : U // weight u = a} // statistic u.val = s} =
      Fintype.card {u : U // statistic u = s} := by
  apply Fintype.card_congr
  exact
    { toFun := fun u => ⟨u.val.val, u.property⟩
      invFun := fun u => ⟨⟨u.val, by rw [hweight, u.property, hs]⟩, u.property⟩
      left_inv := by intro u; rfl
      right_inv := by intro u; rfl }

omit [DecidableEq U] in
theorem card_pos_of_supported (statistic : U → A) (counts b : A → ℕ)
    (hb : ∀ a, 0 < counts a → Fintype.card {u : U // statistic u = a} = b a)
    (hpos : ∀ a, 0 < counts a → 0 < b a) :
    0 < Fintype.card (Words statistic counts) := by
  rw [card_of_supported statistic counts b hb]
  apply Nat.mul_pos (Nat.multinomial_pos Finset.univ counts)
  apply Finset.prod_pos
  intro a _
  by_cases ha : counts a = 0
  · simp [ha]
  · exact pow_pos (hpos a (Nat.pos_of_ne_zero ha)) _

end MatrixMultiplication.ExactStatisticWords

end
end

end MatrixAllFields

end OAI