lean/OAI/LinearAlgebra/MatrixMultiplication/Completion/Labels.lean

import OAI.LinearAlgebra.MatrixMultiplication.Completion.Scripts
import OAI.LinearAlgebra.MatrixMultiplication.Entropy.ConditionalLabels

namespace OAI

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

noncomputable section

universe uCoord

namespace MatrixMultiplication.CompletionLabels

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

variable {X Y Z : Type uCoord}

def Leaf (S : FlaggedTensor X Y Z) :=
  {p : X × Y × Z // S.tensor p.1 p.2.1 p.2.2 ≠ 0}

instance leafFintype [Fintype X] [Fintype Y] [Fintype Z]
    (S : FlaggedTensor X Y Z) : Fintype (Leaf S) :=
  inferInstanceAs (Fintype {p : X × Y × Z // S.tensor p.1 p.2.1 p.2.2 ≠ 0})

def Coordinate (X Y Z : Type uCoord) : Color → Type uCoord
  | .B => X
  | .A => Z
  | .C => Y

def coordinate (p : X × Y × Z) : (c : Color) → Coordinate X Y Z c
  | .B => p.1
  | .A => p.2.2
  | .C => p.2.1

def ownerFlag (S : FlaggedTensor X Y Z) : (c : Color) → Coordinate X Y Z c → Prop
  | .B => S.flagB
  | .A => S.flagA
  | .C => S.flagC

def leafColor (S : FlaggedTensor X Y Z) (a : Leaf S) : Color :=
  if S.flagB a.val.1 then .B else if S.flagA a.val.2.2 then .A else .C

theorem leafColor_eq_iff (S : FlaggedTensor X Y Z) (a : Leaf S) (c : Color) :
    leafColor S a = c ↔ ownerFlag S c (coordinate a.val c) := by
  have h := S.one_hot _ _ _ a.property
  cases c <;>
    by_cases hb : S.flagB a.val.1 <;>
    by_cases ha : S.flagA a.val.2.2 <;>
    by_cases hc : S.flagC a.val.2.1 <;>
    simp_all [leafColor, ownerFlag, coordinate]

theorem complete_supported (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ)
    (a : Leaf (complete S center m)) :
    Tensor.power S.tensor m a.val.1 a.val.2.1 a.val.2.2 ≠ 0 := by
  have h := a.property
  change (if weight S center m a.val.1 a.val.2.1 a.val.2.2 = 1 then
    Tensor.power S.tensor m a.val.1 a.val.2.1 a.val.2.2 else 0) ≠ 0 at h
  split_ifs at h with hw
  · exact h
  · exact False.elim (h rfl)

def slot (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ)
    (a : Leaf (complete S center m)) (i : Fin m) : Leaf S :=
  ⟨(a.val.1 i, a.val.2.1 i, a.val.2.2 i),
    (Finset.prod_ne_zero_iff.mp (complete_supported S center m a)) i (Finset.mem_univ i)⟩

def pattern (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ)
    (a : Leaf (complete S center m)) : Fin m → Color :=
  fun i => leafColor S (slot S center m a i)

theorem slot_injective (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ) :
    Function.Injective (slot S center m) := by
  intro a b h
  apply Subtype.ext
  apply Prod.ext
  · funext i
    exact congrArg (fun w : Leaf S => w.val.1) (congrFun h i)
  · apply Prod.ext
    · funext i
      exact congrArg (fun w : Leaf S => w.val.2.1) (congrFun h i)
    · funext i
      exact congrArg (fun w : Leaf S => w.val.2.2) (congrFun h i)

theorem completed_color_iff (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ)
    (a : Leaf (complete S center m)) (c : Color) :
    leafColor (complete S center m) a = c ↔
      raisedFlag center c (fun i => pattern S center m a i = c) := by
  rw [leafColor_eq_iff]
  have hold (i : Fin m) := leafColor_eq_iff S (slot S center m a i) c
  have heq : (fun i => pattern S center m a i = c) =
      (fun i => ownerFlag S c (coordinate (slot S center m a i).val c)) := by
    funext i
    exact propext (hold i)
  rw [heq]
  cases c <;> rfl

theorem pattern_mem (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ)
    (a : Leaf (complete S center m)) (i : Fin m) :
    pattern S center m a i = center ∨
      pattern S center m a i = leafColor (complete S center m) a := by
  by_cases hc : pattern S center m a i = center
  · exact Or.inl hc
  · right
    have hn : center ≠ pattern S center m a i := Ne.symm hc
    have hnew : leafColor (complete S center m) a = pattern S center m a i := by
      apply (completed_color_iff S center m a _).mpr
      simp only [raisedFlag, ite_eq_right hn]
      exact ⟨i, rfl⟩
    exact hnew.symm

theorem pattern_eq_center (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ)
    (a : Leaf (complete S center m))
    (h : leafColor (complete S center m) a = center) :
    pattern S center m a = fun _ => center := by
  funext i
  have hi := pattern_mem S center m a i
  simpa only [h, or_self] using hi

def centerRead (S : FlaggedTensor X Y Z) (center output : Color) (m : ℕ)
    (u : Fin m → Coordinate X Y Z center) : Fin m → Color :=
  fun i => if ownerFlag S center (u i) then center else output

def outputRead (S : FlaggedTensor X Y Z) (center output : Color) (m : ℕ)
    (u : Fin m → Coordinate X Y Z output) : Fin m → Color :=
  fun i => if ownerFlag S output (u i) then output else center

theorem centerRead_pattern (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ)
    (a : Leaf (complete S center m)) :
    centerRead S center (leafColor (complete S center m) a) m
      (fun i => coordinate (slot S center m a i).val center) = pattern S center m a := by
  funext i
  have hc := leafColor_eq_iff S (slot S center m a i) center
  change (if ownerFlag S center _ then center else _) = _
  by_cases h : pattern S center m a i = center
  · rw [ite_eq_left (hc.mp h), h]
  · rw [ite_eq_right (fun hf => h (hc.mpr hf))]
    exact (Or.resolve_left (pattern_mem S center m a i) h).symm

theorem outputRead_pattern (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ)
    (a : Leaf (complete S center m)) :
    outputRead S center (leafColor (complete S center m) a) m
      (fun i => coordinate (slot S center m a i).val
        (leafColor (complete S center m) a)) = pattern S center m a := by
  funext i
  have hc := leafColor_eq_iff S (slot S center m a i)
    (leafColor (complete S center m) a)
  change (if ownerFlag S _ _ then _ else center) = _
  by_cases h : pattern S center m a i = leafColor (complete S center m) a
  · rw [ite_eq_left (hc.mp h), h]
  · rw [ite_eq_right (fun hf => h (hc.mpr hf))]
    exact (Or.resolve_right (pattern_mem S center m a i) h).symm

theorem raisedFlag_iff_output {I : Type*} (p : I → Color) (center output : Color)
    (active : raisedFlag center output (fun i => p i = output))
    (allowed : ∀ i, p i = center ∨ p i = output) (c : Color) :
    raisedFlag center c (fun i => p i = c) ↔ c = output := by
  constructor
  · intro hc
    by_contra hco
    by_cases hcc : center = c
    · subst c
      have hne : center ≠ output := hco
      have ha : ∃ i, p i = output := by
        simpa only [raisedFlag, ite_eq_right hne] using active
      have hall : ∀ i, p i = center := by
        simpa only [raisedFlag, ite_eq_left rfl, ite_true] using hc
      obtain ⟨i, hi⟩ := ha
      exact hne ((hall i).symm.trans hi)
    · have ha : ∃ i, p i = c := by
        simpa only [raisedFlag, ite_eq_right hcc] using hc
      obtain ⟨i, hi⟩ := ha
      rcases allowed i with h | h
      · exact hcc (h.symm.trans hi)
      · exact hco (hi.symm.trans h)
  · rintro rfl
    exact active

def wordCoordinates {m : ℕ} (S : FlaggedTensor X Y Z) (w : Fin m → Leaf S) :
    (Fin m → X) × (Fin m → Y) × (Fin m → Z) :=
  (fun i => (w i).val.1, fun i => (w i).val.2.1, fun i => (w i).val.2.2)

theorem word_ownerFlag (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ)
    (w : Fin m → Leaf S) (c : Color) :
    ownerFlag (complete S center m) c (coordinate (wordCoordinates S w) c) ↔
      raisedFlag center c (fun i => leafColor S (w i) = c) := by
  have heq : (fun i => leafColor S (w i) = c) =
      (fun i => ownerFlag S c (coordinate (w i).val c)) := by
    funext i
    exact propext (leafColor_eq_iff S (w i) c)
  rw [heq]
  cases c <;> rfl

def packLeaf (S : FlaggedTensor X Y Z) (center output : Color) (m : ℕ)
    (w : Fin m → Leaf S)
    (active : raisedFlag center output (fun i => leafColor S (w i) = output))
    (allowed : ∀ i, leafColor S (w i) = center ∨ leafColor S (w i) = output) :
    Leaf (complete S center m) := by
  have hflag (c : Color) :
      ownerFlag (complete S center m) c (coordinate (wordCoordinates S w) c) ↔
        c = output :=
    (word_ownerFlag S center m w c).trans
      (raisedFlag_iff_output _ center output active allowed c)
  have hw : weight S center m (wordCoordinates S w).1
      (wordCoordinates S w).2.1 (wordCoordinates S w).2.2 = 1 := by
    have hb := hflag .B
    have ha := hflag .A
    have hc := hflag .C
    change flagB S center m (wordCoordinates S w).1 ↔ Color.B = output at hb
    change flagA S center m (wordCoordinates S w).2.2 ↔ Color.A = output at ha
    change flagC S center m (wordCoordinates S w).2.1 ↔ Color.C = output at hc
    simp only [weight, hb, ha, hc]
    cases output <;> simp
  refine ⟨wordCoordinates S w, ?_⟩
  rw [complete_tensor, ite_eq_left hw]
  apply Finset.prod_ne_zero_iff.mpr
  intro i _
  exact (w i).property

@[simp] theorem slot_packLeaf (S : FlaggedTensor X Y Z) (center output : Color) (m : ℕ)
    (w : Fin m → Leaf S) (active) (allowed) :
    slot S center m (packLeaf S center output m w active allowed) = w := by
  funext i
  apply Subtype.ext
  rfl

theorem packLeaf_color (S : FlaggedTensor X Y Z) (center output : Color) (m : ℕ)
    (w : Fin m → Leaf S) (active) (allowed) :
    leafColor (complete S center m) (packLeaf S center output m w active allowed) = output := by
  apply (completed_color_iff S center m _ output).mpr
  simpa only [pattern, slot_packLeaf] using active

def conditionalLeafEquiv (S : FlaggedTensor X Y Z) (center output : Color) (m : ℕ) :
    {a : Leaf (complete S center m) // leafColor (complete S center m) a = output} ≃
      {w : Fin m → Leaf S //
        raisedFlag center output (fun i => leafColor S (w i) = output) ∧
        ∀ i, leafColor S (w i) = center ∨ leafColor S (w i) = output} where
  toFun a := ⟨slot S center m a.val,
    (completed_color_iff S center m a.val output).mp a.property,
    fun i => by simpa only [pattern, ← a.property] using pattern_mem S center m a.val i⟩
  invFun w := ⟨packLeaf S center output m w.val w.property.1 w.property.2,
    packLeaf_color S center output m w.val w.property.1 w.property.2⟩
  left_inv a := by
    apply Subtype.ext
    apply slot_injective S center m
    simp only [slot_packLeaf]
  right_inv w := by
    apply Subtype.ext
    simp only [slot_packLeaf]

def RetainedLeaf (S : FlaggedTensor X Y Z) (first second : Color) :=
  {a : Leaf S // leafColor S a = first ∨ leafColor S a = second}

instance retainedLeafFintype [Fintype X] [Fintype Y] [Fintype Z]
    (S : FlaggedTensor X Y Z) (first second : Color) :
    Fintype (RetainedLeaf S first second) :=
  inferInstanceAs (Fintype {a : Leaf S // leafColor S a = first ∨ leafColor S a = second})

def terminationFirstRead (S : FlaggedTensor X Y Z) (first second : Color)
    (u : Coordinate X Y Z first) : Color :=
  if ownerFlag S first u then first else second

def terminationSecondRead (S : FlaggedTensor X Y Z) (first second : Color)
    (u : Coordinate X Y Z second) : Color :=
  if ownerFlag S second u then second else first

theorem termination_readable (S : FlaggedTensor X Y Z) (first second : Color)
    (a : RetainedLeaf S first second) :
    terminationFirstRead S first second (coordinate a.val.val first) = leafColor S a.val ∧
    terminationSecondRead S first second (coordinate a.val.val second) = leafColor S a.val := by
  have hf := leafColor_eq_iff S a.val first
  have hs := leafColor_eq_iff S a.val second
  constructor
  · by_cases h : leafColor S a.val = first
    · simp only [terminationFirstRead, ite_eq_left (hf.mp h), h]
    · rw [terminationFirstRead, ite_eq_right (fun hflag => h (hf.mpr hflag))]
      exact (Or.resolve_left a.property h).symm
  · by_cases h : leafColor S a.val = second
    · simp only [terminationSecondRead, ite_eq_left (hs.mp h), h]
    · rw [terminationSecondRead, ite_eq_right (fun hflag => h (hs.mpr hflag))]
      exact (Or.resolve_right a.property h).symm

end MatrixMultiplication.CompletionLabels
namespace MatrixMultiplication.CompletionLabels.TopologicalFlatten

open MatrixMultiplication.Foundation RecursiveCompletion

universe u v

def firstSide : ReaderPair → Color
  | .xy => .B
  | .xz => .B
  | .yz => .C

def secondSide : ReaderPair → Color
  | .xy => .C
  | .xz => .A
  | .yz => .A

structure NodeSchedule (A : Type u) where
  arity : ℕ → ℕ
  readerPair : ℕ → ReaderPair
  active : ℕ → A → Bool
  branch : (n : ℕ) → A → Fin (arity n)

namespace NodeSchedule

variable {A : Type u}

def Label (s : NodeSchedule A) (n : ℕ) : Type := Option (Fin (s.arity n))

instance labelFintype (s : NodeSchedule A) (n : ℕ) : Fintype (s.Label n) :=
  inferInstanceAs (Fintype (Option (Fin (s.arity n))))

def labels (s : NodeSchedule A) (n : ℕ) (a : A) : s.Label n :=
  if s.active n a then some (s.branch n a) else none

@[simp] theorem labels_of_inactive (s : NodeSchedule A) (n : ℕ) (a : A)
    (h : s.active n a = false) : s.labels n a = none := by
  simp [labels, h]; rfl

@[simp] theorem labels_of_active (s : NodeSchedule A) (n : ℕ) (a : A)
    (h : s.active n a = true) : s.labels n a = some (s.branch n a) := by
  simp [labels, h]; rfl

theorem labels_eq_iff (s : NodeSchedule A) (n : ℕ) (a b : A) :
    s.labels n a = s.labels n b ↔
      s.active n a = s.active n b ∧
        (s.active n a = true → s.branch n a = s.branch n b) := by
  cases ha : s.active n a <;> cases hb : s.active n b <;>
    simp [labels, ha, hb]
  · rfl
  · exact ⟨Option.some.inj, congrArg some⟩

def Complete (s : NodeSchedule A) (depth : ℕ) : Prop :=
  ∀ a b, (∀ n, n < depth →
    s.active n a = s.active n b ∧
      (s.active n a = true → s.branch n a = s.branch n b)) → a = b

end NodeSchedule

structure TopologicalSchedule (A : Type u) (Coord : Color → Type v) (depth : ℕ)
    extends NodeSchedule A where
  view : (c : Color) → A → Coord c
  activate : (n : ℕ) → LabelRecord toNodeSchedule.Label n → Bool
  activate_correct : ∀ n, n < depth → ∀ a,
    activate n (labelRecordOf toNodeSchedule.labels n a) = active n a
  localFirst : (n : ℕ) → Coord (firstSide (readerPair n)) → Fin (arity n)
  localSecond : (n : ℕ) → Coord (secondSide (readerPair n)) → Fin (arity n)
  localFirst_read : ∀ n, n < depth → ∀ a, active n a = true →
    localFirst n (view (firstSide (readerPair n)) a) = branch n a
  localSecond_read : ∀ n, n < depth → ∀ a, active n a = true →
    localSecond n (view (secondSide (readerPair n)) a) = branch n a

namespace TopologicalSchedule

variable {A : Type u} {Coord : Color → Type v} {depth : ℕ}

def pairs (s : TopologicalSchedule A Coord depth) : Fin depth → ReaderPair :=
  fun n => s.readerPair n.val

def firstReader (s : TopologicalSchedule A Coord depth) (n : ℕ)
    (prior : LabelRecord s.toNodeSchedule.Label n)
    (own : Coord (firstSide (s.readerPair n))) : s.toNodeSchedule.Label n :=
  if s.activate n prior then some (s.localFirst n own) else none

def secondReader (s : TopologicalSchedule A Coord depth) (n : ℕ)
    (prior : LabelRecord s.toNodeSchedule.Label n)
    (own : Coord (secondSide (s.readerPair n))) : s.toNodeSchedule.Label n :=
  if s.activate n prior then some (s.localSecond n own) else none

theorem firstReader_readable (s : TopologicalSchedule A Coord depth)
    (n : ℕ) (hn : n < depth) (a : A) :
    s.firstReader n (labelRecordOf s.toNodeSchedule.labels n a)
      (s.view (firstSide (s.readerPair n)) a) =
        s.toNodeSchedule.labels n a := by
  simp only [firstReader, NodeSchedule.labels, s.activate_correct n hn a]
  by_cases h : s.active n a = true
  · simp [h, s.localFirst_read n hn a h]; rfl
  · simp [h]; rfl

theorem secondReader_readable (s : TopologicalSchedule A Coord depth)
    (n : ℕ) (hn : n < depth) (a : A) :
    s.secondReader n (labelRecordOf s.toNodeSchedule.labels n a)
      (s.view (secondSide (s.readerPair n)) a) =
        s.toNodeSchedule.labels n a := by
  simp only [secondReader, NodeSchedule.labels, s.activate_correct n hn a]
  by_cases h : s.active n a = true
  · simp [h, s.localSecond_read n hn a h]; rfl
  · simp [h]; rfl

theorem readers_off_branch (s : TopologicalSchedule A Coord depth)
    (n : ℕ) (hn : n < depth) (a : A) (ha : s.active n a = false)
    (ownFirst : Coord (firstSide (s.readerPair n)))
    (ownSecond : Coord (secondSide (s.readerPair n))) :
    s.firstReader n (labelRecordOf s.toNodeSchedule.labels n a) ownFirst = none ∧
      s.secondReader n (labelRecordOf s.toNodeSchedule.labels n a) ownSecond = none := by
  simp [firstReader, secondReader, s.activate_correct n hn a, ha]; rfl

end TopologicalSchedule

theorem labelRecordOf_eq_prefix {A : Type u} {Label : ℕ → Type v}
    (labels : ∀ n, A → Label n) {a b : A} :
    ∀ {m k : ℕ}, k ≤ m →
      labelRecordOf labels m a = labelRecordOf labels m b →
      labelRecordOf labels k a = labelRecordOf labels k b := by
  intro m
  induction m with
  | zero =>
      intro k hk _
      have hk0 : k = 0 := Nat.eq_zero_of_le_zero hk
      subst k
      rfl
  | succ m ih =>
      intro k hk h
      rcases Nat.eq_or_lt_of_le hk with hk | hk
      · subst k
        exact h
      · exact ih (Nat.le_of_lt_succ hk) (congrArg Prod.fst h)

theorem label_eq_of_record_eq {A : Type u} {Label : ℕ → Type v}
    (labels : ∀ n, A → Label n) {depth n : ℕ} {a b : A}
    (h : labelRecordOf labels depth a = labelRecordOf labels depth b)
    (hn : n < depth) : labels n a = labels n b := by
  have hp : labelRecordOf labels (n + 1) a =
      labelRecordOf labels (n + 1) b :=
    labelRecordOf_eq_prefix labels (Nat.succ_le_of_lt hn) h
  exact congrArg Prod.snd hp

namespace NodeSchedule

theorem completeRecord_injective {A : Type u} (s : NodeSchedule A) (depth : ℕ)
    (complete : s.Complete depth) :
    Function.Injective (labelRecordOf s.labels depth) := by
  intro a b h
  apply complete a b
  intro n hn
  exact (s.labels_eq_iff n a b).mp (label_eq_of_record_eq s.labels h hn)

end NodeSchedule

namespace TopologicalSchedule

variable {A : Type u} {Coord : Color → Type v} {depth : ℕ}

theorem completeRecord_injective (s : TopologicalSchedule A Coord depth)
    (complete : s.toNodeSchedule.Complete depth) :
    Function.Injective (labelRecordOf s.toNodeSchedule.labels depth) :=
  s.toNodeSchedule.completeRecord_injective depth complete

end TopologicalSchedule
end MatrixMultiplication.CompletionLabels.TopologicalFlatten

namespace MatrixMultiplication.CompletionLabels

open RecursiveCompletion TopologicalFlatten
attribute [local instance] Classical.propDecidable Classical.decEq

variable {X Y Z : Type uCoord}

def ownerPair : Color → Color → ReaderPair
  | .B, .A | .A, .B => .xz
  | .A, .C | .C, .A => .yz
  | _, _ => .xy

theorem ownerPair_first_mem (center output : Color) (h : center ≠ output) :
    firstSide (ownerPair center output) = center ∨
      firstSide (ownerPair center output) = output := by
  cases center <;> cases output <;> simp_all [ownerPair, firstSide]

theorem ownerPair_second_mem (center output : Color) (h : center ≠ output) :
    secondSide (ownerPair center output) = center ∨
      secondSide (ownerPair center output) = output := by
  cases center <;> cases output <;> simp_all [ownerPair, secondSide]

def patternSideRead (S : FlaggedTensor X Y Z) (center output side : Color) (m : ℕ)
    (u : Fin m → Coordinate X Y Z side) : Fin m → Color :=
  if center = output then fun _ => center
  else if side = center then fun i => if ownerFlag S side (u i) then center else output
  else fun i => if ownerFlag S side (u i) then output else center

theorem patternSideRead_correct (S : FlaggedTensor X Y Z) (center output : Color) (m : ℕ)
    (a : Leaf (complete S center m))
    (ha : leafColor (complete S center m) a = output) (side : Color)
    (hs : center ≠ output → side = center ∨ side = output) :
    patternSideRead S center output side m
      (fun i => coordinate (slot S center m a i).val side) = pattern S center m a := by
  by_cases h : center = output
  · simp only [patternSideRead, ite_eq_left h]
    exact (pattern_eq_center S center m a (ha.trans h.symm)).symm
  · rcases hs h with heq | heq
    · subst side
      simp only [patternSideRead, ite_eq_right h, ite_true]
      have hr := centerRead_pattern S center m a
      rw [ha] at hr
      unfold centerRead at hr
      exact hr
    · subst side
      simp only [patternSideRead, ite_eq_right h, ite_eq_right (Ne.symm h)]
      have hr := outputRead_pattern S center m a
      rw [ha] at hr
      exact hr

theorem completion_pattern_readers (S : FlaggedTensor X Y Z) (center output : Color) (m : ℕ)
    (a : Leaf (complete S center m))
    (ha : leafColor (complete S center m) a = output) :
    patternSideRead S center output (firstSide (ownerPair center output)) m
        (fun i => coordinate (slot S center m a i).val (firstSide (ownerPair center output))) =
      pattern S center m a ∧
    patternSideRead S center output (secondSide (ownerPair center output)) m
        (fun i => coordinate (slot S center m a i).val (secondSide (ownerPair center output))) =
      pattern S center m a := by
  exact ⟨patternSideRead_correct S center output m a ha _ (ownerPair_first_mem center output),
    patternSideRead_correct S center output m a ha _ (ownerPair_second_mem center output)⟩

end MatrixMultiplication.CompletionLabels
namespace MatrixMultiplication.CompletionLabels.TopologicalFlatten

open MatrixMultiplication.Foundation RecursiveCompletion

attribute [local instance] Classical.propDecidable Classical.decEq

universe u v w z u' v' w'

namespace NodeSchedule

def PrefixDetermined {A : Type u} (s : NodeSchedule A) (depth : ℕ) : Prop :=
  ∀ n, n < depth → ∀ a b,
    labelRecordOf s.labels n a = labelRecordOf s.labels n b →
      s.active n a = s.active n b

def canonicalActivate {A : Type u} (s : NodeSchedule A) (n : ℕ)
    (prior : LabelRecord s.Label n) : Bool :=
  if h : ∃ a, labelRecordOf s.labels n a = prior then
    s.active n (Classical.choose h)
  else false

theorem canonicalActivate_correct {A : Type u} (s : NodeSchedule A) (depth : ℕ)
    (topological : s.PrefixDetermined depth) (n : ℕ) (hn : n < depth) (a : A) :
    s.canonicalActivate n (labelRecordOf s.labels n a) = s.active n a := by
  unfold canonicalActivate
  split_ifs with h
  · exact topological n hn _ a (Classical.choose_spec h)
  · exact False.elim (h ⟨a, rfl⟩)

end NodeSchedule

namespace TopologicalSchedule

def ofPrefixDetermined {A : Type u} {Coord : Color → Type v} {depth : ℕ}
    (s : NodeSchedule A) (view : (side : Color) → A → Coord side)
    (topological : s.PrefixDetermined depth)
    (localFirst : (n : ℕ) → Coord (firstSide (s.readerPair n)) → Fin (s.arity n))
    (localSecond : (n : ℕ) → Coord (secondSide (s.readerPair n)) → Fin (s.arity n))
    (first_correct : ∀ n, n < depth → ∀ a, s.active n a = true →
      localFirst n (view (firstSide (s.readerPair n)) a) = s.branch n a)
    (second_correct : ∀ n, n < depth → ∀ a, s.active n a = true →
      localSecond n (view (secondSide (s.readerPair n)) a) = s.branch n a) :
    TopologicalSchedule A Coord depth where
  toNodeSchedule := s
  view := view
  activate := s.canonicalActivate
  activate_correct := s.canonicalActivate_correct depth topological
  localFirst := localFirst
  localSecond := localSecond
  localFirst_read := first_correct
  localSecond_read := second_correct

end TopologicalSchedule

structure Program (A : Type u) (Coord : Color → Type v)
    (Context : Type z) (Code : Type w) (depth : ℕ) where
  context : A → Context
  view : (side : Color) → A → Coord side
  pair : ℕ → ReaderPair
  labels : ℕ → A → Code
  read : (n : ℕ) → (side : Color) → Context → (Fin n → Code) → Coord side → Code
  readable : ∀ n, n < depth → ∀ a side,
    (side = firstSide (pair n) ∨ side = secondSide (pair n)) →
      read n side (context a) (fun j => labels j.val a) (view side a) = labels n a

namespace Program

variable {A : Type u} {Coord : Color → Type v}
  {Context : Type z} {Code : Type w} {depth : ℕ}

def Complete (p : Program A Coord Context Code depth) : Prop :=
  ∀ a b, p.context a = p.context b →
    (∀ n, n < depth → p.labels n a = p.labels n b) → a = b

def pullback {B : Type u'} {NewCoord : Color → Type v'}
    (p : Program A Coord Context Code depth) (source : B → A)
    (view : (side : Color) → B → NewCoord side)
    (project : (side : Color) → NewCoord side → Coord side)
    (projects : ∀ side b, project side (view side b) = p.view side (source b)) :
    Program B NewCoord Context Code depth where
  context b := p.context (source b)
  view := view
  pair := p.pair
  labels n b := p.labels n (source b)
  read n side ctx prior own := p.read n side ctx prior (project side own)
  readable := by
    intro n hn b side hs
    simpa only [projects side b] using p.readable n hn (source b) side hs

theorem pullback_complete {B : Type u'} {NewCoord : Color → Type v'}
    (p : Program A Coord Context Code depth) (source : B → A)
    (view : (side : Color) → B → NewCoord side)
    (project : (side : Color) → NewCoord side → Coord side)
    (projects : ∀ side b, project side (view side b) = p.view side (source b))
    (complete : p.Complete) (injective : Function.Injective source) :
    (p.pullback source view project projects).Complete := by
  intro a b hc hl
  apply injective
  exact complete (source a) (source b) hc hl

def recode {NewCode : Type w'} (p : Program A Coord Context Code depth)
    (encode : Code → NewCode) (decode : NewCode → Code)
    (roundtrip : Function.LeftInverse decode encode) :
    Program A Coord Context NewCode depth where
  context := p.context
  view := p.view
  pair := p.pair
  labels n a := encode (p.labels n a)
  read n side ctx prior own := encode (p.read n side ctx (fun j => decode (prior j)) own)
  readable := by
    intro n hn a side hs
    have hprior : (fun j : Fin n => decode (encode (p.labels j.val a))) =
        (fun j : Fin n => p.labels j.val a) := by
      funext j
      exact roundtrip _
    dsimp
    rw [hprior, p.readable n hn a side hs]

theorem recode_complete {NewCode : Type w'} (p : Program A Coord Context Code depth)
    (encode : Code → NewCode) (decode : NewCode → Code)
    (roundtrip : Function.LeftInverse decode encode) (complete : p.Complete) :
    (p.recode encode decode roundtrip).Complete := by
  intro a b hc hl
  apply complete a b hc
  intro n hn
  exact roundtrip.injective (hl n hn)

def single (context : A → Context) (view : (side : Color) → A → Coord side)
    (pair : ReaderPair) (label : A → Code)
    (read : (side : Color) → Context → Coord side → Code)
    (correct : ∀ a side, (side = firstSide pair ∨ side = secondSide pair) →
      read side (context a) (view side a) = label a) :
    Program A Coord Context Code 1 where
  context := context
  view := view
  pair _ := pair
  labels _ := label
  read _ side ctx _ own := read side ctx own
  readable := by
    intro n hn a side hs
    exact correct a side hs

private def appendLabel (d : ℕ) (f g : ℕ → A → Code) (n : ℕ) (a : A) : Code :=
  if n < d then f n a else g (n - d) a

private def takeArray {n d : ℕ} (h : d ≤ n) (prior : Fin n → Code) : Fin d → Code :=
  fun j => prior ⟨j.val, lt_of_lt_of_le j.isLt h⟩

private def dropArray {n d : ℕ} (h : d ≤ n) (prior : Fin n → Code) : Fin (n - d) → Code :=
  fun j => prior ⟨d + j.val, by omega⟩

def append {OtherContext : Type z} {d e : ℕ}
    (p : Program A Coord Context Code d) (q : Program A Coord OtherContext Code e)
    (sameView : ∀ side a, p.view side a = q.view side a)
    (derive : Context → (Fin d → Code) → OtherContext)
    (derive_correct : ∀ a, derive (p.context a) (fun j => p.labels j.val a) = q.context a) :
    Program A Coord Context Code (d + e) where
  context := p.context
  view := p.view
  pair n := if n < d then p.pair n else q.pair (n - d)
  labels := appendLabel d p.labels q.labels
  read n side ctx prior own :=
    if h : n < d then p.read n side ctx prior own
    else q.read (n - d) side
      (derive ctx (takeArray (Nat.le_of_not_gt h) prior))
      (dropArray (Nat.le_of_not_gt h) prior) own
  readable := by
    intro n hn a side hs
    by_cases h : n < d
    · have hprior : (fun j : Fin n => appendLabel d p.labels q.labels j.val a) =
          (fun j : Fin n => p.labels j.val a) := by
        funext j
        simp [appendLabel, lt_trans j.isLt h]
      simp only [ite_eq_left h] at hs
      simp only [dite_eq_left h]
      rw [hprior]
      simpa only [appendLabel, ite_eq_left h] using p.readable n h a side hs
    · have hd : d ≤ n := Nat.le_of_not_gt h
      have hhead : takeArray hd (fun j : Fin n => appendLabel d p.labels q.labels j.val a) =
          (fun j : Fin d => p.labels j.val a) := by
        funext j
        simp [takeArray, appendLabel, j.isLt]
      have htail : dropArray hd (fun j : Fin n => appendLabel d p.labels q.labels j.val a) =
          (fun j : Fin (n - d) => q.labels j.val a) := by
        funext j
        have hj : ¬ d + j.val < d := by omega
        simp [dropArray, appendLabel, hj]
      have hnq : n - d < e := by omega
      simp only [ite_eq_right h] at hs
      simp only [dite_eq_right h]
      rw [hhead, htail, derive_correct a, sameView side a]
      simpa only [appendLabel, ite_eq_right h] using q.readable (n - d) hnq a side hs

theorem append_labels_left {OtherContext : Type z} {d e : ℕ}
    (p : Program A Coord Context Code d) (q : Program A Coord OtherContext Code e)
    (sameView : ∀ side a, p.view side a = q.view side a)
    (derive : Context → (Fin d → Code) → OtherContext)
    (derive_correct : ∀ a, derive (p.context a) (fun j => p.labels j.val a) = q.context a)
    (n : ℕ) (hn : n < d) (a : A) :
    (p.append q sameView derive derive_correct).labels n a = p.labels n a := by
  simp [append, appendLabel, hn]

theorem append_labels_right {OtherContext : Type z} {d e : ℕ}
    (p : Program A Coord Context Code d) (q : Program A Coord OtherContext Code e)
    (sameView : ∀ side a, p.view side a = q.view side a)
    (derive : Context → (Fin d → Code) → OtherContext)
    (derive_correct : ∀ a, derive (p.context a) (fun j => p.labels j.val a) = q.context a)
    (n : ℕ) (a : A) :
    (p.append q sameView derive derive_correct).labels (d + n) a = q.labels n a := by
  have h : ¬d + n < d := by omega
  simp [append, appendLabel, h]

theorem append_complete {OtherContext : Type z} {d e : ℕ}
    (p : Program A Coord Context Code d) (q : Program A Coord OtherContext Code e)
    (sameView : ∀ side a, p.view side a = q.view side a)
    (derive : Context → (Fin d → Code) → OtherContext)
    (derive_correct : ∀ a, derive (p.context a) (fun j => p.labels j.val a) = q.context a)
    (complete : q.Complete) :
    (p.append q sameView derive derive_correct).Complete := by
  intro a b hc hl
  change p.context a = p.context b at hc
  have hhead : (fun j : Fin d => p.labels j.val a) =
      (fun j : Fin d => p.labels j.val b) := by
    funext j
    have h := hl j.val (by omega)
    simpa only [append_labels_left p q sameView derive derive_correct j.val j.isLt] using h
  have hctx : q.context a = q.context b := by
    rw [← derive_correct a, ← derive_correct b, hc, hhead]
  apply complete a b hctx
  intro n hn
  have h := hl (d + n) (by omega)
  simpa only [append_labels_right] using h

def recordArray {Code : Type w} :
    (n : ℕ) → LabelRecord (fun _ => Code) n → Fin n → Code
  | 0, _, i => Fin.elim0 i
  | n + 1, prior, i =>
      if h : i.val < n then recordArray n prior.1 ⟨i.val, h⟩ else prior.2

theorem recordArray_labelRecordOf {B : Type u'} (labels : ℕ → B → Code)
    (n : ℕ) (a : B) :
    recordArray n (labelRecordOf labels n a) = (fun i => labels i.val a) := by
  induction n with
  | zero => funext i; exact Fin.elim0 i
  | succ n ih =>
      funext i
      by_cases h : i.val < n
      · simp only [recordArray, dite_eq_left h]
        exact congrFun ih ⟨i.val, h⟩
      · have hi : i.val = n := by omega
        simp [recordArray, hi, labelRecordOf]

def firstReader (p : Program A Coord Context Code depth) (n : ℕ) (ctx : Context)
    (prior : LabelRecord (fun _ => Code) n)
    (own : Coord (firstSide (p.pair n))) : Code :=
  p.read n (firstSide (p.pair n)) ctx (recordArray n prior) own

def secondReader (p : Program A Coord Context Code depth) (n : ℕ) (ctx : Context)
    (prior : LabelRecord (fun _ => Code) n)
    (own : Coord (secondSide (p.pair n))) : Code :=
  p.read n (secondSide (p.pair n)) ctx (recordArray n prior) own

theorem firstReader_readable (p : Program A Coord Context Code depth)
    (n : ℕ) (hn : n < depth) (a : A) :
    p.firstReader n (p.context a) (labelRecordOf p.labels n a)
      (p.view (firstSide (p.pair n)) a) = p.labels n a := by
  rw [firstReader, recordArray_labelRecordOf]
  exact p.readable n hn a _ (Or.inl rfl)

theorem secondReader_readable (p : Program A Coord Context Code depth)
    (n : ℕ) (hn : n < depth) (a : A) :
    p.secondReader n (p.context a) (labelRecordOf p.labels n a)
      (p.view (secondSide (p.pair n)) a) = p.labels n a := by
  rw [secondReader, recordArray_labelRecordOf]
  exact p.readable n hn a _ (Or.inr rfl)

theorem record_injective_on_context (p : Program A Coord Context Code depth)
    (complete : p.Complete) (ctx : Context) :
    Function.Injective
      (fun a : {a : A // p.context a = ctx} => labelRecordOf p.labels depth a.val) := by
  intro a b h
  apply Subtype.ext
  apply complete a.val b.val (a.property.trans b.property.symm)
  intro n hn
  exact label_eq_of_record_eq p.labels h hn

end Program
end MatrixMultiplication.CompletionLabels.TopologicalFlatten

namespace MatrixMultiplication.CompletionLabels

open MatrixMultiplication.Foundation RecursiveCompletion TopologicalFlatten
attribute [local instance] Classical.propDecidable Classical.decEq

variable {X Y Z : Type uCoord}

def rootColor (n : ℕ) : Color := if n = 0 then .B else if n = 1 then .A else .C

def rootIndex : Color → Fin 3
  | .B => 0
  | .A => 1
  | .C => 2

@[simp] theorem rootColor_rootIndex (c : Color) : rootColor (rootIndex c).val = c := by
  cases c <;> simp [rootIndex, rootColor]

def completionView (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ)
    (side : Color) (a : Leaf (complete S center m)) : Fin m → Coordinate X Y Z side :=
  fun i => coordinate (slot S center m a i).val side

def patternProgram (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ) :
    Program (Leaf (complete S center m)) (fun side => Fin m → Coordinate X Y Z side)
      Color (Option (Fin m → Color)) 3 where
  context := leafColor (complete S center m)
  view := completionView S center m
  pair n := ownerPair center (rootColor n)
  labels n a := if leafColor (complete S center m) a = rootColor n then
    some (pattern S center m a) else none
  read n side ctx _ own := if ctx = rootColor n then
    some (patternSideRead S center ctx side m own) else none
  readable := by
    intro n hn a side hs
    by_cases h : leafColor (complete S center m) a = rootColor n
    · simp only [ite_eq_left h]
      congr 1
      apply patternSideRead_correct S center _ m a rfl side
      intro hne
      have hmem : side = center ∨ side = rootColor n := by
        rcases hs with rfl | rfl
        · exact ownerPair_first_mem center (rootColor n) (by simpa only [h] using hne)
        · exact ownerPair_second_mem center (rootColor n) (by simpa only [h] using hne)
      simpa only [h] using hmem
    · simp only [ite_eq_right h]

def decodePattern (center : Color) (m : ℕ) (output : Color)
    (prior : Fin 3 → Option (Fin m → Color)) : Fin m → Color :=
  (prior (rootIndex output)).getD (fun _ => center)

theorem decodePattern_correct (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ)
    (a : Leaf (complete S center m)) :
    decodePattern center m ((patternProgram S center m).context a)
      (fun j => (patternProgram S center m).labels j.val a) = pattern S center m a := by
  simp [decodePattern, patternProgram]

end MatrixMultiplication.CompletionLabels
namespace MatrixMultiplication.CompletionLabels.TopologicalFlatten.Program

open MatrixMultiplication.Foundation RecursiveCompletion

universe u v w z

variable {A : Type u} {Coord : Color → Type v}
  {Context : Type z} {Code : Type w} {depth : ℕ}

private def powPast (d n : ℕ) (j : Fin (n % d)) : Fin n :=
  ⟨(n / d) * d + j.val, by
    calc
      (n / d) * d + j.val < (n / d) * d + n % d :=
        Nat.add_lt_add_left j.isLt _
      _ = n := by
        simpa only [Nat.mul_comm] using Nat.div_add_mod n d⟩

private def powLabel [Inhabited Code]
    (p : Program A Coord Context Code depth) (m n : ℕ) (a : Fin m → A) : Code :=
  if hi : n / depth < m then
    p.labels (n % depth) (a ⟨n / depth, hi⟩)
  else default

private theorem powLabel_at [Inhabited Code]
    (p : Program A Coord Context Code depth) (m : ℕ)
    (a : Fin m → A) (i : Fin m) {k : ℕ} (hk : k < depth) :
    powLabel p m (i.val * depth + k) a = p.labels k (a i) := by
  have hd : 0 < depth := lt_of_le_of_lt (Nat.zero_le k) hk
  have hquot : (i.val * depth + k) / depth = i.val := by
    rw [Nat.add_comm, Nat.add_mul_div_right _ _ hd,
      Nat.div_eq_of_lt hk, Nat.zero_add]
  have hrem : (i.val * depth + k) % depth = k := by
    rw [Nat.mul_add_mod_self_right, Nat.mod_eq_of_lt hk]
  simp only [powLabel, hquot, hrem, dite_eq_left i.isLt]

def pow [Inhabited Code] (p : Program A Coord Context Code depth) (m : ℕ) :
    Program (Fin m → A) (fun side => Fin m → Coord side)
      (Fin m → Context) Code (m * depth) where
  context a i := p.context (a i)
  view side a i := p.view side (a i)
  pair n := p.pair (n % depth)
  labels := powLabel p m
  read n side ctx prior own :=
    if hi : n / depth < m then
      p.read (n % depth) side (ctx ⟨n / depth, hi⟩)
        (fun j => prior (powPast depth n j)) (own ⟨n / depth, hi⟩)
    else default
  readable := by
    intro n hn a side hs
    have hd : 0 < depth := by
      by_contra h
      have hzero : depth = 0 := by omega
      simp [hzero] at hn
    have hi : n / depth < m := (Nat.div_lt_iff_lt_mul hd).2 hn
    let i : Fin m := ⟨n / depth, hi⟩
    have hlocal : n % depth < depth := Nat.mod_lt n hd
    have hprior :
        (fun j : Fin (n % depth) => powLabel p m (powPast depth n j).val a) =
        (fun j : Fin (n % depth) => p.labels j.val (a i)) := by
      funext j
      change powLabel p m (i.val * depth + j.val) a = p.labels j.val (a i)
      exact powLabel_at p m a i (lt_trans j.isLt hlocal)
    simp only [dite_eq_left hi]
    change p.read (n % depth) side (p.context (a i))
      (fun j : Fin (n % depth) => powLabel p m (powPast depth n j).val a)
      (p.view side (a i)) = powLabel p m n a
    rw [hprior]
    simpa only [powLabel, dite_eq_left hi] using
      p.readable (n % depth) hlocal (a i) side hs

theorem pow_labels [Inhabited Code] (p : Program A Coord Context Code depth) (m : ℕ)
    (a : Fin m → A) (i : Fin m) (n : ℕ) (hn : n < depth) :
    (p.pow m).labels (i.val * depth + n) a = p.labels n (a i) :=
  powLabel_at p m a i hn

theorem pow_complete [Inhabited Code]
    (p : Program A Coord Context Code depth) (m : ℕ) (complete : p.Complete) :
    (p.pow m).Complete := by
  intro a b hc hl
  funext i
  apply complete (a i) (b i)
  · exact congrFun hc i
  · intro k hk
    have hindex : i.val * depth + k < m * depth := by
      calc
        i.val * depth + k < i.val * depth + depth := Nat.add_lt_add_left hk _
        _ = (i.val + 1) * depth := by rw [Nat.add_mul, Nat.one_mul]
        _ ≤ m * depth := Nat.mul_le_mul_right depth (Nat.succ_le_of_lt i.isLt)
    have h := hl (i.val * depth + k) hindex
    change powLabel p m (i.val * depth + k) a =
      powLabel p m (i.val * depth + k) b at h
    rw [powLabel_at p m a i hk, powLabel_at p m b i hk] at h
    exact h

end MatrixMultiplication.CompletionLabels.TopologicalFlatten.Program

namespace MatrixMultiplication.CompletionLabels

open MatrixMultiplication.Foundation RecursiveCompletion TopologicalFlatten

universe w
variable {X Y Z : Type uCoord} {Code : Type w} {depth : ℕ}

abbrev CompletionCode (m : ℕ) (Code : Type w) := Option ((Fin m → Color) ⊕ Code)

def encodePattern {m : ℕ} : Option (Fin m → Color) → CompletionCode m Code
  | none => none
  | some pattern => some (.inl pattern)

def decodePatternCode {m : ℕ} : CompletionCode m Code → Option (Fin m → Color)
  | some (.inl pattern) => some pattern
  | _ => none

theorem patternCode_roundtrip {m : ℕ} :
    Function.LeftInverse (decodePatternCode (Code := Code)) (encodePattern (m := m)) := by
  intro c
  cases c <;> rfl

def encodeOld {m : ℕ} (c : Code) : CompletionCode m Code := some (.inr c)

def decodeOld [Inhabited Code] {m : ℕ} : CompletionCode m Code → Code
  | some (.inr c) => c
  | _ => default

theorem oldCode_roundtrip [Inhabited Code] {m : ℕ} :
    Function.LeftInverse (decodeOld (Code := Code) (m := m)) encodeOld := by
  intro c
  rfl

def inheritedProgram (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ)
    [Inhabited Code]
    (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
    (view_eq : ∀ side a, p.view side a = coordinate a.val side) :
    Program (Leaf (complete S center m)) (fun side => Fin m → Coordinate X Y Z side)
      (Fin m → Color) (CompletionCode m Code) (m * depth) :=
  let old := p.recode encodeOld decodeOld oldCode_roundtrip
  (old.pow m).pullback (slot S center m) (completionView S center m)
    (fun _ => id) (by
      intro side a
      funext i
      exact (view_eq side (slot S center m a i)).symm)

theorem inheritedProgram_complete (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ)
    [Inhabited Code]
    (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
    (view_eq : ∀ side a, p.view side a = coordinate a.val side)
    (complete : p.Complete) :
    (inheritedProgram S center m p view_eq).Complete := by
  exact Program.pullback_complete
    ((p.recode encodeOld decodeOld oldCode_roundtrip).pow m)
    (slot S center m) (completionView S center m) (fun _ => id)
    (by intro side a; funext i; exact (view_eq side (slot S center m a i)).symm)
    (Program.pow_complete _ m
      (Program.recode_complete p encodeOld decodeOld oldCode_roundtrip complete))
    (slot_injective S center m)

private def completionContextDecoder (center : Color) (m : ℕ) (output : Color)
    (prior : Fin 3 → CompletionCode m Code) : Fin m → Color :=
  decodePattern center m output (fun i => decodePatternCode (prior i))

private theorem completionContextDecoder_correct
    (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ) [Inhabited Code]
    (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
    (context_eq : ∀ a, p.context a = leafColor S a)
    (view_eq : ∀ side a, p.view side a = coordinate a.val side)
    (a : Leaf (complete S center m)) :
    completionContextDecoder (Code := Code) center m
      (((patternProgram S center m).recode (encodePattern (Code := Code)) decodePatternCode
        patternCode_roundtrip).context a)
      (fun j => ((patternProgram S center m).recode (encodePattern (Code := Code)) decodePatternCode
        patternCode_roundtrip).labels j.val a) =
      (inheritedProgram S center m p view_eq).context a := by
  change decodePattern center m (leafColor (complete S center m) a)
    (fun j => decodePatternCode (Code := Code)
      (encodePattern ((patternProgram S center m).labels j.val a))) =
      (fun i => p.context (slot S center m a i))
  have hr (c : Option (Fin m → Color)) :
      decodePatternCode (encodePattern c : CompletionCode m Code) = c := patternCode_roundtrip c
  simp only [hr]
  exact (decodePattern_correct S center m a).trans (by
    funext i
    exact (context_eq (slot S center m a i)).symm)

def completionProgram (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ)
    [Inhabited Code]
    (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
    (context_eq : ∀ a, p.context a = leafColor S a)
    (view_eq : ∀ side a, p.view side a = coordinate a.val side) :
    Program (Leaf (complete S center m)) (fun side => Fin m → Coordinate X Y Z side)
      Color (CompletionCode m Code) (3 + m * depth) :=
  ((patternProgram S center m).recode encodePattern decodePatternCode patternCode_roundtrip).append
    (inheritedProgram S center m p view_eq) (fun _ _ => rfl)
    (completionContextDecoder center m)
    (completionContextDecoder_correct S center m p context_eq view_eq)

theorem completionProgram_complete (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ)
    [Inhabited Code]
    (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
    (context_eq : ∀ a, p.context a = leafColor S a)
    (view_eq : ∀ side a, p.view side a = coordinate a.val side)
    (complete : p.Complete) :
    (completionProgram S center m p context_eq view_eq).Complete := by
  exact Program.append_complete
    ((patternProgram S center m).recode encodePattern decodePatternCode patternCode_roundtrip)
    (inheritedProgram S center m p view_eq) (fun _ _ => rfl)
    (completionContextDecoder center m)
    (completionContextDecoder_correct S center m p context_eq view_eq)
    (inheritedProgram_complete S center m p view_eq complete)

def coordinateWord (m : ℕ) (side : Color) :
    Coordinate (Fin m → X) (Fin m → Y) (Fin m → Z) side →
      (Fin m → Coordinate X Y Z side) := by
  cases side <;> exact id

theorem coordinateWord_coordinate (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ)
    (side : Color) (a : Leaf (complete S center m)) :
    coordinateWord m side (coordinate a.val side) = completionView S center m side a := by
  cases side <;> rfl

def completionLocalProgram (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ)
    [Inhabited Code]
    (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
    (context_eq : ∀ a, p.context a = leafColor S a)
    (view_eq : ∀ side a, p.view side a = coordinate a.val side) :
    Program (Leaf (complete S center m))
      (Coordinate (Fin m → X) (Fin m → Y) (Fin m → Z))
      Color (CompletionCode m Code) (3 + m * depth) :=
  (completionProgram S center m p context_eq view_eq).pullback id
    (fun side a => coordinate a.val side) (coordinateWord m)
    (coordinateWord_coordinate S center m)

theorem completionLocalProgram_complete (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ)
    [Inhabited Code]
    (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
    (context_eq : ∀ a, p.context a = leafColor S a)
    (view_eq : ∀ side a, p.view side a = coordinate a.val side)
    (complete : p.Complete) :
    (completionLocalProgram S center m p context_eq view_eq).Complete := by
  exact Program.pullback_complete (completionProgram S center m p context_eq view_eq)
    id (fun side a => coordinate a.val side) (coordinateWord m)
    (coordinateWord_coordinate S center m)
    (completionProgram_complete S center m p context_eq view_eq complete)
    Function.injective_id

structure ReadableTensor (S : FlaggedTensor X Y Z) where
  Code : Type
  [finiteCode : Fintype Code]
  [inhabitedCode : Inhabited Code]
  depth : ℕ
  program : Program (Leaf S) (Coordinate X Y Z) Color Code depth
  context_eq : ∀ a, program.context a = leafColor S a
  view_eq : ∀ side a, program.view side a = coordinate a.val side
  complete : program.Complete

attribute [instance] ReadableTensor.finiteCode ReadableTensor.inhabitedCode

namespace ReadableTensor

def raise (S : FlaggedTensor X Y Z) (r : ReadableTensor S) (center : Color) (m : ℕ) :
    ReadableTensor (RecursiveCompletion.complete S center m) where
  Code := CompletionCode m r.Code
  depth := 3 + m * r.depth
  program := completionLocalProgram S center m r.program r.context_eq r.view_eq
  context_eq _ := rfl
  view_eq _ _ := rfl
  complete := completionLocalProgram_complete S center m r.program r.context_eq r.view_eq r.complete

def script (S : FlaggedTensor X Y Z) (r : ReadableTensor S) :
    (s : Script) → ReadableTensor (Script.tensor S s)
  | .base => r
  | .step prior center m => raise _ (script S r prior) center m

end ReadableTensor

end MatrixMultiplication.CompletionLabels
namespace MatrixMultiplication.CompletionLabels

open MatrixMultiplication.Foundation RecursiveCompletion TopologicalFlatten

attribute [local instance] Classical.propDecidable Classical.decEq

universe u

variable {X Y Z : Type uCoord} {Code : Type u} {depth : ℕ}

def terminationSideRead (S : FlaggedTensor X Y Z) (first second side : Color)
    (own : Coordinate X Y Z side) : Color :=
  if side = first then
    if ownerFlag S side own then first else second
  else if ownerFlag S side own then second else first

theorem terminationSideRead_correct (S : FlaggedTensor X Y Z)
    (first second : Color) (distinct : first ≠ second)
    (a : RetainedLeaf S first second) (side : Color)
    (hs : side = first ∨ side = second) :
    terminationSideRead S first second side (coordinate a.val.val side) =
      leafColor S a.val := by
  rcases hs with h | h
  · subst side
    simpa only [terminationSideRead, ite_eq_left rfl, ite_true, terminationFirstRead] using
      (termination_readable S first second a).1
  · subst side
    simpa only [terminationSideRead, ite_eq_right (Ne.symm distinct), terminationSecondRead] using
      (termination_readable S first second a).2

def terminationRoot (S : FlaggedTensor X Y Z) (first second : Color)
    (distinct : first ≠ second) :
    Program (RetainedLeaf S first second) (Coordinate X Y Z) PUnit Color 1 :=
  Program.single (fun _ => PUnit.unit)
    (fun side a => coordinate a.val.val side)
    (ownerPair first second) (fun a => leafColor S a.val)
    (fun side _ own => terminationSideRead S first second side own)
    (by
      intro a side hs
      apply terminationSideRead_correct S first second distinct a side
      rcases hs with h | h
      · rw [h]
        exact ownerPair_first_mem first second distinct
      · rw [h]
        exact ownerPair_second_mem first second distinct)

def terminationInherited (S : FlaggedTensor X Y Z) (first second : Color)
    (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
    (view_eq : ∀ side a, p.view side a = coordinate a.val side) :
    Program (RetainedLeaf S first second) (Coordinate X Y Z) Color Code depth :=
  p.pullback Subtype.val (fun side a => coordinate a.val.val side) (fun _ => id)
    (fun side a => (view_eq side a.val).symm)

theorem terminationInherited_complete (S : FlaggedTensor X Y Z) (first second : Color)
    (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
    (view_eq : ∀ side a, p.view side a = coordinate a.val side)
    (complete : p.Complete) :
    (terminationInherited S first second p view_eq).Complete := by
  unfold terminationInherited
  exact p.pullback_complete
    (fun a : RetainedLeaf S first second => a.val)
    (fun side a => coordinate a.val.val side) (fun _ => id)
    (fun side a => (view_eq side a.val).symm) complete Subtype.val_injective

def terminationDecodeColor (fallback : Color) : Color ⊕ Code → Color
  | .inl color => color
  | .inr _ => fallback

def terminationDecodeOld [Inhabited Code] : Color ⊕ Code → Code
  | .inl _ => default
  | .inr code => code

def terminationProgram [Inhabited Code]
    (S : FlaggedTensor X Y Z) (first second : Color) (distinct : first ≠ second)
    (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
    (context_eq : ∀ a, p.context a = leafColor S a)
    (view_eq : ∀ side a, p.view side a = coordinate a.val side) :
    Program (RetainedLeaf S first second) (Coordinate X Y Z)
      PUnit (Color ⊕ Code) (1 + depth) :=
  ((terminationRoot S first second distinct).recode Sum.inl
    (terminationDecodeColor first) (fun _ => rfl)).append
    ((terminationInherited S first second p view_eq).recode Sum.inr
      terminationDecodeOld (fun _ => rfl))
    (by intro side a; rfl)
    (fun _ prior => terminationDecodeColor first (prior 0))
    (by
      intro a
      change leafColor S a.val = p.context a.val
      exact (context_eq a.val).symm)

theorem terminationProgram_complete [Inhabited Code]
    (S : FlaggedTensor X Y Z) (first second : Color) (distinct : first ≠ second)
    (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
    (context_eq : ∀ a, p.context a = leafColor S a)
    (view_eq : ∀ side a, p.view side a = coordinate a.val side)
    (complete : p.Complete) :
    (terminationProgram S first second distinct p context_eq view_eq).Complete := by
  exact Program.append_complete
    ((terminationRoot S first second distinct).recode Sum.inl
      (terminationDecodeColor first) (fun _ => rfl))
    ((terminationInherited S first second p view_eq).recode Sum.inr
      terminationDecodeOld (fun _ => rfl))
    (by intro side a; rfl)
    (fun _ prior => terminationDecodeColor first (prior 0))
    (by
      intro a
      change leafColor S a.val = p.context a.val
      exact (context_eq a.val).symm)
    (Program.recode_complete (terminationInherited S first second p view_eq)
      Sum.inr terminationDecodeOld (fun _ => rfl)
      (terminationInherited_complete S first second p view_eq complete))

@[simp] theorem terminationProgram_context [Inhabited Code]
    (S : FlaggedTensor X Y Z) (first second : Color) (distinct : first ≠ second)
    (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
    (context_eq : ∀ a, p.context a = leafColor S a)
    (view_eq : ∀ side a, p.view side a = coordinate a.val side)
    (a : RetainedLeaf S first second) :
    (terminationProgram S first second distinct p context_eq view_eq).context a =
      PUnit.unit := rfl

@[simp] theorem terminationProgram_view [Inhabited Code]
    (S : FlaggedTensor X Y Z) (first second : Color) (distinct : first ≠ second)
    (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
    (context_eq : ∀ a, p.context a = leafColor S a)
    (view_eq : ∀ side a, p.view side a = coordinate a.val side)
    (side : Color) (a : RetainedLeaf S first second) :
    (terminationProgram S first second distinct p context_eq view_eq).view side a =
      coordinate a.val.val side := rfl

theorem terminationRecord_injective [Inhabited Code]
    (S : FlaggedTensor X Y Z) (first second : Color) (distinct : first ≠ second)
    (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth)
    (context_eq : ∀ a, p.context a = leafColor S a)
    (view_eq : ∀ side a, p.view side a = coordinate a.val side)
    (complete : p.Complete) :
    Function.Injective (labelRecordOf
      (terminationProgram S first second distinct p context_eq view_eq).labels (1 + depth)) := by
  intro a b h
  apply terminationProgram_complete S first second distinct p context_eq view_eq complete a b rfl
  intro n hn
  exact label_eq_of_record_eq _ h hn

end MatrixMultiplication.CompletionLabels

end

end OAI