lean/OAI/Computability/BinPacking/Search/ExtensionVerifierMachine.lean

import Mathlib.Tactic.DeriveFintype
import OAI.Computability.BinPacking.Arithmetic.GraphTallyMachine

namespace OAI

namespace BinPackingGap.ExtensionVerifierMachine.Fields

open Turing
open BinPackingGames.Foundations.Complexity
open MachineComposition
open BinPackingGames.Reduction.MachineTransfer

inductive Block
  | bins | items | fixed
  deriving DecidableEq

protected abbrev Block.enumList : List Block := [.bins, .items, .fixed]

protected theorem Block.enumList_getElem?_ctorIdx_eq (x : Block) :
    Block.enumList[x.ctorIdx]? = some x := by
  cases x <;> rfl

protected theorem Block.enumList_nodup : Block.enumList.Nodup := by decide

instance : Fintype Block where
  elems := ⟨Block.enumList, Block.enumList_nodup⟩
  complete x := by cases x <;> decide

inductive Field
  | bins | numerator | denominator
  deriving DecidableEq

protected abbrev Field.enumList : List Field := [.bins, .numerator, .denominator]

protected theorem Field.enumList_getElem?_ctorIdx_eq (x : Field) :
    Field.enumList[x.ctorIdx]? = some x := by
  cases x <;> rfl

protected theorem Field.enumList_nodup : Field.enumList.Nodup := by decide

instance : Fintype Field where
  elems := ⟨Field.enumList, Field.enumList_nodup⟩
  complete x := by cases x <;> decide

inductive Mode
  | flag (field : Field)
  | digit (field : Field)
  | items
  | fixed
  deriving DecidableEq, Fintype

def Field.block : Field → Block
  | .bins => .bins
  | .numerator | .denominator => .items

def afterField : Field → Mode
  | .bins => .items
  | .numerator => .flag .denominator
  | .denominator => .items

def Mode.block : Mode → Block
  | .flag f | .digit f => f.block
  | .items => .items
  | .fixed => .fixed

def nextMode : Mode → Bool → Mode
  | .flag f, true => .digit f
  | .flag f, false => afterField f
  | .digit f, _ => .flag f
  | .items, true => .flag .numerator
  | .items, false => .fixed
  | .fixed, _ => .fixed

abbrev Words := Block → List Bool

def prepend (words : Words) (block : Block) (chunk : List Bool) : Words :=
  Function.update words block (chunk ++ words block)

@[simp] theorem prepend_nil (words : Words) (block : Block) :
    prepend words block [] = words := by
  simp [prepend]

theorem prepend_prepend (words : Words) (block : Block) (first second : List Bool) :
    prepend (prepend words block first) block second =
      prepend words block (second ++ first) := by
  funext k
  by_cases h : k = block
  · subst k; simp [prepend, List.append_assoc]
  · simp [prepend, h]

def run : Mode → Words → List Bool → Mode × Words
  | mode, words, [] => (mode, words)
  | mode, words, bit :: rest =>
      run (nextMode mode bit) (prepend words mode.block [bit]) rest

theorem run_frame (field : Field) (bits suffix : List Bool) (words : Words) :
    run (.flag field) words (BinPackingCompleteness.BinaryEncoding.frame bits ++ suffix) =
      run (afterField field)
        (prepend words field.block (BinPackingCompleteness.BinaryEncoding.frame bits).reverse)
        suffix := by
  induction bits generalizing words with
  | nil => simp [BinPackingCompleteness.BinaryEncoding.frame, run, nextMode, Mode.block]
  | cons bit bits ih =>
      simp only [BinPackingCompleteness.BinaryEncoding.frame, List.cons_append, run,
        nextMode, Mode.block]
      rw [ih]
      simp only [prepend_prepend, List.reverse_cons, List.append_assoc,
        List.singleton_append]

theorem run_nat (field : Field) (n : Nat) (suffix : List Bool) (words : Words) :
    run (.flag field) words (BinaryEncoding.natBits n ++ suffix) =
      run (afterField field)
        (prepend words field.block (BinaryEncoding.natBits n).reverse) suffix :=
  run_frame field n.bits suffix words

