lean/OAI/LinearAlgebra/MatrixMultiplication/Completion/Execution.lean

import OAI.LinearAlgebra.MatrixMultiplication.Completion.HierarchyWords
import OAI.LinearAlgebra.MatrixMultiplication.Completion.GeometricValues
import OAI.LinearAlgebra.MatrixMultiplication.Entropy.ComplexConditionalHierarchyStage
import OAI.LinearAlgebra.MatrixMultiplication.Entropy.ComplexOrientedConditionalHierarchyStage
import OAI.LinearAlgebra.MatrixMultiplication.Tensor.ComplexGeometricStageCoordinates
import OAI.LinearAlgebra.MatrixMultiplication.Polynomial.ComplexPolynomialExecutionReindex

namespace OAI

/-! Readable tensor completion and its finite arithmetic realization. -/

noncomputable section

namespace MatrixMultiplication.CompletionExecution

open MatrixMultiplication.Foundation CompletionHierarchyWords ConditionalPrefixWords
open PolynomialKernelExecution ExecutionPairingBudget StageHierarchyResources
open scoped BigOperators Classical

variable {A X Y Z : Type} [Fintype A]
variable (H : ReadableHierarchy A X Y Z)

abbrev Position (counts : A → ℕ) (t : ℕ) := Fin (t * ∑ a, counts a)
abbrev Coordinate (U : Type) (counts : A → ℕ) (t : ℕ) := Position counts t → U
abbrev Prefix (counts : A → ℕ) (t n : ℕ) :=
  ExactPrefix counts H.labels n t (Position counts t)

def support (counts : A → ℕ) (t : ℕ)
    (x : Coordinate X counts t) (y : Coordinate Y counts t)
    (z : Coordinate Z counts t) : Prop :=
  ∀ i, ∃ a : A, H.x a = x i ∧ H.y a = y i ∧ H.z a = z i

def pairingProduct (counts : A → ℕ) (t : ℕ) (pair : ReaderPair) (n : ℕ) : ℕ :=
  ∏ i ∈ Finset.range n, if H.pair i = pair then
    stageRefinementCount counts H.labels i t else 1

@[simp] theorem pairingProduct_zero (counts : A → ℕ) (t : ℕ) (pair : ReaderPair) :
    pairingProduct H counts t pair 0 = 1 := by simp [pairingProduct]

theorem pairingProduct_succ (counts : A → ℕ) (t : ℕ) (pair : ReaderPair) (n : ℕ) :
    pairingProduct H counts t pair (n + 1) = pairingProduct H counts t pair n *
      (if H.pair n = pair then stageRefinementCount counts H.labels n t else 1) := by
  simp only [pairingProduct, Finset.prod_range_succ]

def prefixValue {PX PY PZ : Type*} (counts : A → ℕ) (t n : ℕ)
    (pairing : Tensor ℂ PX PY PZ) :
    Tensor ℂ (Coordinate X counts t × (Prefix H counts t n × PX))
      (Coordinate Y counts t × (Prefix H counts t n × PY))
      (Coordinate Z counts t × (Prefix H counts t n × PZ)) :=
  fun x y z => if x.2.1 = y.2.1 ∧ x.2.1 = z.2.1 ∧
      eligible H id x.2.1 x.1 y.1 z.1 then pairing x.2.2 y.2.2 z.2.2 else 0

