lean/OAI/LinearAlgebra/MatrixMultiplication/FieldHistory/Schedule.lean

import OAI.LinearAlgebra.MatrixMultiplication.FieldHistory.Populations

namespace OAI

/-! Finite extraction histories, inherited masks and recovery bounds. -/

noncomputable section

namespace MatrixMultiplication.AllFieldHistory

open AllFieldParameters
open scoped BigOperators
attribute [local instance] Classical.propDecidable Classical.decEq

def initialAncestor {K : ℕ} : CanonicalHistory K → Initial K
  | .initial h => h
  | .afterA h => h.1.val
  | .afterB h => h.1.val.1.val
  | .partC h => h.1.val.1.val.1.val
  | .afterC h => h.1.1.val.1.val.1.val

def ancestrySplits {K : ℕ} : CanonicalHistory K → List (Shape × Bool)
  | .initial _ => []
  | .afterA h => [(aSplit h, h.2.2)]
  | .afterB h => [(aSplit h.1.val, h.1.val.2.2), (bSplit h, h.2.2)]
  | .partC h => [(aSplit h.1.val.1.val, h.1.val.1.val.2.2),
      (bSplit h.1.val, h.1.val.2.2)]
  | .afterC h => [(aSplit h.1.1.val.1.val, h.1.1.val.1.val.2.2),
      (bSplit h.1.1.val, h.1.1.val.2.2), (cSplit h, h.2.2)]

def ancestrySubdivisions {K : ℕ} : CanonicalHistory K → List ℕ
  | .initial _ | .afterA _ | .afterB _ => []
  | .partC h => [h.2.val]
  | .afterC h => [h.1.2.val]

def historyKey {K : ℕ} (h : History K) : JointPopulation.HistoryKey where
  lot := (initialAncestor h.1).1.val
  initialShape := initialShape (initialAncestor h.1)
  physicalPlacement := h.2
  parentSplits := ancestrySplits h.1
  subdivisions := ancestrySubdivisions h.1

theorem placement_preserved {K : ℕ} (h : CanonicalHistory K) (phi psi : Placement)
    (heq : historyKey (h, phi) = historyKey (h, psi)) : phi = psi :=
  congrArg JointPopulation.HistoryKey.physicalPlacement heq

inductive Work (K : ℕ) where
  | stageA (h : InitialPositive K)
  | stageB (h : APositive K)
  | stageC (h : PartC K)
  deriving Fintype

def Work.source {K : ℕ} : Work K → CanonicalHistory K
  | .stageA h => .initial h.val
  | .stageB h => .afterA h.val
  | .stageC h => .partC h

def Work.stage {K : ℕ} : Work K → Fin 3
  | .stageA _ => 0
  | .stageB _ => 1
  | .stageC _ => 2

def Work.lot {K : ℕ} (w : Work K) : Fin K := (initialAncestor w.source).1

def Work.halfLength {K : ℕ} : Work K → ℕ
  | .stageA _ => 4
  | .stageB _ => 2
  | .stageC _ => 1

def Work.parentShape {K : ℕ} : Work K → Shape
  | .stageA h => initialShape h.val
  | .stageB h => aShape h.val
  | .stageC h => cShapeParent h

def Work.Branch {K : ℕ} : Work K → Type
  | .stageA h => ASplit h
  | .stageB h => BSplit h
  | .stageC _ => Fin 4

instance {K : ℕ} (w : Work K) : Fintype w.Branch := by
  cases w <;> dsimp [Work.Branch] <;> infer_instance

def Work.child {K : ℕ} (w : Work K) (b : w.Branch) (right : Bool) : CanonicalHistory K :=
  match w with
  | .stageA h => .afterA ⟨h, b, right⟩
  | .stageB h => .afterB ⟨h, b, right⟩
  | .stageC h => .afterC (h, b, right)

def Work.splitShape {K : ℕ} (w : Work K) (b : w.Branch) : Shape :=
  match w with
  | .stageA h => aSplit ⟨h, b, false⟩
  | .stageB h => bSplit ⟨h, b, false⟩
  | .stageC h => cSplit (h, b, false)

abbrev PlacedWork (K : ℕ) := Work K × Placement
abbrev Active (K tick : ℕ) := {w : PlacedWork K //
  FiniteSchedule.lotTick w.1.lot w.1.stage = tick}