theorem run_items (items : RawInstance) (suffix : List Bool) (words : Words) :
    run .items words (BinaryEncoding.rawInstanceBits items ++ suffix) =
      run .fixed
        (prepend words .items (BinaryEncoding.rawInstanceBits items).reverse) suffix := by
  induction items generalizing words with
  | nil => simp [BinaryEncoding.rawInstanceBits, BinaryEncoding.listBits, run,
      nextMode, Mode.block]
  | cons item items ih =>
      change run (.flag .numerator) (prepend words .items [true])
        (BinaryEncoding.natBits item.1 ++ BinaryEncoding.natBits item.2 ++
          BinaryEncoding.rawInstanceBits items ++ suffix) = _
      simp only [List.append_assoc]
      rw [run_nat]
      change run (.flag .denominator)
        (prepend (prepend words .items [true]) .items
          (BinaryEncoding.natBits item.1).reverse)
        (BinaryEncoding.natBits item.2 ++
          (BinaryEncoding.rawInstanceBits items ++ suffix)) = _
      rw [run_nat]
      change run .items _ (BinaryEncoding.rawInstanceBits items ++ suffix) = _
      rw [ih]
      simp only [Field.block, prepend_prepend, BinaryEncoding.rawInstanceBits,
        BinaryEncoding.listBits, BinaryEncoding.pairBits, List.reverse_cons,
        List.reverse_append, List.append_assoc]

theorem run_fixed (input : List Bool) (words : Words) :
    run .fixed words input = (.fixed, prepend words .fixed input.reverse) := by
  induction input generalizing words with
  | nil => simp [run]
  | cons bit input ih =>
      simpa only [run, nextMode, Mode.block, prepend_prepend,
        List.reverse_cons] using ih (prepend words .fixed [bit])

def encodedWords (bins : Nat) (items : RawInstance) (fixed : List (Option Nat)) : Words
  | .bins => BinaryEncoding.natBits bins
  | .items => BinaryEncoding.rawInstanceBits items
  | .fixed => BinaryEncoding.listBits (BinaryEncoding.optionBits BinaryEncoding.natBits) fixed

def empty : Words := fun _ => []

def reversed (words : Words) : Words := fun block => (words block).reverse

@[simp] theorem reversed_reversed (words : Words) : reversed (reversed words) = words := by
  funext block
  simp [reversed]

def wordLength (words : Words) : Nat :=
  (words .bins).length + (words .items).length + (words .fixed).length

@[simp] theorem wordLength_empty : wordLength empty = 0 := rfl

@[simp] theorem wordLength_reversed (words : Words) :
    wordLength (reversed words) = wordLength words := by simp [wordLength, reversed]

theorem wordLength_prepend (words : Words) (block : Block) (chunk : List Bool) :
    wordLength (prepend words block chunk) = wordLength words + chunk.length := by
  cases block <;> simp [wordLength, prepend] <;> omega

theorem run_wordLength (mode : Mode) (words : Words) (input : List Bool) :
    wordLength (run mode words input).2 = wordLength words + input.length := by
  induction input generalizing mode words with
  | nil => simp [run]
  | cons bit input ih =>
      rw [run, ih, wordLength_prepend]
      simp only [List.length_cons, List.length_nil]
      omega

theorem run_extension (bins : Nat) (items : RawInstance) (fixed : List (Option Nat)) :
    run (.flag .bins) empty (BinaryEncoding.extensionBits bins items fixed) =
      (.fixed, reversed (encodedWords bins items fixed)) := by
  unfold BinaryEncoding.extensionBits
  rw [List.append_assoc, run_nat]
  change run .items _ (_ ++ _) = _
  rw [run_items, run_fixed]
  congr 1
  funext block
  cases block <;> simp [prepend, empty, reversed, encodedWords, Field.block]

inductive Label
  | scan | restoreBins | restoreItems | restoreFixed
  deriving DecidableEq

protected abbrev Label.enumList : List Label := [.scan, .restoreBins, .restoreItems,
  .restoreFixed]

protected theorem Label.enumList_getElem?_ctorIdx_eq (x : Label) :
    Label.enumList[x.ctorIdx]? = some x := by
  cases x <;> rfl

protected theorem Label.enumList_nodup : Label.enumList.Nodup := by decide

instance : Fintype Label where
  elems := ⟨Label.enumList, Label.enumList_nodup⟩
  complete x := by cases x <;> decide

abbrev Alphabet (_ : Fin 7) := Bool
abbrev State := Mode × Option Bool

def scanFinish : TM2.Stmt Alphabet Label State :=
  .load (fun state => (nextMode state.1 (state.2.getD false), none))
    (.goto fun _ => .scan)