structure Bundle (counts : A → ℕ) (t n : ℕ) where
  PX : Type
  PY : Type
  PZ : Type
  AX : Type
  AY : Type
  AZ : Type
  [finitePX : Fintype PX]
  [finitePY : Fintype PY]
  [finitePZ : Fintype PZ]
  [finiteAX : Fintype AX]
  [finiteAY : Fintype AY]
  [finiteAZ : Fintype AZ]
  execution : Execution (Coordinate X counts t) (Coordinate Y counts t) (Coordinate Z counts t)
    (Prefix H counts t n) PX PY PZ AX AY AZ
      (support H counts t)
  shape : MatrixCoordinates PX PY PZ
  shape_positive : shape.Positive
  normal : execution.value = prefixValue H counts t n shape.tensor
  rank_exact : execution.rankBound = stageAuxiliaryBudget counts H.labels n t
  volume_exact : shape.volume = stagePairingProduct counts H.labels n t
  rows_exact : shape.rows = pairingProduct H counts t .xz n
  inner_exact : shape.inner = pairingProduct H counts t .xy n
  columns_exact : shape.columns = pairingProduct H counts t .yz n
  pairing_budget : shape.volume ≤ execution.rankBound

attribute [instance] Bundle.finitePX Bundle.finitePY Bundle.finitePZ
attribute [instance] Bundle.finiteAX Bundle.finiteAY Bundle.finiteAZ

theorem position_card (counts : A → ℕ) (t : ℕ) :
    Fintype.card (Position counts t) = ∑ a, t * counts a := by
  simp [Position, Finset.mul_sum]

def scalarAuxiliary : Tensor ℂ PUnit PUnit PUnit := fun _ _ _ => 1

theorem scalarAuxiliary_rank : Tensor.RankAtMost scalarAuxiliary 1 := by
  refine ⟨fun _ _ => 1, fun _ _ => 1, fun _ _ => 1, ?_⟩
  funext x y z
  simp [scalarAuxiliary, Tensor.rankOne]

def initial (counts : A → ℕ) (t : ℕ) : Bundle H counts t 0 := by
  let E : Execution (Coordinate X counts t) (Coordinate Y counts t)
      (Coordinate Z counts t) (Prefix H counts t 0) PUnit PUnit PUnit
      PUnit PUnit PUnit (support H counts t) := {
    auxiliary := scalarAuxiliary
    rankBound := 1
    auxiliary_rank := scalarAuxiliary_rank
    order := 0
    leftDegree := 0
    middleDegree := 0
    rightDegree := 0
    leftMap := fun _ _ _ => 1
    middleMap := fun _ _ _ => 1
    rightMap := fun _ _ _ => 1
    left_degree := by intros; simp
    middle_degree := by intros; simp
    right_degree := by intros; simp
    value := prefixValue H counts t 0 MatrixCoordinates.scalar.tensor
    vanishes := by intro _ _ _ _ j hj; omega
    leading := by
      intro x y z hs
      have hxy : x.2.1 = y.2.1 := Subsingleton.elim _ _
      have hxz : x.2.1 = z.2.1 := Subsingleton.elim _ _
      have he : eligible H id x.2.1 x.1 y.1 z.1 :=
        (root_eligible_iff H x.2.1 x.1 y.1 z.1).mpr hs
      change _ = (if x.2.1 = y.2.1 ∧ x.2.1 = z.2.1 ∧
        eligible H id x.2.1 x.1 y.1 z.1 then
          MatrixCoordinates.scalar.tensor x.2.2 y.2.2 z.2.2 else 0)
      rw [ite_eq_left ⟨hxy, hxz, he⟩, MatrixCoordinates.scalar_tensor]
      simp [PolynomialLocalConstruction.kernel, LocalMaps.fiberTransform, scalarAuxiliary]
    synchronized := by intro _ _ _ _ _; exact ⟨Subsingleton.elim _ _, Subsingleton.elim _ _⟩
  }
  exact {
    PX := PUnit
    PY := PUnit
    PZ := PUnit
    AX := PUnit
    AY := PUnit
    AZ := PUnit
    execution := E
    shape := MatrixCoordinates.scalar
    shape_positive := MatrixCoordinates.scalar_positive
    normal := rfl
    rank_exact := by simp [E, stageAuxiliaryBudget]
    volume_exact := by simp [stagePairingProduct]
    rows_exact := by simp [MatrixCoordinates.scalar]
    inner_exact := by simp [MatrixCoordinates.scalar]
    columns_exact := by simp [MatrixCoordinates.scalar]
    pairing_budget := le_rfl
  }

