lean/OAI/LinearAlgebra/MatrixMultiplication/ComplexBounds/SquareCounts.lean

import OAI.LinearAlgebra.MatrixMultiplication.Completion.Cardinality
import OAI.LinearAlgebra.MatrixMultiplication.Completion.Termination
import OAI.LinearAlgebra.MatrixMultiplication.Tensor.BaseTensorBudgets
import OAI.LinearAlgebra.MatrixMultiplication.Entropy.ComplexEntropyContinuity

namespace OAI

/-! Explicit complex square and rectangular matrix multiplication bounds. -/

noncomputable section

namespace MatrixMultiplication.SquareCounts

open MatrixMultiplication.Foundation RecursiveCompletion CompletionLabels CompletionCardinality
open scoped BigOperators
attribute [local instance] Classical.propDecidable Classical.decEq

universe uCoord

private theorem colorBA : Color.B ≠ Color.A := by intro h; cases h
private theorem colorBC : Color.B ≠ Color.C := by intro h; cases h
private theorem colorAB : Color.A ≠ Color.B := by intro h; cases h
private theorem colorAC : Color.A ≠ Color.C := by intro h; cases h
private theorem colorCB : Color.C ≠ Color.B := by intro h; cases h
private theorem colorCA : Color.C ≠ Color.A := by intro h; cases h

attribute [local simp] colorBA colorBC colorAB colorAC colorCB colorCA

def baseLeaf (i : Fin 5) : CompletionLabels.Leaf BaseThree.flagged :=
  ⟨BaseThree.point i, by
    change BaseThree.tensor _ _ _ ≠ 0
    rw [BaseThree.point_supported]
    exact one_ne_zero⟩

def baseLeafEquiv : Fin 5 ≃ CompletionLabels.Leaf BaseThree.flagged :=
  Equiv.ofBijective baseLeaf ⟨by
    intro i j h
    exact BaseThree.point_injective (congrArg Subtype.val h), by
    intro a
    obtain ⟨i, hi⟩ := (BaseThree.support_enumeration _ _ _).mp a.property
    exact ⟨i, Subtype.ext hi⟩⟩

theorem baseLeaf_color (i : Fin 5) :
    leafColor BaseThree.flagged (baseLeaf i) = BaseThree.leafColor i := by
  fin_cases i <;>
    norm_num [leafColor, baseLeaf, BaseThree.flagged, BaseThree.flagB, BaseThree.flagA,
      BaseThree.point, BaseThree.leafColor, Fin.ext_iff]

def initialCount : Color → ℕ
  | .B => 2
  | .A => 2
  | .C => 1

theorem base_conditionalCount (c : Color) :
    conditionalCount BaseThree.flagged c = initialCount c := by
  have h := Fintype.card_congr
    (baseLeafEquiv.subtypeEquiv
      (p := fun i => BaseThree.leafColor i = c)
      (q := fun a => leafColor BaseThree.flagged a = c)
      (fun i => by change _ ↔ leafColor BaseThree.flagged (baseLeaf i) = c
                   rw [baseLeaf_color]))
  change Fintype.card {a : CompletionLabels.Leaf BaseThree.flagged //
    leafColor BaseThree.flagged a = c} = _
  rw [← h]
  simp only [Fintype.card_subtype, Finset.card_filter, Fin.sum_univ_five]
  cases c <;>
    norm_num [BaseThree.leafColor, initialCount,
      show (3 : Fin 5).val = 3 from rfl, show (4 : Fin 5).val = 4 from rfl]

def counts : Script → Color → ℕ
  | .base => initialCount
  | .step prior center m => fun c =>
      if c = center then counts prior center ^ m
      else (counts prior center + counts prior c) ^ m - counts prior center ^ m

theorem conditionalCount_script (s : Script) (c : Color) :
    conditionalCount (Script.tensor BaseThree.flagged s) c = counts s c := by
  induction s generalizing c with
  | base => exact base_conditionalCount c
  | step prior center m ih =>
      change conditionalCount (complete (Script.tensor BaseThree.flagged prior) center m) c = _
      rw [CompletionCardinality.count_complete]
      simp only [counts, ih]

def stageOne : Script := Script.step Script.base .B 2
def stageTwo : Script := stageOne.step .A 3
def stageThree : Script := stageTwo.step .C 2
def stageFour : Script := stageThree.step .B 2

