lean/OAI/Computability/BinPacking/PCP/NormalizationReadMachine.lean

import Mathlib.Tactic.DeriveFintype
import OAI.Computability.BinPacking.Information.SourceFieldArray

namespace OAI

namespace BinPackingCompleteness.NormalizationReadMachine

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

abbrev Signs := Fin 3 → Bool
abbrev Counters := Fin 3 → List Bool
abbrev State (A : Type) := (A × Signs) × Option Bool
abbrev Alphabet {K : Type} (_ : K) := Bool

def clean {A : Type} (ambient : A) (signs : Signs) : State A := ((ambient, signs), none)

def clauseSigns {n : Nat} (clause : Target.Clause n) : Signs := fun i => clause[i].positive

def clauseCounters {n : Nat} (clause : Target.Clause n) : Counters :=
  fun i => List.replicate clause[i].variableIndex.val true

inductive Label where
  | field (slot : Fin 3)
  | sign (slot : Fin 3)
  deriving DecidableEq, Fintype

section Placement

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

def afterSign (labels : Label → Λ) (exit : Option Λ) (slot : Fin 3) : Option Λ :=
  if slot = 0 then some (labels (.field 1))
  else if slot = 1 then some (labels (.field 2)) else exit

@[simp] theorem afterSign_zero (labels : Label → Λ) (exit : Option Λ) :
    afterSign labels exit 0 = some (labels (.field 1)) := rfl

@[simp] theorem afterSign_one (labels : Label → Λ) (exit : Option Λ) :
    afterSign labels exit 1 = some (labels (.field 2)) := rfl

@[simp] theorem afterSign_two (labels : Label → Λ) (exit : Option Λ) :
    afterSign labels exit 2 = exit := rfl

def saveSign (source : K) (slot : Fin 3) (bit : Bool) (exit : Option Λ) :
    TM2.Stmt (Alphabet (K := K)) Λ (State A) :=
  .load (fun state => clean state.1.1 (Function.update state.1.2 slot bit))
    (exitAt source exit)

def rejectSign (source : K) (exit : Option Λ) :
    TM2.Stmt (Alphabet (K := K)) Λ (State A) :=
  .load (fun state => clean state.1.1 state.1.2) (exitAt source exit)

def signInstruction (source : K) (slot : Fin 3) (exit rejected : Option Λ) :
    TM2.Stmt (Alphabet (K := K)) Λ (State A) :=
  .pop source (fun state head => (state.1, head))
    (.branch (fun state => state.2.isNone)
      (rejectSign source rejected)
      (.branch (fun state => state.2.getD false)
        (.pop source (fun state head => (state.1, head))
          (.branch (fun state => state.2 == some false)
            (saveSign source slot true exit) (rejectSign source rejected)))
        (saveSign source slot false exit)))

def instruction (tape : Fin 4 → K) (labels : Label → Λ) (exit rejected : Option Λ) :
    Label → TM2.Stmt (Alphabet (K := K)) Λ (State A)
  | .field slot => Hastad.SourceMachine.fieldLoop (tape 0) (tape slot.succ)
      (labels (.field slot)) (some (labels (.sign slot)))
  | .sign slot => signInstruction (tape 0) slot (afterSign labels exit slot) rejected

def tapes (tape : Fin 4 → K) (base : K → List Bool) (input : List Bool)
    (counter : Counters) : K → List Bool :=
  Function.update (Function.update (Function.update (Function.update base
    (tape 0) input) (tape 1) (counter 0)) (tape 2) (counter 1)) (tape 3) (counter 2)

theorem tapes_input (tape : Fin 4 → K) (distinct : Function.Injective tape)
    (base : K → List Bool) (input : List Bool) (counter : Counters) :
    tapes tape base input counter (tape 0) = input := by
  have hd (i j : Fin 4) (hne : i ≠ j) : tape i ≠ tape j := fun h => hne (distinct h)
  simp [tapes, hd]

theorem tapes_counter (tape : Fin 4 → K) (distinct : Function.Injective tape)
    (base : K → List Bool) (input : List Bool) (counter : Counters) (slot : Fin 3) :
    tapes tape base input counter (tape slot.succ) = counter slot := by
  have hd (i j : Fin 4) (hne : i ≠ j) : tape i ≠ tape j := fun h => hne (distinct h)
  fin_cases slot <;> simp [tapes, hd]