variable {H}

theorem previous_eligible {counts : A → ℕ} {t n : ℕ} (B : Bundle H counts t n)
    (x : Coordinate X counts t × (Prefix H counts t n × B.PX))
    (y : Coordinate Y counts t × (Prefix H counts t n × B.PY))
    (z : Coordinate Z counts t × (Prefix H counts t n × B.PZ))
    (_hs : support H counts t x.1 y.1 z.1)
    (hn : B.execution.value x y z ≠ 0) : eligible H id x.2.1 x.1 y.1 z.1 := by
  rw [B.normal] at hn
  by_contra h
  exact hn (by simp [prefixValue, h])

section Successor

variable {counts : A → ℕ} {t n : ℕ} (B : Bundle H counts t n)
variable {NX NY NZ BX BY BZ : Type}
variable [Fintype BX] [Fintype BY] [Fintype BZ]

def refinedExecution
    (S : Stage B.execution (Fin (stageRefinementCount counts H.labels n t))
      NX NY NZ BX BY BZ) :
    Execution (Coordinate X counts t) (Coordinate Y counts t) (Coordinate Z counts t)
      (Prefix H counts t (n + 1)) (B.PX × NX) (B.PY × NY) (B.PZ × NZ)
      (B.AX × BX) (B.AY × BY) (B.AZ × BZ)
      (support H counts t) :=
  (B.execution.step S).reindexOutput
    (nextPrefixEquiv counts H.labels n t (Position counts t))
    (Equiv.refl _) (Equiv.refl _) (Equiv.refl _)

theorem refinedExecution_normal
    (S : Stage B.execution (Fin (stageRefinementCount counts H.labels n t))
      NX NY NZ BX BY BZ)
    (shape : MatrixCoordinates NX NY NZ)
    (hstage : ∀ p x y z, eligible H id p x.1 y.1 z.1 →
      S.value p x y z = if x.2.1 = y.2.1 ∧ x.2.1 = z.2.1 ∧
          eligible H id (appendCode p x.2.1) x.1 y.1 z.1
        then shape.tensor x.2.2 y.2.2 z.2.2 else 0) :
    (refinedExecution B S).value =
      prefixValue H counts t (n + 1) (B.shape.product shape).tensor := by
  classical
  funext x y z
  let e := nextPrefixEquiv counts H.labels n t (Position counts t)
  let px := e x.2.1
  let py := e y.2.1
  let pz := e z.2.1
  have hdecode (p : Prefix H counts t (n + 1)) :
      appendCode (e p).1 (e p).2 = p := e.symm_apply_apply p
  change B.execution.value (x.1, (px.1, x.2.2.1))
      (y.1, (py.1, y.2.2.1)) (z.1, (pz.1, z.2.2.1)) *
    S.value px.1 (x.1, (px.2, x.2.2.2))
      (y.1, (py.2, y.2.2.2)) (z.1, (pz.2, z.2.2.2)) = _
  rw [B.normal]
  simp only [prefixValue]
  by_cases hold : px.1 = py.1 ∧ px.1 = pz.1 ∧ eligible H id px.1 x.1 y.1 z.1
  · rw [ite_eq_left hold]
    have hguard :
        (px.2 = py.2 ∧ px.2 = pz.2 ∧ eligible H id (appendCode px.1 px.2) x.1 y.1 z.1) ↔
        (x.2.1 = y.2.1 ∧ x.2.1 = z.2.1 ∧ eligible H id x.2.1 x.1 y.1 z.1) := by
      constructor
      · rintro ⟨hxy, hxz, he⟩
        refine ⟨e.injective (Prod.ext hold.1 hxy),
          e.injective (Prod.ext hold.2.1 hxz), ?_⟩
        simpa only [px, hdecode] using he
      · rintro ⟨hxy, hxz, he⟩
        refine ⟨congrArg (fun p => (e p).2) hxy,
          congrArg (fun p => (e p).2) hxz, ?_⟩
        simpa only [px, hdecode] using he
    rw [hstage px.1 (x.1, (px.2, x.2.2.2))
      (y.1, (py.2, y.2.2.2)) (z.1, (pz.2, z.2.2.2)) hold.2.2]
    simp only [hguard,
      MatrixCoordinates.product_tensor, Tensor.product, mul_ite, mul_zero]
  · have hnext : ¬ (x.2.1 = y.2.1 ∧ x.2.1 = z.2.1 ∧
        eligible H id x.2.1 x.1 y.1 z.1) := by
      rintro ⟨hxy, hxz, he⟩
      apply hold
      refine ⟨congrArg (fun p => (e p).1) hxy,
        congrArg (fun p => (e p).1) hxz, ?_⟩
      rw [← hdecode x.2.1] at he
      obtain ⟨word, hw, _⟩ :=
        (eligible_appendCode_iff H px.1 px.2 x.1 y.1 z.1).mp he
      exact ⟨word, hw⟩
    rw [ite_eq_right hold, ite_eq_right hnext, zero_mul]

