lean/OAI/Computability/BinPacking/CookLevin/InitializationMachineAt.lean

import OAI.Computability.BinPacking.CookLevin.InitializationMachine
import OAI.Computability.BinPacking.CookLevin.ValidityMachine

namespace OAI

namespace BinPackingGames.Foundations.Complexity.CookLevin.InitializationMachineAt

open Turing PostfixModel
open Reduction.MachineSubstitution (pushWord stepAux_pushWord)
open InitializationMachine (Label termTokens bodySteps selectorSteps)

variable {K Λ σ : Type} [DecidableEq K]

abbrev Ports (K : Type) := Fin 6 ↪ K
abbrev Alphabet (_ : K) := Bool
abbrev State (σ : Type) := (σ × Bool) × Option Bool

def initialState (ambient : σ) : State σ := ((ambient, false), none)

def frame (p : Ports K) (base : K → List Bool) (contents : Fin 6 → List Bool)
    (k : K) : List Bool :=
  if k = p 0 then contents 0 else if k = p 1 then contents 1
  else if k = p 2 then contents 2 else if k = p 3 then contents 3
  else if k = p 4 then contents 4 else if k = p 5 then contents 5 else base k

@[simp] theorem frame_at (p : Ports K) (base : K → List Bool)
    (contents : Fin 6 → List Bool) (j : Fin 6) : frame p base contents (p j) = contents j := by
  fin_cases j <;> simp [frame, p.injective.eq_iff]

theorem frame_other (p : Ports K) (base : K → List Bool) (contents : Fin 6 → List Bool)
    (k : K) (hk : ∀ j, k ≠ p j) : frame p base contents k = base k := by
  simp [frame, hk]

theorem update_frame (p : Ports K) (base : K → List Bool) (contents : Fin 6 → List Bool)
    (j : Fin 6) (replacement : List Bool) :
    Function.update (frame p base contents) (p j) replacement =
      frame p base (Function.update contents j replacement) := by
  funext k
  by_cases hk : ∃ r, p r = k
  · obtain ⟨r, rfl⟩ := hk
    by_cases hr : r = j
    · subst r; simp
    · simp [p.injective.ne hr, hr]
  · have hn : ∀ r, k ≠ p r := fun r h => hk ⟨r, h.symm⟩
    simp [Function.update_of_ne (hn j), frame_other p base _ k hn]

def contents (m i d : Nat) (output count : List Bool) (j : Fin 6) : List Bool :=
  match j.val with
  | 0 => encodeWord m
  | 1 => encodeWord i
  | 2 => encodeWord d
  | 3 => []
  | 4 => output
  | _ => count

def tapes (p : Ports K) (base : K → List Bool) (m i d : Nat)
    (output count : List Bool) : K → List Bool := frame p base (contents m i d output count)

@[simp] theorem tapes_at (p : Ports K) (base : K → List Bool) (m i d : Nat)
    (output count : List Bool) (j : Fin 6) :
    tapes p base m i d output count (p j) = contents m i d output count j := by
  exact frame_at p base _ j

theorem tapes_other (p : Ports K) (base : K → List Bool) (m i d : Nat)
    (output count : List Bool) (k : K) (hk : ∀ j, k ≠ p j) :
    tapes p base m i d output count k = base k := frame_other p base _ k hk

theorem update_remaining (p : Ports K) (base : K → List Bool) (m i d r : Nat)
    (output count : List Bool) :
    Function.update (tapes p base m i d output count) (p 0) (encodeWord r) =
      tapes p base r i d output count := by
  rw [tapes, update_frame]
  congr 1
  funext j
  fin_cases j <;> simp [contents]

theorem update_current (p : Ports K) (base : K → List Bool) (m i d r : Nat)
    (output count : List Bool) :
    Function.update (tapes p base m i d output count) (p 1) (encodeWord r) =
      tapes p base m r d output count := by
  rw [tapes, update_frame]
  congr 1
  funext j
  fin_cases j <;> simp [contents]