def instruction : Label → TM2.Stmt Alphabet Label State
  | .scan =>
      .pop 0 (fun state head => (state.1, head))
        (.branch (fun state => state.2.isSome)
          (.branch (fun state => decide (state.1.block = .bins))
            (.push 1 (fun state => state.2.getD false) scanFinish)
            (.branch (fun state => decide (state.1.block = .items))
              (.push 2 (fun state => state.2.getD false) scanFinish)
              (.push 3 (fun state => state.2.getD false) scanFinish)))
          (.load (fun _ => (.flag .bins, none)) (.goto fun _ => .restoreBins)))
  | .restoreBins => loopAt 1 4 id false .restoreBins (some .restoreItems)
  | .restoreItems => loopAt 2 5 id false .restoreItems (some .restoreFixed)
  | .restoreFixed => loopAt 3 6 id false .restoreFixed none

abbrev machine : FinTM2 where
  K := Fin 7
  k₀ := 0
  k₁ := 4
  Γ := Alphabet
  Λ := Label
  main := .scan
  σ := State
  initialState := (.flag .bins, none)
  m := instruction

def tapes (input : List Bool) (saved output : Words) : Fin 7 → List Bool
  | 0 => input
  | 1 => saved .bins
  | 2 => saved .items
  | 3 => saved .fixed
  | 4 => output .bins
  | 5 => output .items
  | _ => output .fixed

def cfg (label : Option Label) (input : List Bool) (saved output : Words)
    (mode : Mode := .flag .bins) (register : Option Bool := none) : machine.Cfg :=
  ⟨label, (mode, register), tapes input saved output⟩

private theorem update_input (input replacement : List Bool) (saved output : Words) :
    Function.update (tapes input saved output) 0 replacement =
      tapes replacement saved output := by
  funext k; fin_cases k <;> rfl

def savedTape : Block → Fin 7
  | .bins => 1
  | .items => 2
  | .fixed => 3

def outputTape : Block → Fin 7
  | .bins => 4
  | .items => 5
  | .fixed => 6

private theorem update_saved (input : List Bool) (saved output : Words)
    (block : Block) (replacement : List Bool) :
    Function.update (tapes input saved output) (savedTape block) replacement =
      tapes input (Function.update saved block replacement) output := by
  funext k; cases block <;> fin_cases k <;> rfl

private theorem update_output (input : List Bool) (saved output : Words)
    (block : Block) (replacement : List Bool) :
    Function.update (tapes input saved output) (outputTape block) replacement =
      tapes input saved (Function.update output block replacement) := by
  funext k; cases block <;> fin_cases k <;> rfl

theorem step_scan_empty (saved output : Words) (mode : Mode) (register : Option Bool) :
    machine.step (cfg (some .scan) [] saved output mode register) =
      some (cfg (some .restoreBins) [] saved output) := by
  change some (TM2.stepAux (instruction .scan) _ _) = _
  simp [instruction, cfg, TM2.stepAux, tapes, update_input]
  all_goals rfl

theorem step_scan_cons (bit : Bool) (input : List Bool) (saved output : Words)
    (mode : Mode) (register : Option Bool) :
    machine.step (cfg (some .scan) (bit :: input) saved output mode register) =
      some (cfg (some .scan) input (prepend saved mode.block [bit]) output
        (nextMode mode bit)) := by
  change some (TM2.stepAux (instruction .scan) _ _) = _
  cases mode with
  | flag field =>
      cases field <;>
        simp [instruction, scanFinish, cfg, TM2.stepAux, Mode.block, Field.block,
          update_input, ← update_saved, savedTape, prepend, tapes] <;> rfl
  | digit field =>
      cases field <;>
        simp [instruction, scanFinish, cfg, TM2.stepAux, Mode.block, Field.block,
          update_input, ← update_saved, savedTape, prepend, tapes] <;> rfl
  | items =>
      simp [instruction, scanFinish, cfg, TM2.stepAux, Mode.block,
        update_input, ← update_saved, savedTape, prepend, tapes]; rfl
  | fixed =>
      simp [instruction, scanFinish, cfg, TM2.stepAux, Mode.block,
        update_input, ← update_saved, savedTape, prepend, tapes]; rfl

theorem scanTrace (input : List Bool) (saved output : Words) (mode : Mode)
    (register : Option Bool) :
    (advance machine.step)^[input.length + 1]
      (some (cfg (some .scan) input saved output mode register)) =
      some (cfg (some .restoreBins) [] (run mode saved input).2 output) := by
  induction input generalizing mode saved register with
  | nil =>
      simpa only [List.length_nil, Nat.zero_add, Function.iterate_one,
        advance_some, run] using step_scan_empty saved output mode register
  | cons bit input ih =>
      rw [List.length_cons, Function.iterate_succ_apply]
      simp only [advance_some]
      rw [step_scan_cons]
      simpa only [run] using ih (saved := prepend saved mode.block [bit])
        (mode := nextMode mode bit) (register := none)