def extendBundle [Fintype NX] [Fintype NY] [Fintype NZ]
    (S : Stage B.execution (Fin (stageRefinementCount counts H.labels n t))
      NX NY NZ BX BY BZ)
    (shape : MatrixCoordinates NX NY NZ) (hpositive : shape.Positive)
    (hvolume : shape.volume = stageRefinementCount counts H.labels n t)
    (hrank : S.rankBound = stageCost counts H.labels n t)
    (hrows : shape.rows = if H.pair n = .xz then
      stageRefinementCount counts H.labels n t else 1)
    (hinner : shape.inner = if H.pair n = .xy then
      stageRefinementCount counts H.labels n t else 1)
    (hcolumns : shape.columns = if H.pair n = .yz then
      stageRefinementCount counts H.labels n t else 1)
    (hstage : ∀ p x y z, eligible H id p x.1 y.1 z.1 →
      S.value p x y z = if x.2.1 = y.2.1 ∧ x.2.1 = z.2.1 ∧
          eligible H id (appendCode p x.2.1) x.1 y.1 z.1
        then shape.tensor x.2.2 y.2.2 z.2.2 else 0) : Bundle H counts t (n + 1) where
  PX := B.PX × NX
  PY := B.PY × NY
  PZ := B.PZ × NZ
  AX := B.AX × BX
  AY := B.AY × BY
  AZ := B.AZ × BZ
  execution := refinedExecution B S
  shape := B.shape.product shape
  shape_positive := B.shape.product_positive shape B.shape_positive hpositive
  normal := refinedExecution_normal B S shape hstage
  rank_exact := by
    change B.execution.rankBound * S.rankBound = _
    rw [B.rank_exact, hrank, stageAuxiliaryBudget_succ]
  volume_exact := by
    rw [MatrixCoordinates.product_volume, B.volume_exact, hvolume, stagePairingProduct_succ]
  rows_exact := by
    change B.shape.rows * shape.rows = _
    rw [B.rows_exact, hrows, pairingProduct_succ]
  inner_exact := by
    change B.shape.inner * shape.inner = _
    rw [B.inner_exact, hinner, pairingProduct_succ]
  columns_exact := by
    change B.shape.columns * shape.columns = _
    rw [B.columns_exact, hcolumns, pairingProduct_succ]
  pairing_budget := by
    change (B.shape.product shape).volume ≤ B.execution.rankBound * S.rankBound
    rw [MatrixCoordinates.product_volume]
    apply Nat.mul_le_mul B.pairing_budget
    rw [hvolume, hrank]
    exact LabelHierarchySeparation.population_le_poolAuxiliaryCost _

end Successor

section ConcreteStages