theorem update_threshold (p : Ports K) (base : K → List Bool) (m i d r : Nat)
    (output count : List Bool) :
    Function.update (tapes p base m i d output count) (p 2) (encodeWord r) =
      tapes p base m i r output count := by
  rw [tapes, update_frame]
  congr 1
  funext j
  fin_cases j <;> simp [contents]

theorem update_reversed (p : Ports K) (base : K → List Bool) (m i d : Nat)
    (output count replacement : List Bool) :
    Function.update (tapes p base m i d output count) (p 4) replacement =
      tapes p base m i d replacement count := by
  rw [tapes, update_frame]
  congr 1
  funext j
  fin_cases j <;> simp [contents]

theorem update_count (p : Ports K) (base : K → List Bool) (m i d : Nat)
    (output count replacement : List Bool) :
    Function.update (tapes p base m i d output count) (p 5) replacement =
      tapes p base m i d output replacement := by
  rw [tapes, update_frame]
  congr 1
  funext j
  fin_cases j <;> simp [contents]

theorem push_current (p : Ports K) (base : K → List Bool) (m i d : Nat)
    (output count : List Bool) :
    Function.update (tapes p base m i d output count) (p 1) (true :: encodeWord i) =
      tapes p base m (i + 1) d output count := by
  rw [show true :: encodeWord i = encodeWord (i + 1) by
    simp [encodeWord, List.replicate_succ]]
  exact update_current p base m i d (i + 1) output count

def statement (p : Ports K) (label : Label ↪ Λ) : Label → TM2.Stmt (Alphabet (K := K)) Λ (State σ)
  | .guard => MachineUnaryCounter.guard (p 0) (label .inputTag) (label .done)
  | .inputTag => pushWord (p 4) (encodeWord 5) (.goto fun _ => label .scan)
  | .scan => MachineTransducerCopy.scanLoop (p 1) (p 3) false
      (fun _ b => label (.emit b)) (label .restore)
  | .emit b => MachineTransducerCopy.emitter (p 4) (fun _ _ => false)
      (fun _ symbol => [symbol]) (label .scan) false b
  | .restore => Reduction.MachineTransfer.loopAt (p 3) (p 1) id false
      (label .restore) (some (label .test))
  | .test => MachineUnaryCounter.guard (p 2) (label (.result false)) (label (.result true))
  | .result b => pushWord (p 4) (encodeWords [if b then 1 else 0, 3])
      (.push (p 5) (fun _ => true) (.push (p 5) (fun _ => true)
        (.push (p 5) (fun _ => true)
          (.push (p 1) (fun _ => true) (.goto fun _ => label .guard)))))
  | .done => .halt

def Agrees (p : Ports K) (label : Label ↪ Λ)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) : Prop :=
  ∀ l, l ≠ .done → program (label l) = statement p label l

private theorem chain {α : Type*} {f : α → α} {x y z : α} {m n : Nat}
    (first : f^[m] x = y) (second : f^[n] y = z) : f^[m + n] x = z := by
  rw [Nat.add_comm m n, Function.iterate_add_apply, first, second]

theorem inputTagStep (p : Ports K) (label : Label ↪ Λ)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) (ha : Agrees p label program)
    (base : K → List Bool) (m i d : Nat) (output count : List Bool) (ambient : σ) :
    TM2.step program ⟨some (label .inputTag), initialState ambient, tapes p base m i d output count⟩ =
      some ⟨some (label .scan), initialState ambient,
        tapes p base m i d ((encodeWord 5).reverse ++ output) count⟩ := by
  change some (TM2.stepAux (program (label .inputTag)) _ _) = _
  rw [ha .inputTag (by decide), statement, stepAux_pushWord]
  simp [TM2.stepAux, contents, update_reversed]

private theorem identity_output (control : Bool) (input : List Bool) :
    Reduction.MachineTransducer.output (fun (_ : Bool) _ => false)
      (fun _ symbol => [symbol]) control input = input := by
  induction input generalizing control with
  | nil => rfl
  | cons b input ih => simp [Reduction.MachineTransducer.output, ih]