theorem tapes_other (tape : Fin 4 → K) (base : K → List Bool)
    (input : List Bool) (counter : Counters) (k : K) (other : ∀ i, k ≠ tape i) :
    tapes tape base input counter k = base k := by
  simp [tapes, other]

theorem update_input (tape : Fin 4 → K) (distinct : Function.Injective tape)
    (base : K → List Bool) (input replacement : List Bool) (counter : Counters) :
    Function.update (tapes tape base input counter) (tape 0) replacement =
      tapes tape base replacement counter := by
  have hd (i j : Fin 4) (hne : i ≠ j) : tape i ≠ tape j := fun h => hne (distinct h)
  funext k
  by_cases hk : k = tape 0
  · subst k
    simp [tapes, hd]
  · simp [tapes, hk, Function.update_apply]

theorem update_counter (tape : Fin 4 → K) (distinct : Function.Injective tape)
    (base : K → List Bool) (input replacement : List Bool) (counter : Counters) (slot : Fin 3) :
    Function.update (tapes tape base input counter) (tape slot.succ) replacement =
      tapes tape base input (Function.update counter slot replacement) := by
  have hd (i j : Fin 4) (hne : i ≠ j) : tape i ≠ tape j := fun h => hne (distinct h)
  funext k
  by_cases hk : k = tape slot.succ
  · subst k
    fin_cases slot <;> simp [tapes, hd]
  · fin_cases slot
    · change k ≠ tape 1 at hk
      simp [tapes, hk, Function.update_apply]
    · change k ≠ tape 2 at hk
      simp [tapes, hk, Function.update_apply]
    · change k ≠ tape 3 at hk
      simp [tapes, hk, Function.update_apply]

theorem fieldTapes_eq (tape : Fin 4 → K) (distinct : Function.Injective tape)
    (base : K → List Bool) (input replacement output : List Bool)
    (counter : Counters) (slot : Fin 3) :
    Hastad.SourceMachine.fieldTapes (tape 0) (tape slot.succ)
      (tapes tape base input counter) replacement output =
      tapes tape base replacement (Function.update counter slot output) := by
  unfold Hastad.SourceMachine.fieldTapes
  rw [update_input tape distinct, update_counter tape distinct]

variable (tape : Fin 4 → K) (distinct : Function.Injective tape)
variable (labels : Label → Λ) (exit rejected : Option Λ)
variable (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State A))
variable (atLabels : ∀ label, program (labels label) = instruction tape labels exit rejected label)
variable (base : K → List Bool) (ambient : A)

include distinct atLabels

theorem fieldTrace (slot : Fin 3) (value : Nat) (suffix : List Bool)
    (counter : Counters) (signs : Signs) (register : Option Bool) :
    (advance (TM2.step program))^[value + 1]
      (some ⟨some (labels (.field slot)), ((ambient, signs), register),
        tapes tape base (encodeWord value ++ suffix) counter⟩) =
      some ⟨some (labels (.sign slot)), clean ambient signs,
        tapes tape base suffix
          (Function.update counter slot (List.replicate value true ++ counter slot))⟩ := by
  have distinctSlot : tape 0 ≠ tape slot.succ := by
    intro h
    have same := congrArg Fin.val (distinct h)
    simp only [Fin.val_zero, Fin.val_succ] at same
    omega
  have h := Hastad.SourceMachine.fieldLoopTrace (tape 0) (tape slot.succ) distinctSlot
    (labels (.field slot)) (some (labels (.sign slot))) program (atLabels (.field slot))
    (tapes tape base (encodeWord value ++ suffix) counter) value suffix (counter slot)
    (ambient, signs) register
  simpa only [fieldTapes_eq tape distinct, Function.update_eq_self, clean] using h