variable {counts : A → ℕ} {t n : ℕ}

def extendXY (B : Bundle H counts t n) (hn : n < H.depth)
    (hpair : H.pair n = .xy) : Bundle H counts t (n + 1) := Classical.choice (by
  have hagree : ∀ (p : Prefix H counts t n)
      (x : Coordinate X counts t) (y : Coordinate Y counts t)
      (z : Coordinate Z counts t), eligible H id p x y z →
      readXYX H id hpair p x = readXYY H id hpair p y := by
    intro p x y z he
    exact readable_XY H id hpair p x y z hn he
  obtain ⟨S, _, hrank, _, _, _, _, hvalue⟩ :=
    ConditionalHierarchyStage.exists_actualPoolStage counts H.labels n t B.execution id
      (readXYX H id hpair) (readXYY H id hpair)
      (eligible H id) (previous_eligible B) hagree
  refine ⟨extendBundle B S (GeometricStageCoordinates.xy _)
    (GeometricStageCoordinates.xy_positive (stageRefinementCount_pos counts H.labels n t))
    (GeometricStageCoordinates.xy_volume _) hrank
    (by simp [hpair, GeometricStageCoordinates.xy])
    (by simp [hpair, GeometricStageCoordinates.xy])
    (by simp [hpair, GeometricStageCoordinates.xy]) ?_⟩
  intro p x y z he
  rw [hvalue]
  obtain ⟨word, hw⟩ := he
  exact CompletionGeometricValues.raw_XY_normal H p hn hpair x y z word hw)

def extendXZ (B : Bundle H counts t n) (hn : n < H.depth)
    (hpair : H.pair n = .xz) : Bundle H counts t (n + 1) := Classical.choice (by
  have hagree : ∀ (p : Prefix H counts t n)
      (x : Coordinate X counts t) (y : Coordinate Y counts t)
      (z : Coordinate Z counts t), eligible H id p x y z →
      readXZX H id hpair p x = readXZZ H id hpair p z := by
    intro p x y z he
    exact readable_XZ H id hpair p x y z hn he
  obtain ⟨S, _, hrank, _, _, _, _, hvalue⟩ :=
    OrientedConditionalHierarchyStage.exists_actualPoolStage_XZ counts H.labels n t B.execution id
      (readXZX H id hpair) (readXZZ H id hpair)
      (eligible H id) (previous_eligible B) hagree
  refine ⟨extendBundle B S (GeometricStageCoordinates.xz _)
    (GeometricStageCoordinates.xz_positive (stageRefinementCount_pos counts H.labels n t))
    (GeometricStageCoordinates.xz_volume _) hrank
    (by simp [hpair, GeometricStageCoordinates.xz])
    (by simp [hpair, GeometricStageCoordinates.xz])
    (by simp [hpair, GeometricStageCoordinates.xz]) ?_⟩
  intro p x y z he
  rw [hvalue]
  obtain ⟨word, hw⟩ := he
  exact CompletionGeometricValues.raw_XZ_normal H p hn hpair x y z word hw)

def extendYZ (B : Bundle H counts t n) (hn : n < H.depth)
    (hpair : H.pair n = .yz) : Bundle H counts t (n + 1) := Classical.choice (by
  have hagree : ∀ (p : Prefix H counts t n)
      (x : Coordinate X counts t) (y : Coordinate Y counts t)
      (z : Coordinate Z counts t), eligible H id p x y z →
      readYZY H id hpair p y = readYZZ H id hpair p z := by
    intro p x y z he
    exact readable_YZ H id hpair p x y z hn he
  obtain ⟨S, _, hrank, _, _, _, _, hvalue⟩ :=
    OrientedConditionalHierarchyStage.exists_actualPoolStage_YZ counts H.labels n t B.execution id
      (readYZY H id hpair) (readYZZ H id hpair)
      (eligible H id) (previous_eligible B) hagree
  refine ⟨extendBundle B S (GeometricStageCoordinates.yz _)
    (GeometricStageCoordinates.yz_positive (stageRefinementCount_pos counts H.labels n t))
    (GeometricStageCoordinates.yz_volume _) hrank
    (by simp [hpair, GeometricStageCoordinates.yz])
    (by simp [hpair, GeometricStageCoordinates.yz])
    (by simp [hpair, GeometricStageCoordinates.yz]) ?_⟩
  intro p x y z he
  rw [hvalue]
  obtain ⟨word, hw⟩ := he
  exact CompletionGeometricValues.raw_YZ_normal H p hn hpair x y z word hw)