theorem indexTrace (p : Ports K) (label : Label ↪ Λ)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) (ha : Agrees p label program)
    (base : K → List Bool) (m i d : Nat) (output count : List Bool) (ambient : σ) :
    (MachineComposition.advance (TM2.step program))^[3 * (i + 1) + 2]
      (some ⟨some (label .scan), initialState ambient, tapes p base m i d output count⟩) =
      some ⟨some (label .test), initialState ambient,
        tapes p base m i d ((encodeWord i).reverse ++ output) count⟩ := by
  have h := MachineTransducerCopy.transduceCopyTrace (p 1) (p 3) (p 4)
    (p.injective.ne (by decide)) (p.injective.ne (by decide)) (p.injective.ne (by decide))
    false (fun _ _ => false) (fun _ symbol => [symbol])
    (label .scan) (label .restore) (fun _ b => label (.emit b)) (some (label .test)) program
    (ha .scan (by decide))
    (by intro control symbol; exact ha (.emit symbol) (by intro h; cases h))
    (ha .restore (by decide)) (tapes p base m i d output count)
    (by simp [contents]) ambient false none
  simpa [contents, identity_output, update_reversed, initialState] using h

theorem thresholdStep (p : Ports K) (label : Label ↪ Λ)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) (ha : Agrees p label program)
    (base : K → List Bool) (m i d : Nat) (output count : List Bool) (ambient : σ) :
    TM2.step program ⟨some (label .test), initialState ambient, tapes p base m i d output count⟩ =
      some ⟨some (label (.result (decide (d = 0)))), initialState ambient,
        tapes p base m i (d - 1) output count⟩ := by
  change some (TM2.stepAux (program (label .test)) _ _) = _
  rw [ha .test (by decide)]
  cases d with
  | zero => simp [statement, MachineUnaryCounter.guard, TM2.stepAux, contents, initialState, encodeWord]
  | succ d =>
    simp only [statement, MachineUnaryCounter.guard, TM2.stepAux, initialState,
      tapes_at, contents, encodeWord, List.replicate_succ, List.cons_append]
    change some (⟨some (label (.result false)), initialState ambient,
      Function.update (tapes p base m i (d + 1) output count) (p 2) (encodeWord d)⟩ :
      TM2.Cfg (Alphabet (K := K)) Λ (State σ)) = _
    rw [update_threshold]
    simp [initialState]

theorem resultStep (p : Ports K) (label : Label ↪ Λ)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) (ha : Agrees p label program)
    (base : K → List Bool) (m i d : Nat) (output count : List Bool) (ambient : σ) (b : Bool) :
    TM2.step program ⟨some (label (.result b)), initialState ambient, tapes p base m i d output count⟩ =
      some ⟨some (label .guard), initialState ambient, tapes p base m (i + 1) d
        ((encodeWords [if b then 1 else 0, 3]).reverse ++ output) (true :: true :: true :: count)⟩ := by
  change some (TM2.stepAux (program (label (.result b))) _ _) = _
  rw [ha (.result b) (by intro h; cases h), statement, stepAux_pushWord]
  simp [TM2.stepAux, contents, update_reversed, update_count, push_current]