theorem factors_at_every_stage :
    stageOne.factors = 2 ∧ stageTwo.factors = 6 ∧ stageThree.factors = 12 ∧
      stageFour.factors = 24 ∧ Script.square.factors = 72 := by
  norm_num [stageOne, stageTwo, stageThree, stageFour, Script.factors, Script.square]

theorem counts_after_three :
    counts stageThree .B = 20691584 ∧ counts stageThree .A = 13993344 ∧
      counts stageThree .C = 10144225 := by
  norm_num [counts, initialCount, stageThree, stageTwo, stageOne, reduceCtorEq]

theorem counts_after_four :
    counts stageFour .B = 428141648429056 ∧
      counts stageFour .A = 774902581936128 ∧
      counts stageFour .C = 522705468255425 := by
  norm_num [counts, initialCount, stageFour, stageThree, stageTwo, stageOne, reduceCtorEq]

theorem actual_counts_after_three :
    conditionalCount (Script.tensor BaseThree.flagged stageThree) .B = 20691584 ∧
    conditionalCount (Script.tensor BaseThree.flagged stageThree) .A = 13993344 ∧
    conditionalCount (Script.tensor BaseThree.flagged stageThree) .C = 10144225 := by
  simpa only [conditionalCount_script] using counts_after_three

theorem actual_counts_after_four :
    conditionalCount (Script.tensor BaseThree.flagged stageFour) .B = 428141648429056 ∧
    conditionalCount (Script.tensor BaseThree.flagged stageFour) .A = 774902581936128 ∧
    conditionalCount (Script.tensor BaseThree.flagged stageFour) .C = 522705468255425 := by
  simpa only [conditionalCount_script] using counts_after_four

def completed := Script.tensor BaseThree.flagged Script.square

theorem completion_unit_coefficients {X Y Z : Type uCoord}
    (S : FlaggedTensor X Y Z)
    (unit : ∀ x y z, S.tensor x y z ≠ 0 → S.tensor x y z = 1)
    (center : Color) (m : ℕ) (x y z)
    (supported : (complete S center m).tensor x y z ≠ 0) :
    (complete S center m).tensor x y z = 1 := by
  rw [complete_tensor] at supported ⊢
  split_ifs at supported ⊢ with h
  · apply Finset.prod_eq_one
    intro i hi
    exact unit _ _ _ ((Finset.prod_ne_zero_iff.mp supported) i hi)
  · exact False.elim (supported rfl)

theorem script_unit_coefficients (s : Script) :
    ∀ x y z, (Script.tensor BaseThree.flagged s).tensor x y z ≠ 0 →
      (Script.tensor BaseThree.flagged s).tensor x y z = 1 := by
  induction s with
  | base =>
      intro x y z hs
      obtain ⟨i, hi⟩ := (BaseThree.support_enumeration x y z).mp hs
      have hp := BaseThree.point_supported i
      simpa only [Script.tensor, BaseThree.flagged, hi] using hp
  | step prior center m ih =>
      exact completion_unit_coefficients (Script.tensor BaseThree.flagged prior)
        ih center m

def tensor := CompletionTermination.tensor completed .A

theorem tensor_unit_coefficients (x y z) (hs : tensor x y z ≠ 0) :
    tensor x y z = 1 := by
  have h := (CompletionTermination.support_iff completed .A x y z).mp hs
  rw [tensor, CompletionTermination.tensor, ite_eq_right h.2]
  exact script_unit_coefficients Script.square x y z h.1

abbrev Leaf := CompletionTermination.Leaf completed .A

def retainedLeafEquiv : Leaf ≃ RetainedLeaf completed .B .C :=
  CompletionTermination.retainedLeafEquiv completed .A .B .C
    (by intro c; cases c <;> simp)

@[simp] theorem retainedLeafEquiv_coordinates (a : Leaf) :
    (retainedLeafEquiv a).val.val = a.val := rfl

def leafCount : ℕ := 2995461856366867388223311649574852466276480577

theorem leafCount_pos : 0 < leafCount := by norm_num [leafCount]