theorem initList_eq (input : List Bool) :
    initList machine input = cfg (some .scan) input empty empty := by
  unfold initList cfg
  congr 1
  funext k
  fin_cases k <;> rfl

theorem scan_extension (bins : Nat) (items : RawInstance) (fixed : List (Option Nat)) :
    (advance machine.step)^[(BinaryEncoding.extensionBits bins items fixed).length + 1]
      (some (initList machine (BinaryEncoding.extensionBits bins items fixed))) =
      some (cfg (some .restoreBins) [] (reversed (encodedWords bins items fixed)) empty) := by
  rw [initList_eq]
  simpa only [run_extension] using
    scanTrace (BinaryEncoding.extensionBits bins items fixed) empty empty (.flag .bins) none

def restoreLabel : Block → Label
  | .bins => .restoreBins
  | .items => .restoreItems
  | .fixed => .restoreFixed

def nextRestore : Block → Option Label
  | .bins => some .restoreItems
  | .items => some .restoreFixed
  | .fixed => none

theorem restoreTrace (block : Block) (saved output : Words) :
    (advance machine.step)^[(saved block).length + 1]
      (some (cfg (some (restoreLabel block)) [] saved output)) =
      some (cfg (nextRestore block) [] (Function.update saved block [])
        (prepend output block (saved block).reverse)) := by
  change (nextAt (outputTape block) instruction)^[(saved block).length + 1]
    (some (cfg (some (restoreLabel block)) [] saved output)) =
    some (cfg (nextRestore block) [] (Function.update saved block [])
      (prepend output block (saved block).reverse))
  have distinct : savedTape block ≠ outputTape block := by cases block <;> decide
  have atLoop : instruction (restoreLabel block) =
      loopAt (savedTape block) (outputTape block) id false
        (restoreLabel block) (nextRestore block) := by cases block <;> rfl
  have trace := transferAt_fromTapes (savedTape block) (outputTape block) distinct
    id false (restoreLabel block) (nextRestore block) instruction atLoop
    (tapes [] saved output) (Mode.flag .bins) none
  have source : tapes [] saved output (savedTape block) = saved block := by
    cases block <;> rfl
  have destination : tapes [] saved output (outputTape block) = output block := by
    cases block <;> rfl
  rw [source, destination] at trace
  simpa only [cfg, tapesAt, update_saved, update_output,
    List.map_id_fun, id_eq, prepend] using! trace

private theorem appendTrace {X : Type*} (f : X → X) {a b : Nat} {x y z : X}
    (first : f^[a] x = y) (second : f^[b] y = z) : f^[a + b] x = z := by
  rw [Nat.add_comm a b, Function.iterate_add_apply, first, second]

theorem restoreAllTrace (words : Words) :
    (advance machine.step)^[(words .bins).length + (words .items).length +
        (words .fixed).length + 3]
      (some (cfg (some .restoreBins) [] (reversed words) empty)) =
      some (cfg none [] empty words) := by
  let saved₁ := Function.update (reversed words) .bins []
  let output₁ := prepend empty .bins (words .bins)
  let saved₂ := Function.update saved₁ .items []
  let output₂ := prepend output₁ .items (words .items)
  have first := restoreTrace .bins (reversed words) empty
  have second := restoreTrace .items saved₁ output₁
  have third := restoreTrace .fixed saved₂ output₂
  simp only [reversed, List.length_reverse, List.reverse_reverse,
    restoreLabel, nextRestore] at first
  change (advance machine.step)^[(words .bins).length + 1]
    (some (cfg (some .restoreBins) [] (reversed words) empty)) =
    some (cfg (some .restoreItems) [] saved₁ output₁) at first
  have saved₁_items : saved₁ .items = (words .items).reverse := by
    simp [saved₁, reversed]
  have saved₂_fixed : saved₂ .fixed = (words .fixed).reverse := by
    simp [saved₂, saved₁, reversed]
  rw [saved₁_items] at second
  simp only [List.length_reverse, List.reverse_reverse, restoreLabel, nextRestore] at second
  change (advance machine.step)^[(words .items).length + 1]
    (some (cfg (some .restoreItems) [] saved₁ output₁)) =
    some (cfg (some .restoreFixed) [] saved₂ output₂) at second
  rw [saved₂_fixed] at third
  simp only [List.length_reverse, List.reverse_reverse, restoreLabel, nextRestore] at third
  have cleared : Function.update saved₂ .fixed [] = empty := by
    funext block; cases block <;> simp [saved₂, saved₁, empty]
  have restored : prepend output₂ .fixed (words .fixed) = words := by
    funext block; cases block <;> simp [output₂, output₁, prepend, empty]
  rw [cleared, restored] at third
  have total := appendTrace (advance machine.step)
    (appendTrace (advance machine.step) first second) third
  have clock : (words .bins).length + (words .items).length +
      (words .fixed).length + 3 =
      ((words .bins).length + 1 + ((words .items).length + 1)) +
        ((words .fixed).length + 1) := by omega
  rw [clock]
  exact total