theorem bodyTrace (p : Ports K) (label : Label ↪ Λ)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) (ha : Agrees p label program)
    (base : K → List Bool) (m i d : Nat) (output count : List Bool) (ambient : σ) :
    (MachineComposition.advance (TM2.step program))^[bodySteps i]
      (some ⟨some (label .inputTag), initialState ambient, tapes p base m i d output count⟩) =
      some ⟨some (label .guard), initialState ambient, tapes p base m (i + 1) (d - 1)
        ((tokenBits (termTokens i d)).reverse ++ output) (true :: true :: true :: count)⟩ := by
  have tag : (MachineComposition.advance (TM2.step program))^[1]
      (some ⟨some (label .inputTag), initialState ambient, tapes p base m i d output count⟩) =
      some ⟨some (label .scan), initialState ambient,
        tapes p base m i d ((encodeWord 5).reverse ++ output) count⟩ := by
    simpa only [Function.iterate_one, MachineComposition.advance_some] using
      inputTagStep p label program ha base m i d output count ambient
  have index := indexTrace p label program ha base m i d
    ((encodeWord 5).reverse ++ output) count ambient
  let out := (encodeWord i).reverse ++ ((encodeWord 5).reverse ++ output)
  have test : (MachineComposition.advance (TM2.step program))^[1]
      (some ⟨some (label .test), initialState ambient, tapes p base m i d out count⟩) =
      some ⟨some (label (.result (decide (d = 0)))), initialState ambient,
        tapes p base m i (d - 1) out count⟩ := by
    simpa only [Function.iterate_one, MachineComposition.advance_some] using
      thresholdStep p label program ha base m i d out count ambient
  have result : (MachineComposition.advance (TM2.step program))^[1]
      (some ⟨some (label (.result (decide (d = 0)))), initialState ambient,
        tapes p base m i (d - 1) out count⟩) =
      some ⟨some (label .guard), initialState ambient, tapes p base m (i + 1) (d - 1)
        ((encodeWords [if decide (d = 0) then 1 else 0, 3]).reverse ++ out)
        (true :: true :: true :: count)⟩ := by
    simpa only [Function.iterate_one, MachineComposition.advance_some] using
      resultStep p label program ha base m i (d - 1) out count ambient (decide (d = 0))
  have whole := chain (chain (chain tag index) test) result
  have ht : 1 + (3 * (i + 1) + 2) + 1 + 1 = bodySteps i := by
    unfold InitializationMachine.bodySteps
    omega
  rw [ht] at whole
  simpa only [InitializationMachine.termTokens_bits, List.reverse_append,
    List.append_assoc, out] using whole

theorem guardStep_zero (p : Ports K) (label : Label ↪ Λ)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) (ha : Agrees p label program)
    (base : K → List Bool) (i d : Nat) (output count : List Bool) (ambient : σ) :
    TM2.step program ⟨some (label .guard), initialState ambient, tapes p base 0 i d output count⟩ =
      some ⟨some (label .done), initialState ambient, tapes p base 0 i d output count⟩ := by
  change some (TM2.stepAux (program (label .guard)) _ _) = _
  rw [ha .guard (by decide)]
  simp [statement, MachineUnaryCounter.guard, TM2.stepAux, contents, initialState, encodeWord]

theorem guardStep_succ (p : Ports K) (label : Label ↪ Λ)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) (ha : Agrees p label program)
    (base : K → List Bool) (m i d : Nat) (output count : List Bool) (ambient : σ) :
    TM2.step program ⟨some (label .guard), initialState ambient, tapes p base (m + 1) i d output count⟩ =
      some ⟨some (label .inputTag), initialState ambient, tapes p base m i d output count⟩ := by
  change some (TM2.stepAux (program (label .guard)) _ _) = _
  rw [ha .guard (by decide)]
  simp only [statement, MachineUnaryCounter.guard, TM2.stepAux, initialState,
    tapes_at, contents, encodeWord, List.replicate_succ, List.cons_append]
  change some (⟨some (label .inputTag), initialState ambient,
    Function.update (tapes p base (m + 1) i d output count) (p 0) (encodeWord m)⟩ :
    TM2.Cfg (Alphabet (K := K)) Λ (State σ)) = _
  rw [update_remaining]
  rfl

theorem prepend_three (n : Nat) (count : List Bool) :
    List.replicate n true ++ (true :: true :: true :: count) =
      List.replicate (n + 3) true ++ count := by
  change List.replicate n true ++ (List.replicate 3 true ++ count) = _
  rw [← List.append_assoc, List.replicate_append_replicate]