theorem signStep (slot : Fin 3) (sign : Bool) (suffix : List Bool)
    (counter : Counters) (signs : Signs) (register : Option Bool) :
    TM2.step program
      ⟨some (labels (.sign slot)), ((ambient, signs), register),
        tapes tape base (encodeWord (if sign then 1 else 0) ++ suffix) counter⟩ =
      some ⟨afterSign labels exit slot, clean ambient (Function.update signs slot sign),
        tapes tape base suffix counter⟩ := by
  change some (TM2.stepAux (program (labels (.sign slot))) _ _) = _
  rw [atLabels (.sign slot)]
  cases sign <;> cases h : afterSign labels exit slot <;>
    simp [instruction, signInstruction, saveSign, rejectSign, encodeWord,
      TM2.stepAux, exitAt, h, clean, tapes_input tape distinct, update_input tape distinct]

omit [DecidableEq K] distinct atLabels in
private theorem joinTrace {X : Type*} {f : X → X} {a b c : X} {n m : Nat}
    (first : f^[n] a = b) (second : f^[m] b = c) : f^[n + m] a = c := by
  rw [Nat.add_comm, Function.iterate_add_apply, first, second]

theorem literalTrace {n : Nat} (slot : Fin 3) (literal : Target.Literal n)
    (suffix : List Bool) (counter : Counters) (signs : Signs) (register : Option Bool) :
    (advance (TM2.step program))^[literal.variableIndex.val + 2]
      (some ⟨some (labels (.field slot)), ((ambient, signs), register),
        tapes tape base (encodeWords (literalWords literal) ++ suffix) counter⟩) =
      some ⟨afterSign labels exit slot, clean ambient (Function.update signs slot literal.positive),
        tapes tape base suffix (Function.update counter slot
          (List.replicate literal.variableIndex.val true ++ counter slot))⟩ := by
  have first := fieldTrace tape distinct labels exit rejected program atLabels base ambient
    slot literal.variableIndex.val (encodeWord (if literal.positive then 1 else 0) ++ suffix)
    counter signs register
  have second := signStep tape distinct labels exit rejected program atLabels base ambient
    slot literal.positive suffix
    (Function.update counter slot (List.replicate literal.variableIndex.val true ++ counter slot))
    signs none
  change (advance (TM2.step program))^[1]
    (some ⟨some (labels (.sign slot)), clean ambient signs,
      tapes tape base (encodeWord (if literal.positive then 1 else 0) ++ suffix)
        (Function.update counter slot (List.replicate literal.variableIndex.val true ++ counter slot))⟩) = _
    at second
  have full := joinTrace first second
  simpa only [literalWords, encodeWords, List.append_nil, List.append_assoc,
    Nat.add_assoc] using full

theorem clauseTrace {n : Nat} (clause : Target.Clause n) (suffix : List Bool)
    (signs : Signs) (register : Option Bool) :
    (advance (TM2.step program))^[clause[0].variableIndex.val +
        clause[1].variableIndex.val + clause[2].variableIndex.val + 6]
      (some ⟨some (labels (.field 0)), ((ambient, signs), register),
        tapes tape base (encodeWords (clauseWords clause) ++ suffix) (fun _ => [])⟩) =
      some ⟨exit, clean ambient (clauseSigns clause),
        tapes tape base suffix (clauseCounters clause)⟩ := by
  let counter₀ : Counters := Function.update (fun _ => []) 0
    (List.replicate clause[0].variableIndex.val true)
  let counter₁ : Counters := Function.update counter₀ 1
    (List.replicate clause[1].variableIndex.val true)
  let counter₂ : Counters := Function.update counter₁ 2
    (List.replicate clause[2].variableIndex.val true)
  let signs₀ := Function.update signs 0 clause[0].positive
  let signs₁ := Function.update signs₀ 1 clause[1].positive
  let signs₂ := Function.update signs₁ 2 clause[2].positive
  have counter₀_one : counter₀ 1 = [] := rfl
  have counter₁_two : counter₁ 2 = [] := rfl
  have first := literalTrace tape distinct labels exit rejected program atLabels base ambient
    0 clause[0] (encodeWords (literalWords clause[1]) ++
      (encodeWords (literalWords clause[2]) ++ suffix)) (fun _ => []) signs register
  have second := literalTrace tape distinct labels exit rejected program atLabels base ambient
    1 clause[1] (encodeWords (literalWords clause[2]) ++ suffix) counter₀ signs₀ none
  have third := literalTrace tape distinct labels exit rejected program atLabels base ambient
    2 clause[2] suffix counter₁ signs₁ none
  simp only [counter₀_one, counter₁_two, List.append_nil,
    afterSign_zero, afterSign_one, afterSign_two] at first second third
  have full := joinTrace (joinTrace first second) third
  have counters_eq : counter₂ = clauseCounters clause := by
    funext i
    fin_cases i <;> simp [counter₂, counter₁, counter₀, clauseCounters]
  have signs_eq : signs₂ = clauseSigns clause := by
    funext i
    fin_cases i <;> simp [signs₂, signs₁, signs₀, clauseSigns]
  have htime : (clause[0].variableIndex.val + 2 + (clause[1].variableIndex.val + 2)) +
      (clause[2].variableIndex.val + 2) =
      clause[0].variableIndex.val + clause[1].variableIndex.val + clause[2].variableIndex.val + 6 := by omega
  rw [htime] at full
  change (advance (TM2.step program))^[_]
    (some ⟨some (labels (.field 0)), ((ambient, signs), register),
      tapes tape base (encodeWords (literalWords clause[0]) ++
        (encodeWords (literalWords clause[1]) ++ (encodeWords (literalWords clause[2]) ++ suffix)))
        (fun _ => [])⟩) =
    some ⟨exit, clean ambient signs₂, tapes tape base suffix counter₂⟩ at full
  rw [signs_eq, counters_eq] at full
  simpa only [clauseWords, encodeWords_append, List.append_assoc] using full