theorem active_tick_lt {K tick : ℕ} (h : Active K tick) : tick < K + 2 := by
  rw [← h.property]
  exact FiniteSchedule.lotTick_lt h.val.1.lot h.val.1.stage

def branchPopulation {K : ℕ} (allocation : Allocation) (dilation : ℕ)
    (w : PlacedWork K) (b : w.1.Branch) : ℕ :=
  population allocation dilation (w.1.child b false, w.2)

theorem branchPopulation_half {K : ℕ} (allocation : Allocation) (dilation : ℕ)
    (w : PlacedWork K) (b : w.1.Branch) (right : Bool) :
    population allocation dilation (w.1.child b right, w.2) =
      branchPopulation allocation dilation w b := by
  rcases w with ⟨w, phi⟩
  cases right with
  | false => rfl
  | true =>
      cases w with
      | stageA h => exact (a_half_counts_eq allocation dilation h b phi).symm
      | stageB h => exact (b_half_counts_eq allocation dilation h b phi).symm
      | stageC h => exact (c_half_counts_eq allocation dilation h b phi).symm

theorem branchPopulation_sum {K : ℕ} (allocation : Allocation) (dilation : ℕ)
    (w : PlacedWork K) :
    (∑ b : w.1.Branch, branchPopulation allocation dilation w b) =
      population allocation dilation (w.1.source, w.2) := by
  rcases w with ⟨w, phi⟩
  cases w with
  | stageA h => exact a_population_transition allocation dilation h false phi
  | stageB h => exact b_population_transition allocation dilation h false phi
  | stageC h => exact c_population_transition allocation dilation h false phi

def terminal {K : ℕ} : CanonicalHistory K → Prop
  | .initial h => initialShape h ∉ positiveInitial
  | .afterA h => aShape h ∉ positiveSecond
  | .afterB h => positive (bShape h) ≠ true
  | .partC _ => False
  | .afterC _ => True

def resident {K : ℕ} (tick : ℕ) : CanonicalHistory K → Prop
  | .initial h => initialShape h ∈ positiveInitial → tick ≤ h.1.val
  | .afterA h => h.1.val.1.val + 1 ≤ tick ∧
      (aShape h ∈ positiveSecond → tick ≤ h.1.val.1.val + 1)
  | .afterB h => h.1.val.1.val.1.val + 2 ≤ tick ∧ positive (bShape h) ≠ true
  | .partC h => tick = h.1.val.1.val.1.val.1.val + 2
  | .afterC h => h.1.1.val.1.val.1.val.1.val + 3 ≤ tick

abbrev State (K tick : ℕ) := {h : History K // resident tick h.1}

theorem terminal_carries {K tick : ℕ} (h : CanonicalHistory K)
    (hr : resident tick h) (ht : terminal h) : resident (tick + 1) h := by
  cases h with
  | initial h => exact fun hp => False.elim (ht hp)
  | afterA h => exact ⟨by have := hr.1; omega, fun hp => False.elim (ht hp)⟩
  | afterB h => exact ⟨by have := hr.1; omega, hr.2⟩
  | partC h => exact False.elim ht
  | afterC h => dsimp [resident] at hr ⊢; omega

theorem work_source_resident {K : ℕ} (w : Work K) :
    resident (FiniteSchedule.lotTick w.lot w.stage) w.source := by
  cases w with
  | stageA h => simp [resident, Work.source, Work.lot, Work.stage,
      initialAncestor, FiniteSchedule.lotTick]
  | stageB h => simp [resident, Work.source, Work.lot, Work.stage,
      initialAncestor, FiniteSchedule.lotTick]
  | stageC h => simp [resident, Work.source, Work.lot, Work.stage,
      initialAncestor, FiniteSchedule.lotTick]

theorem a_child_resident {K : ℕ} (h : InitialPositive K) (b : ASplit h) (right : Bool) :
    resident (h.val.1.val + 1) (.afterA ⟨h, b, right⟩) := by
  simp [resident]

theorem c_child_resident {K : ℕ} (h : PartC K) (b : Fin 4) (right : Bool) :
    resident ((Work.stageC h).lot.val + 3) (.afterC (h, b, right)) := by
  simp [resident, Work.lot, Work.source, initialAncestor]

end MatrixMultiplication.AllFieldHistory

end

end OAI