theorem selectorTrace (p : Ports K) (label : Label ↪ Λ)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) (ha : Agrees p label program)
    (base : K → List Bool) (m i d : Nat) (output count : List Bool) (ambient : σ) :
    (MachineComposition.advance (TM2.step program))^[selectorSteps i m]
      (some ⟨some (label .guard), initialState ambient, tapes p base m i d output count⟩) =
      some ⟨some (label .done), initialState ambient, tapes p base 0 (i + m) (d - m)
        ((tokenBits (InitializationTemplate.selectorLoopTokens m i d)).reverse ++ output)
        (List.replicate (3 * m) true ++ count)⟩ := by
  induction m generalizing i d output count with
  | zero =>
    simpa only [InitializationMachine.selectorSteps, InitializationTemplate.selectorLoopTokens,
      InitializationTemplate.forTokens, tokenBits, tokenWords, List.flatMap_nil,
      encodeWords, List.reverse_nil, List.nil_append, Nat.add_zero, Nat.sub_zero,
      Nat.mul_zero, List.replicate_zero, Function.iterate_one, MachineComposition.advance_some] using
      guardStep_zero p label program ha base i d output count ambient
  | succ m ih =>
    have guard : (MachineComposition.advance (TM2.step program))^[1]
        (some ⟨some (label .guard), initialState ambient, tapes p base (m + 1) i d output count⟩) =
        some ⟨some (label .inputTag), initialState ambient, tapes p base m i d output count⟩ := by
      simpa only [Function.iterate_one, MachineComposition.advance_some] using
        guardStep_succ p label program ha base m i d output count ambient
    have body := bodyTrace p label program ha base m i d output count ambient
    have rest := ih (i + 1) (d - 1) ((tokenBits (termTokens i d)).reverse ++ output)
      (true :: true :: true :: count)
    have whole := chain (chain guard body) rest
    rw [prepend_three] at whole
    have hs : InitializationTemplate.selectorLoopTokens (m + 1) i d =
        termTokens i d ++ InitializationTemplate.selectorLoopTokens m (i + 1) (d - 1) :=
      InitializationTemplate.selectorLoopTokens_succ m i d
    rw [hs, InitializationMachine.tokens_append_bits, List.reverse_append, List.append_assoc]
    simpa only [InitializationMachine.selectorSteps, Nat.add_assoc, Nat.add_comm,
      Nat.add_left_comm, Nat.sub_sub, Nat.mul_succ] using whole

def selectorInTime (p : Ports K) (label : Label ↪ Λ)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) (ha : Agrees p label program)
    (base : K → List Bool) (m i d : Nat) (output count : List Bool) (ambient : σ) :
    StateTransition.EvalsToInTime (TM2.step program)
      ⟨some (label .guard), initialState ambient, tapes p base m i d output count⟩
      (some ⟨some (label .done), initialState ambient, tapes p base 0 (i + m) (d - m)
        ((tokenBits (InitializationTemplate.selectorLoopTokens m i d)).reverse ++ output)
        (List.replicate (3 * m) true ++ count)⟩)
      (m * (3 * (i + m) + 6) + 1) where
  steps := selectorSteps i m
  evals_in_steps := selectorTrace p label program ha base m i d output count ambient
  steps_le_m := InitializationMachine.selectorSteps_le i m

theorem increment_count (m c : Nat) (suffix : List Bool) :
    List.replicate (3 * m) true ++ (encodeWord c ++ suffix) =
      encodeWord (c + 3 * m) ++ suffix := by
  simp only [encodeWord, ← List.append_assoc, List.replicate_append_replicate]
  rw [Nat.add_comm (3 * m) c]

omit [DecidableEq K] in
theorem standalone_agrees (p : Ports K) :
    Agrees (σ := σ) p (Function.Embedding.refl Label)
      (statement p (Function.Embedding.refl Label)) := by
  intro l _
  rfl

def machine [Fintype K] [Fintype σ] (p : Ports K) (ambient : σ) : FinTM2 where
  K := K
  k₀ := p 0
  k₁ := p 4
  Γ _ := Bool
  Λ := Label
  main := .guard
  σ := State σ
  initialState := initialState ambient
  m := statement p (Function.Embedding.refl Label)

def closurePorts (p : Ports K) (closing : K) (hc : ∀ j, closing ≠ p j) : OrClosure.Ports K where
  remaining := closing
  reversed := p 4
  count := p 5
  remaining_ne_reversed := hc 4
  remaining_ne_count := hc 5
  reversed_ne_count := p.injective.ne (by decide)