def clauseInTime {n : Nat} (clause : Target.Clause n) (suffix : List Bool)
    (signs : Signs) (register : Option Bool) :
    StateTransition.EvalsToInTime (TM2.step program)
      ⟨some (labels (.field 0)), ((ambient, signs), register),
        tapes tape base (encodeWords (clauseWords clause) ++ suffix) (fun _ => [])⟩
      (some ⟨exit, clean ambient (clauseSigns clause),
        tapes tape base suffix (clauseCounters clause)⟩)
      (clause[0].variableIndex.val + clause[1].variableIndex.val + clause[2].variableIndex.val + 6) where
  steps := clause[0].variableIndex.val + clause[1].variableIndex.val + clause[2].variableIndex.val + 6
  evals_in_steps := clauseTrace tape distinct labels exit rejected program atLabels base ambient
    clause suffix signs register
  steps_le_m := Nat.le_refl _

end Placement

theorem steps_le_encoded_length {n : Nat} (clause : Target.Clause n) :
    clause[0].variableIndex.val + clause[1].variableIndex.val + clause[2].variableIndex.val + 6 ≤
      (encodeWords (clauseWords clause)).length := by
  simp only [clauseWords, encodeWords_append, List.length_append,
    literalWords, encodeWords, List.length_append, encodeWord_length, List.length_nil]
  omega

abbrev ConcreteLabel := Label ⊕ Bool

def concreteProgram : ConcreteLabel → TM2.Stmt (Alphabet (K := Fin 4)) ConcreteLabel (State Unit)
  | .inl label => instruction id Sum.inl (some (.inr true)) (some (.inr false)) label
  | .inr _ => .halt

abbrev machine : FinTM2 where
  K := Fin 4
  k₀ := 0
  k₁ := 1
  Γ := Alphabet
  Λ := ConcreteLabel
  main := .inl (.field 0)
  σ := State Unit
  initialState := clean () (fun _ => false)
  m := concreteProgram

def machineInTime {n : Nat} (clause : Target.Clause n) (suffix : List Bool) :
    StateTransition.EvalsToInTime machine.step
      ⟨some (.inl (.field 0)), clean () (fun _ => false),
        tapes id (fun _ : Fin 4 => []) (encodeWords (clauseWords clause) ++ suffix) (fun _ => [])⟩
      (some ⟨some (.inr true), clean () (clauseSigns clause),
        tapes id (fun _ : Fin 4 => []) suffix (clauseCounters clause)⟩)
      (clause[0].variableIndex.val + clause[1].variableIndex.val + clause[2].variableIndex.val + 6) :=
  clauseInTime id (fun _ _ h => h) Sum.inl (some (.inr true)) (some (.inr false))
    concreteProgram (fun _ => rfl) (fun _ => []) () clause suffix (fun _ => false) none

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

end BinPackingCompleteness.NormalizationReadMachine

end OAI