def extend (B : Bundle H counts t n) (hn : n < H.depth) :
    Bundle H counts t (n + 1) :=
  match hp : H.pair n with
  | .xy => extendXY B hn hp
  | .xz => extendXZ B hn hp
  | .yz => extendYZ B hn hp

end ConcreteStages

variable (H)

def run (counts : A → ℕ) (t : ℕ) : (n : ℕ) → n ≤ H.depth → Bundle H counts t n
  | 0, _ => initial H counts t
  | n + 1, hn => extend (run counts t n (by omega)) (by omega)

def realize (counts : A → ℕ) (t : ℕ) : Bundle H counts t H.depth :=
  run H counts t H.depth le_rfl

theorem realize_dimensions (counts : A → ℕ) (t : ℕ) :
    (realize H counts t).shape.rows =
        ConditionalLabels.stagePairingSize counts H.labels H.depth
          (fun n => H.pair n.val) .xz t ∧
    (realize H counts t).shape.inner =
        ConditionalLabels.stagePairingSize counts H.labels H.depth
          (fun n => H.pair n.val) .xy t ∧
    (realize H counts t).shape.columns =
        ConditionalLabels.stagePairingSize counts H.labels H.depth
          (fun n => H.pair n.val) .yz t := by
  have h (pair : ReaderPair) : pairingProduct H counts t pair H.depth =
      ConditionalLabels.stagePairingSize counts H.labels H.depth
        (fun n => H.pair n.val) pair t := by
    simp only [pairingProduct, ConditionalLabels.stagePairingSize,
      ConditionalLabels.pairingSize, ← Fin.prod_univ_eq_prod_range]
  exact ⟨(realize H counts t).rows_exact.trans (h .xz),
    (realize H counts t).inner_exact.trans (h .xy),
    (realize H counts t).columns_exact.trans (h .yz)⟩

theorem realize_rankBound (counts : A → ℕ) (t : ℕ) :
    (realize H counts t).execution.rankBound =
      stageAuxiliaryBudget counts H.labels H.depth t :=
  (realize H counts t).rank_exact

theorem realize_volume (counts : A → ℕ) (t : ℕ)
    (complete : Function.Injective (labelRecordOf H.labels H.depth)) :
    (realize H counts t).shape.volume =
      Fintype.card (ExactWords (fun a => t * counts a)) := by
  rw [(realize H counts t).volume_exact]
  exact stagePairingProduct_eq_exactWords_card counts H.labels H.depth complete t

theorem realize_label_card (counts : A → ℕ) (t : ℕ)
    (complete : Function.Injective (labelRecordOf H.labels H.depth)) :
    Fintype.card (Prefix H counts t H.depth) =
      Fintype.card (ExactWords (fun a => t * counts a)) := by
  rw [exactWords_card]
  calc
    Fintype.card (Prefix H counts t H.depth) =
        Fintype.card (PopulationWords (Position counts t) (fun a => t * counts a)) :=
      Fintype.card_congr
        (sourcePrefixEquiv counts H.labels H.depth t (Position counts t) complete)
    _ = Nat.multinomial Finset.univ (fun a => t * counts a) :=
      populationWords_card (I := Position counts t)
        (fun a => t * counts a) (position_card counts t)

end MatrixMultiplication.CompletionExecution

end

end OAI