theorem presenceTrace (p : Ports K) (label : Label ↪ Λ)
    (closing : K) (hc : ∀ j, closing ≠ p j) (again : Λ) (exit : Option Λ)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) (ha : Agrees p label program)
    (atSeed : program (label .done) = OrClosure.seed (closurePorts p closing hc) again)
    (atLoop : program again = OrClosure.loop (closurePorts p closing hc) again exit)
    (base : K → List Bool) (q n : Nat) (suffix output count : List Bool)
    (hclosing : base closing = encodeWord (q + 1) ++ suffix) (ambient : σ) :
    let selected := tapes p base 0 (q + 1) (n + 1 - (q + 1))
      ((tokenBits (InitializationTemplate.selectorLoopTokens (q + 1) 0 (n + 1))).reverse ++ output)
      (List.replicate (3 * (q + 1)) true ++ count)
    (MachineComposition.advance (TM2.step program))^[selectorSteps 0 (q + 1) + (q + 1 + 2)]
      (some ⟨some (label .guard), initialState ambient, tapes p base (q + 1) 0 (n + 1) output count⟩) =
      some ⟨exit, initialState ambient,
        OrClosure.frame (closurePorts p closing hc) selected (encodeWord 0 ++ suffix)
          ((tokenBits (InitializationTemplate.presenceTokens q n)).reverse ++ output)
          (List.replicate (4 * (q + 1) + 1) true ++ count)⟩ := by
  dsimp only
  let out := (tokenBits (InitializationTemplate.selectorLoopTokens (q + 1) 0 (n + 1))).reverse ++ output
  let cnt := List.replicate (3 * (q + 1)) true ++ count
  let selected := tapes p base 0 (q + 1) (n + 1 - (q + 1)) out cnt
  have hs := selectorTrace p label program ha base (q + 1) 0 (n + 1) output count ambient
  simp only [Nat.zero_add] at hs
  have hr : selected closing = encodeWord (q + 1) ++ suffix :=
    (tapes_other p base _ _ _ out cnt closing hc).trans hclosing
  have ho : selected (p 4) = out := by simp [selected, contents]
  have hn : selected (p 5) = cnt := by simp [selected, contents]
  have hf : OrClosure.frame (closurePorts p closing hc) selected
      (encodeWord (q + 1) ++ suffix) out cnt = selected := by
    simpa only [closurePorts, hr, ho, hn] using
      OrClosure.frame_self (closurePorts p closing hc) selected
  have hclose := OrClosure.closureTrace (closurePorts p closing hc) (label .done) again exit
    program atSeed atLoop selected (q + 1) suffix out cnt (ambient, false) none
  rw [hf] at hclose
  have whole := chain hs hclose
  have hout : (tokenBits (InitializationTemplate.closeOr (q + 1))).reverse ++ out =
      (tokenBits (InitializationTemplate.presenceTokens q n)).reverse ++ output := by
    rw [← InitializationTemplate.selectorLoopTokens_presence q n,
      InitializationMachine.tokens_append_bits, List.reverse_append, List.append_assoc]
  have hcnt : List.replicate (q + 1 + 1) true ++ cnt =
      List.replicate (4 * (q + 1) + 1) true ++ count := by
    dsimp only [cnt]
    rw [← List.append_assoc, List.replicate_append_replicate]
    congr 2
    omega
  rw [hout, hcnt] at whole
  exact whole

theorem presenceSteps_le (q : Nat) :
    selectorSteps 0 (q + 1) + (q + 1 + 2) ≤
      (q + 1) * (3 * (q + 1) + 7) + 3 := by
  have h := InitializationMachine.selectorSteps_le 0 (q + 1)
  simp only [Nat.zero_add] at h
  rw [show 3 * (q + 1) + 7 = (3 * (q + 1) + 6) + 1 by omega,
    Nat.mul_add, Nat.mul_one]
  omega

theorem presence_count (q c : Nat) (suffix : List Bool) :
    List.replicate (4 * (q + 1) + 1) true ++ (encodeWord c ++ suffix) =
      encodeWord (c + (4 * (q + 1) + 1)) ++ suffix := by
  simp only [encodeWord, ← List.append_assoc, List.replicate_append_replicate]
  rw [Nat.add_comm (4 * (q + 1) + 1) c]

end BinPackingGames.Foundations.Complexity.CookLevin.InitializationMachineAt

end OAI