theorem extensionTrace (bins : Nat) (items : RawInstance) (fixed : List (Option Nat)) :
    (advance machine.step)^[2 * (BinaryEncoding.extensionBits bins items fixed).length + 4]
      (some (initList machine (BinaryEncoding.extensionBits bins items fixed))) =
      some (cfg none [] empty (encodedWords bins items fixed)) := by
  have first := scan_extension bins items fixed
  have second := restoreAllTrace (encodedWords bins items fixed)
  have joined := appendTrace (advance machine.step) first second
  have length : (BinaryEncoding.extensionBits bins items fixed).length =
      (encodedWords bins items fixed .bins).length +
      (encodedWords bins items fixed .items).length +
      (encodedWords bins items fixed .fixed).length := by
    simp [BinaryEncoding.extensionBits, encodedWords, Nat.add_assoc]
  have clock : 2 * (BinaryEncoding.extensionBits bins items fixed).length + 4 =
      (BinaryEncoding.extensionBits bins items fixed).length + 1 +
        ((encodedWords bins items fixed .bins).length +
          (encodedWords bins items fixed .items).length +
          (encodedWords bins items fixed .fixed).length + 3) := by omega
  rw [clock]
  exact joined

def extensionInTime (bins : Nat) (items : RawInstance) (fixed : List (Option Nat)) :
    StateTransition.EvalsToInTime machine.step
      (initList machine (BinaryEncoding.extensionBits bins items fixed))
      (some (cfg none [] empty (encodedWords bins items fixed)))
      (2 * (BinaryEncoding.extensionBits bins items fixed).length + 4) where
  steps := 2 * (BinaryEncoding.extensionBits bins items fixed).length + 4
  evals_in_steps := extensionTrace bins items fixed
  steps_le_m := Nat.le_refl _

def extracted (input : List Bool) : Words :=
  reversed (run (.flag .bins) empty input).2

theorem totalTrace (input : List Bool) :
    (advance machine.step)^[2 * input.length + 4]
      (some (initList machine input)) =
      some (cfg none [] empty (extracted input)) := by
  have first := scanTrace input empty empty (.flag .bins) none
  have second := restoreAllTrace (extracted input)
  have startSaved : reversed (extracted input) = (run (.flag .bins) empty input).2 :=
    reversed_reversed _
  rw [startSaved] at second
  have joined := appendTrace (advance machine.step) first second
  rw [initList_eq]
  have length : wordLength (extracted input) = input.length := by
    simp [extracted, run_wordLength]
  unfold wordLength at length
  have clock : 2 * input.length + 4 = input.length + 1 +
      ((extracted input .bins).length + (extracted input .items).length +
        (extracted input .fixed).length + 3) := by omega
  rw [clock]
  exact joined

def extractionInTime (input : List Bool) :
    StateTransition.EvalsToInTime machine.step (initList machine input)
      (some (cfg none [] empty (extracted input))) (2 * input.length + 4) where
  steps := 2 * input.length + 4
  evals_in_steps := totalTrace input
  steps_le_m := Nat.le_refl _

@[simp] theorem extracted_extension (bins : Nat) (items : RawInstance)
    (fixed : List (Option Nat)) :
    extracted (BinaryEncoding.extensionBits bins items fixed) =
      encodedWords bins items fixed := by
  simp [extracted, run_extension]

theorem machine_finiteAlphabet (k : machine.K) : Finite (machine.Γ k) := by
  change Finite Bool
  infer_instance

end BinPackingGap.ExtensionVerifierMachine.Fields

end OAI