theorem card_termination_A {X Y Z : Type uCoord} [Fintype X] [Fintype Y] [Fintype Z]
    (S : FlaggedTensor X Y Z) :
    Fintype.card (CompletionTermination.Leaf S .A) =
      conditionalCount S .B + conditionalCount S .C := by
  rw [Fintype.card_congr (CompletionTermination.leafEquiv S .A)]
  simp only [conditionalCount, Fintype.card_subtype, Finset.card_filter,
    ← Finset.sum_add_distrib]
  apply Finset.sum_congr rfl
  intro a _
  cases leafColor S a <;> simp

theorem card_leaf : Fintype.card Leaf = leafCount := by
  rw [card_termination_A, completed, conditionalCount_script, conditionalCount_script]
  norm_num [counts, initialCount, Script.square, leafCount, reduceCtorEq]

instance leafNonempty : Nonempty Leaf :=
  Fintype.card_pos_iff.mp (by rw [card_leaf]; exact leafCount_pos)

def uniformLaw : FiniteLaw Leaf := FiniteLaw.uniform Leaf

theorem uniformLaw_mass (a : Leaf) : uniformLaw.mass a = (leafCount : ℝ)⁻¹ := by
  simp [uniformLaw, card_leaf]

theorem uniformLaw_pos (a : Leaf) : 0 < uniformLaw.mass a := by
  rw [uniformLaw_mass]
  exact inv_pos.mpr (Nat.cast_pos.mpr leafCount_pos)

theorem uniformLaw_entropy : finiteEntropy uniformLaw.mass = Real.log leafCount := by
  rw [uniformLaw, FiniteLaw.uniform_entropy, card_leaf]

def leafMultiplicity (_ : Leaf) : ℕ := 1

theorem totalMultiplicity : (∑ a : Leaf, leafMultiplicity a) = leafCount := by
  exact (Finset.card_eq_sum_ones (Finset.univ : Finset Leaf)).symm.trans card_leaf

theorem totalMultiplicity_pos : 0 < ∑ a : Leaf, leafMultiplicity a := by
  rw [totalMultiplicity]
  exact leafCount_pos

theorem uniformLaw_mass_counts (a : Leaf) :
    uniformLaw.mass a = (leafMultiplicity a : ℝ) /
      (∑ b : Leaf, leafMultiplicity b : ℕ) := by
  rw [uniformLaw_mass, totalMultiplicity]
  simp [leafMultiplicity, one_div]

def retainedUniformLaw : FiniteLaw (RetainedLeaf completed .B .C) :=
  uniformLaw.map retainedLeafEquiv

theorem retainedUniformLaw_mass (a : RetainedLeaf completed .B .C) :
    retainedUniformLaw.mass a = (leafCount : ℝ)⁻¹ := by
  have h := uniformLaw.map_mass_apply retainedLeafEquiv retainedLeafEquiv.injective
    (retainedLeafEquiv.symm a)
  simpa only [retainedUniformLaw, Equiv.apply_symm_apply, uniformLaw_mass] using h

theorem retainedUniformLaw_entropy :
    finiteEntropy retainedUniformLaw.mass = Real.log leafCount := by
  rw [retainedUniformLaw, FiniteLaw.map_entropy_of_injective uniformLaw
    retainedLeafEquiv retainedLeafEquiv.injective, uniformLaw_entropy]

theorem uniform_pairRate_sum {Label : ℕ → Type*} [∀ n, Fintype (Label n)]
    (labels : ∀ n, Leaf → Label n) (depth : ℕ)
    (reader : Fin depth → ReaderPair)
    (complete : Function.Injective (labelRecordOf labels depth)) :
    ConditionalLabels.lawPairingRate uniformLaw labels depth reader .xy +
      ConditionalLabels.lawPairingRate uniformLaw labels depth reader .xz +
      ConditionalLabels.lawPairingRate uniformLaw labels depth reader .yz =
        Real.log leafCount := by
  rw [ConditionalLabels.lawPairingRate_sum uniformLaw labels depth reader complete,
    uniformLaw_entropy]

def approximation :
    Tensor.PolynomialApproximation tensor (3 ^ 72)
      (Script.order 5 Script.square) (Script.degree 15 Script.square) :=
  CompletionTermination.approximation completed .A
    (Script.approximation BaseThree.flagged BaseThree.approximation Script.square)

theorem rank_power (n : ℕ) :
    Tensor.RankAtMost (Tensor.power tensor n)
      ((Script.degree 15 Script.square * n + 1) * (3 ^ 72) ^ n) :=
  approximation.rank_power n

end MatrixMultiplication.SquareCounts

end

end OAI