lean/OAI/Computability/BinPacking/CookLevin/ConfigIndex.lean

import Mathlib.Data.Fintype.Option
import Mathlib.Data.Fintype.Pi
import Mathlib.Data.Fintype.Sigma
import Mathlib.Data.Fintype.Sum
import Mathlib.Data.List.Basic
import Mathlib.Data.List.FinRange
import Mathlib.Logic.Equiv.Fin.Basic
import Mathlib.Logic.Function.Basic
import OAI.Computability.BinPacking.CookLevin.BoundedExecution

namespace OAI

namespace BinPackingGames.Foundations.Complexity.CookLevin.StackEncoding

variable {Γ : Type*}

abbrev Cells (Γ : Type*) (S : Nat) := Fin S → Option Γ

def encode (S : Nat) (xs : List Γ) : Cells Γ S := fun i => xs[i.val]?

def read {S : Nat} (cells : Cells Γ S) (n : Nat) : Option Γ :=
  if h : n < S then cells ⟨n, h⟩ else none

def head {S : Nat} (cells : Cells Γ S) : Option Γ := read cells 0

def isEmpty {S : Nat} (cells : Cells Γ S) : Bool := (head cells).isNone

def popShift {S : Nat} (cells : Cells Γ S) : Cells Γ S :=
  fun i => read cells (i.val + 1)

def pushShift {S : Nat} (a : Γ) (cells : Cells Γ S) : Cells Γ S :=
  fun i => if h : i.val = 0 then some a else cells ⟨i.val - 1, by omega⟩

@[simp] theorem encode_apply (S : Nat) (xs : List Γ) (i : Fin S) :
    encode S xs i = xs[i.val]? := rfl

@[simp] theorem encode_nil (S : Nat) : encode S ([] : List Γ) = fun _ => none := by
  funext i
  simp [encode]

@[simp] theorem read_at {S : Nat} (cells : Cells Γ S) (i : Fin S) :
    read cells i.val = cells i := by
  simp [read, i.isLt]

theorem read_of_capacity_le {S : Nat} (cells : Cells Γ S) (n : Nat) (h : S ≤ n) :
    read cells n = none := by
  simp [read, Nat.not_lt.mpr h]

theorem read_encode {S : Nat} (xs : List Γ) (hlen : xs.length ≤ S) (n : Nat) :
    read (encode S xs) n = xs[n]? := by
  by_cases hn : n < S
  · simp [read, encode, hn]
  · have hx : xs.length ≤ n := by omega
    simp [read, hn, List.getElem?_eq_none hx]

theorem head_encode {S : Nat} (xs : List Γ) (hlen : xs.length ≤ S) :
    head (encode S xs) = xs.head? := by
  rw [head, read_encode xs hlen, List.head?_eq_getElem?]

theorem head_encode_eq_none_iff {S : Nat} (xs : List Γ) (hlen : xs.length ≤ S) :
    head (encode S xs) = none ↔ xs = [] := by
  rw [head_encode xs hlen, List.head?_eq_none_iff]

theorem isEmpty_encode {S : Nat} (xs : List Γ) (hlen : xs.length ≤ S) :
    isEmpty (encode S xs) = xs.isEmpty := by
  rw [isEmpty, head_encode xs hlen]
  cases xs <;> rfl

theorem isEmpty_encode_eq_true_iff {S : Nat} (xs : List Γ) (hlen : xs.length ≤ S) :
    isEmpty (encode S xs) = true ↔ xs = [] := by
  rw [isEmpty_encode xs hlen]
  cases xs <;> simp

theorem encode_tail {S : Nat} (xs : List Γ) (hlen : xs.length ≤ S) :
    encode S xs.tail = popShift (encode S xs) := by
  funext i
  change xs.tail[i.val]? = read (encode S xs) (i.val + 1)
  rw [read_encode xs hlen, List.getElem?_tail]

theorem encode_cons {S : Nat} (a : Γ) (xs : List Γ) :
    encode S (a :: xs) = pushShift a (encode S xs) := by
  funext i
  by_cases hi : i.val = 0 <;> simp [encode, pushShift, List.getElem?_cons, hi]

theorem tail_length_le {S : Nat} (xs : List Γ) (hlen : xs.length ≤ S) :
    xs.tail.length ≤ S := by
  have ht : xs.tail.length ≤ xs.length := by simp
  omega

theorem cons_length_le {S : Nat} (a : Γ) (xs : List Γ) (hroom : xs.length < S) :
    (a :: xs).length ≤ S := by
  simp only [List.length_cons]
  omega

theorem encode_injective {S : Nat} {xs ys : List Γ}
    (hx : xs.length ≤ S) (hy : ys.length ≤ S)
    (h : encode S xs = encode S ys) : xs = ys := by
  apply List.ext_getElem?
  intro n
  rw [← read_encode xs hx n, ← read_encode ys hy n, h]

theorem encode_eq_iff {S : Nat} {xs ys : List Γ}
    (hx : xs.length ≤ S) (hy : ys.length ≤ S) :
    encode S xs = encode S ys ↔ xs = ys :=
  ⟨encode_injective hx hy, fun h => congrArg (encode S) h⟩

abbrev BoundedStack (Γ : Type*) (S : Nat) := {xs : List Γ // xs.length ≤ S}

def boundedEncoding (S : Nat) : BoundedStack Γ S ↪ Cells Γ S where
  toFun xs := encode S xs.val
  inj' := by
    intro xs ys h
    apply Subtype.ext
    exact encode_injective xs.property ys.property h

def boundedPop {S : Nat} (xs : BoundedStack Γ S) : BoundedStack Γ S :=
  ⟨xs.val.tail, tail_length_le xs.val xs.property⟩

def boundedPush {S : Nat} (a : Γ) (xs : BoundedStack Γ S)
    (hroom : xs.val.length < S) : BoundedStack Γ S :=
  ⟨a :: xs.val, cons_length_le a xs.val hroom⟩

theorem boundedPop_correct {S : Nat} (xs : BoundedStack Γ S) :
    boundedEncoding S (boundedPop xs) = popShift (boundedEncoding S xs) :=
  encode_tail xs.val xs.property

theorem boundedPush_correct {S : Nat} (a : Γ) (xs : BoundedStack Γ S)
    (hroom : xs.val.length < S) :
    boundedEncoding S (boundedPush a xs hroom) = pushShift a (boundedEncoding S xs) :=
  encode_cons a xs.val

variable {K : Type} {Alphabet : K → Type} [DecidableEq K]

def encodeTapes (S : Nat) (tapes : ∀ k, List (Alphabet k)) :
    ∀ k, Cells (Alphabet k) S := fun k => encode S (tapes k)

theorem encodeTapes_update (S : Nat) (tapes : ∀ k, List (Alphabet k))
    (k : K) (replacement : List (Alphabet k)) :
    encodeTapes S (Function.update tapes k replacement) =
      Function.update (encodeTapes S tapes) k (encode S replacement) := by
  funext j
  by_cases h : j = k
  · subst j; simp [encodeTapes]
  · simp [encodeTapes, h]

theorem encodeTapes_pop {S : Nat} (tapes : ∀ k, List (Alphabet k)) (k : K)
    (hlen : (tapes k).length ≤ S) :
    encodeTapes S (Function.update tapes k (tapes k).tail) =
      Function.update (encodeTapes S tapes) k (popShift (encode S (tapes k))) := by
  rw [encodeTapes_update, encode_tail (tapes k) hlen]

theorem encodeTapes_push (S : Nat) (tapes : ∀ k, List (Alphabet k)) (k : K)
    (a : Alphabet k) :
    encodeTapes S (Function.update tapes k (a :: tapes k)) =
      Function.update (encodeTapes S tapes) k (pushShift a (encode S (tapes k))) := by
  rw [encodeTapes_update, encode_cons]

omit [DecidableEq K] in
theorem encodeTapes_injective {S : Nat} {tapes other : ∀ k, List (Alphabet k)}
    (h : ∀ k, (tapes k).length ≤ S) (ho : ∀ k, (other k).length ≤ S)
    (heq : encodeTapes S tapes = encodeTapes S other) : tapes = other := by
  funext k
  exact encode_injective (h k) (ho k) (congrFun heq k)

end BinPackingGames.Foundations.Complexity.CookLevin.StackEncoding

namespace BinPackingGames.Foundations.Complexity.CookLevin

open Target

inductive Gate where
  | const (value : Bool)
  | not (input : Nat)
  | and (left right : Nat)
  | or (left right : Nat)
  deriving DecidableEq

def Gate.Bounded (g : Gate) (bound : Nat) : Prop :=
  match g with
  | .const _ => True
  | .not x => x < bound
  | .and x y | .or x y => x < bound ∧ y < bound

def Gate.eval (g : Gate) (wires : Nat → Bool) : Bool :=
  match g with
  | .const b => b
  | .not x => !(wires x)
  | .and x y => wires x && wires y
  | .or x y => wires x || wires y

theorem Gate.bounded_mono (g : Gate) {a b : Nat} (hab : a ≤ b)
    (h : g.Bounded a) : g.Bounded b := by
  cases g with
  | const _ => trivial
  | not _ => exact Nat.lt_of_lt_of_le h hab
  | and _ _ => exact ⟨Nat.lt_of_lt_of_le h.1 hab, Nat.lt_of_lt_of_le h.2 hab⟩
  | or _ _ => exact ⟨Nat.lt_of_lt_of_le h.1 hab, Nat.lt_of_lt_of_le h.2 hab⟩

theorem Gate.eval_congr (g : Gate) {bound : Nat} (hg : g.Bounded bound)
    (A B : Nat → Bool) (h : ∀ j, j < bound → A j = B j) :
    g.eval A = g.eval B := by
  cases g with
  | const b => rfl
  | not x => simp only [Gate.eval, h x hg]
  | and x y => simp only [Gate.eval, h x hg.1, h y hg.2]
  | or x y => simp only [Gate.eval, h x hg.1, h y hg.2]

def Ordered (start : Nat) (gates : List Gate) : Prop :=
  ∀ i (hi : i < gates.length), gates[i].Bounded (start + i)

def Consistent (start : Nat) (gates : List Gate) (wires : Nat → Bool) : Prop :=
  ∀ i (hi : i < gates.length), wires (start + i) = gates[i].eval wires

@[simp] theorem ordered_nil (start : Nat) : Ordered start [] := by
  intro i hi
  simp at hi

theorem ordered_cons (start : Nat) (g : Gate) (gs : List Gate) :
    Ordered start (g :: gs) ↔ g.Bounded start ∧ Ordered (start + 1) gs := by
  unfold Ordered
  constructor
  · intro h
    refine ⟨?_, ?_⟩
    · have h0 := h 0 (by simp)
      change g.Bounded (start + 0) at h0
      simpa only [Nat.add_zero] using h0
    · intro i hi
      have ht := h (i + 1) (by simpa using hi)
      change gs[i].Bounded (start + (i + 1)) at ht
      simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using ht
  · rintro ⟨hg, hgs⟩ i hi
    cases i with
    | zero => simpa using hg
    | succ i =>
      simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using
        hgs i (by simpa using hi)

@[simp] theorem consistent_nil (start : Nat) (A : Nat → Bool) :
    Consistent start [] A := by
  intro i hi
  simp at hi

theorem consistent_cons (start : Nat) (g : Gate) (gs : List Gate) (A : Nat → Bool) :
    Consistent start (g :: gs) A ↔ A start = g.eval A ∧ Consistent (start + 1) gs A := by
  unfold Consistent
  constructor
  · intro h
    refine ⟨?_, ?_⟩
    · have h0 := h 0 (by simp)
      change A (start + 0) = g.eval A at h0
      simpa only [Nat.add_zero] using h0
    · intro i hi
      have ht := h (i + 1) (by simpa using hi)
      change A (start + (i + 1)) = gs[i].eval A at ht
      simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using ht
  · rintro ⟨hg, hgs⟩ i hi
    cases i with
    | zero => simpa using hg
    | succ i =>
      simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using
        hgs i (by simpa using hi)

theorem consistent_append (start : Nat) (gs hs : List Gate) (A : Nat → Bool) :
    Consistent start (gs ++ hs) A ↔
      Consistent start gs A ∧ Consistent (start + gs.length) hs A := by
  induction gs generalizing start with
  | nil => simp [Consistent]
  | cons g gs ih =>
    simp only [List.cons_append, consistent_cons, ih, List.length_cons]
    simp only [Nat.add_comm, Nat.add_left_comm, and_assoc]

def run (start : Nat) : List Gate → (Nat → Bool) → (Nat → Bool)
  | [], A => A
  | g :: gs, A => run (start + 1) gs (Function.update A start (g.eval A))

theorem run_eq_of_lt (start : Nat) (gs : List Gate) (A : Nat → Bool)
    (j : Nat) (hj : j < start) : run start gs A j = A j := by
  induction gs generalizing start A with
  | nil => rfl
  | cons g gs ih =>
    rw [run, ih (start + 1) _ (by omega)]
    exact Function.update_of_ne (by omega) _ _

theorem run_append (start : Nat) (gs hs : List Gate) (A : Nat → Bool) :
    run start (gs ++ hs) A = run (start + gs.length) hs (run start gs A) := by
  induction gs generalizing start A with
  | nil => simp [run]
  | cons g gs ih =>
    simpa [run, Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using
      ih (start + 1) (Function.update A start (g.eval A))

@[simp] theorem run_singleton (start : Nat) (g : Gate) (A : Nat → Bool) :
    run start [g] A = Function.update A start (g.eval A) := rfl

@[simp] theorem run_singleton_here (start : Nat) (g : Gate) (A : Nat → Bool) :
    run start [g] A start = g.eval A := by simp

theorem run_singleton_other (start : Nat) (g : Gate) (A : Nat → Bool)
    (j : Nat) (hj : j ≠ start) : run start [g] A j = A j := by
  simp [hj]

theorem Ordered.append {start : Nat} {gs hs : List Gate}
    (hg : Ordered start gs) (hh : Ordered (start + gs.length) hs) :
    Ordered start (gs ++ hs) := by
  induction gs generalizing start with
  | nil => simpa using hh
  | cons g gs ih =>
    rcases (ordered_cons start g gs).mp hg with ⟨h0, ht⟩
    apply (ordered_cons start g (gs ++ hs)).mpr
    refine ⟨h0, ih ht ?_⟩
    simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using hh

theorem run_consistent (start : Nat) (gs : List Gate) (A : Nat → Bool)
    (h : Ordered start gs) : Consistent start gs (run start gs A) := by
  induction gs generalizing start A with
  | nil => exact consistent_nil start A
  | cons g gs ih =>
    rcases (ordered_cons start g gs).mp h with ⟨hg, hgs⟩
    apply (consistent_cons start g gs _).mpr
    constructor
    · have hout : run start (g :: gs) A start = g.eval A := by
        rw [run, run_eq_of_lt (start + 1) gs _ start (by omega)]
        exact Function.update_self start _ _
      rw [hout]
      exact Gate.eval_congr g hg A (run start (g :: gs) A)
        (fun j hj => (run_eq_of_lt start (g :: gs) A j hj).symm)
    · exact ih (start + 1) _ hgs

theorem run_unique (start : Nat) (gs : List Gate) (A B : Nat → Bool)
    (ho : Ordered start gs) (hc : Consistent start gs B)
    (ha : ∀ j, j < start → A j = B j) :
    ∀ j, j < start + gs.length → run start gs A j = B j := by
  induction gs generalizing start A with
  | nil =>
    intro j hj
    exact ha j (by simpa using hj)
  | cons g gs ih =>
    rcases (ordered_cons start g gs).mp ho with ⟨hg, hgs⟩
    rcases (consistent_cons start g gs B).mp hc with ⟨hb, hbs⟩
    have hnext : ∀ j, j < start + 1 →
        Function.update A start (g.eval A) j = B j := by
      intro j hj
      by_cases heq : j = start
      · subst j
        rw [Function.update_self]
        exact (Gate.eval_congr g hg A B ha).trans hb.symm
      · rw [Function.update_of_ne heq]
        exact ha j (by omega)
    intro j hj
    exact ih (start + 1) _ hgs hbs hnext j (by
      simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using hj)

structure Circuit where
  inputs : Nat
  gates : List Gate
  ordered : Ordered inputs gates
  output : Fin (inputs + gates.length)

abbrev Circuit.wires (C : Circuit) : Nat := C.inputs + C.gates.length

def inputEnv {n : Nat} (input : Fin n → Bool) : Nat → Bool :=
  fun j => if h : j < n then input ⟨j, h⟩ else false

def Circuit.evalWires (C : Circuit) (input : Fin C.inputs → Bool) : Nat → Bool :=
  run C.inputs C.gates (inputEnv input)

def Circuit.eval (C : Circuit) (input : Fin C.inputs → Bool) : Bool :=
  C.evalWires input C.output.val

theorem Circuit.evalWires_input (C : Circuit) (input : Fin C.inputs → Bool)
    (j : Fin C.inputs) : C.evalWires input j.val = input j := by
  rw [Circuit.evalWires, run_eq_of_lt _ _ _ _ j.isLt]
  simp [inputEnv, j.isLt]

theorem Circuit.evalWires_consistent (C : Circuit) (input : Fin C.inputs → Bool) :
    Consistent C.inputs C.gates (C.evalWires input) :=
  run_consistent C.inputs C.gates (inputEnv input) C.ordered

theorem Consistent.congr {start : Nat} {gs : List Gate} {A B : Nat → Bool}
    (hc : Consistent start gs A) (ho : Ordered start gs)
    (hab : ∀ j, j < start + gs.length → A j = B j) :
    Consistent start gs B := by
  intro i hi
  have hbound := Gate.bounded_mono gs[i] (by omega : start + i ≤ start + gs.length)
    (ho i hi)
  calc
    B (start + i) = A (start + i) := (hab _ (by omega)).symm
    _ = gs[i].eval A := hc i hi
    _ = gs[i].eval B := Gate.eval_congr gs[i] hbound A B hab

def unitClause {n : Nat} (wire : Fin n) (positive : Bool) : Clause n :=
  #v[⟨wire, positive⟩, ⟨wire, positive⟩, ⟨wire, positive⟩]

def gateClauses {n : Nat} (output : Fin n) : (g : Gate) → g.Bounded n → List (Clause n)
  | .const b, _ => [unitClause output b, unitClause output b, unitClause output b]
  | .not x, h =>
    let v : Fin n := ⟨x, h⟩
    [#v[⟨output, true⟩, ⟨v, true⟩, ⟨v, true⟩],
     #v[⟨output, false⟩, ⟨v, false⟩, ⟨v, false⟩],
     #v[⟨output, true⟩, ⟨v, true⟩, ⟨v, true⟩]]
  | .and x y, h =>
    let vx : Fin n := ⟨x, h.1⟩
    let vy : Fin n := ⟨y, h.2⟩
    [#v[⟨output, false⟩, ⟨vx, true⟩, ⟨vx, true⟩],
     #v[⟨output, false⟩, ⟨vy, true⟩, ⟨vy, true⟩],
     #v[⟨output, true⟩, ⟨vx, false⟩, ⟨vy, false⟩]]
  | .or x y, h =>
    let vx : Fin n := ⟨x, h.1⟩
    let vy : Fin n := ⟨y, h.2⟩
    [#v[⟨output, true⟩, ⟨vx, false⟩, ⟨vx, false⟩],
     #v[⟨output, true⟩, ⟨vy, false⟩, ⟨vy, false⟩],
     #v[⟨output, false⟩, ⟨vx, true⟩, ⟨vy, true⟩]]

@[simp] theorem gateClauses_length {n : Nat} (output : Fin n)
    (g : Gate) (h : g.Bounded n) : (gateClauses output g h).length = 3 := by
  cases g <;> rfl

theorem gateClauses_correct {n : Nat} (output : Fin n) (g : Gate)
    (h : g.Bounded n) (A : Fin n → Bool) :
    (∀ c ∈ gateClauses output g h, c.eval A = true) ↔
      A output = g.eval (inputEnv A) := by
  cases g with
  | const b =>
    simp only [gateClauses, List.forall_mem_cons]
    cases b <;> cases ho : A output <;>
      simp [unitClause, Clause.eval, Literal.eval, Gate.eval, ho]
  | not x =>
    change x < n at h
    simp only [gateClauses, List.forall_mem_cons]
    cases ho : A output <;> cases hx : A ⟨x, h⟩ <;>
      simp [Clause.eval, Literal.eval, Gate.eval, inputEnv, h, ho, hx]
  | and x y =>
    change x < n ∧ y < n at h
    simp only [gateClauses, List.forall_mem_cons]
    cases ho : A output <;> cases hx : A ⟨x, h.1⟩ <;> cases hy : A ⟨y, h.2⟩ <;>
      simp [Clause.eval, Literal.eval, Gate.eval, inputEnv, h.1, h.2,
        ho, hx, hy]
  | or x y =>
    change x < n ∧ y < n at h
    simp only [gateClauses, List.forall_mem_cons]
    cases ho : A output <;> cases hx : A ⟨x, h.1⟩ <;> cases hy : A ⟨y, h.2⟩ <;>
      simp [Clause.eval, Literal.eval, Gate.eval, inputEnv, h.1, h.2,
        ho, hx, hy]

def Circuit.gateAt (C : Circuit) (i : Fin C.gates.length) : Gate := C.gates[i.val]

def Circuit.gateOutput (C : Circuit) (i : Fin C.gates.length) : Fin C.wires :=
  ⟨C.inputs + i.val, by have hi := i.isLt; simp only [Circuit.wires]; omega⟩

theorem Circuit.gateBounded (C : Circuit) (i : Fin C.gates.length) :
    (C.gateAt i).Bounded C.wires :=
  Gate.bounded_mono _ (by have hi := i.isLt; simp only [Circuit.wires]; omega)
    (C.ordered i.val i.isLt)

def Circuit.gateBlock (C : Circuit) (i : Fin C.gates.length) : List (Clause C.wires) :=
  gateClauses (C.gateOutput i) (C.gateAt i) (C.gateBounded i)

def Circuit.toFormula (C : Circuit) : Formula where
  «variables» := C.wires
  clauses := (List.finRange C.gates.length).flatMap C.gateBlock ++ [unitClause C.output true]

@[simp] theorem Circuit.toFormula_variables (C : Circuit) :
    C.toFormula.variables = C.inputs + C.gates.length := rfl

@[simp] theorem Circuit.toFormula_clause_count (C : Circuit) :
    C.toFormula.clauses.length = 3 * C.gates.length + 1 := by
  have h : ∀ is : List (Fin C.gates.length),
      (is.flatMap C.gateBlock).length = 3 * is.length := by
    intro is
    induction is with
    | nil => rfl
    | cons i is ih =>
      simp only [List.flatMap_cons, List.length_append, Circuit.gateBlock,
        gateClauses_length, List.length_cons] at *
      omega
  simp [Circuit.toFormula, h]

theorem Circuit.toFormula_satisfied_iff (C : Circuit) (A : Fin C.wires → Bool) :
    (∀ c ∈ C.toFormula.clauses, c.eval A = true) ↔
      Consistent C.inputs C.gates (inputEnv A) ∧ A C.output = true := by
  constructor
  · intro h
    constructor
    · intro i hi
      let idx : Fin C.gates.length := ⟨i, hi⟩
      have hblock : ∀ c ∈ C.gateBlock idx, c.eval A = true := by
        intro c hc
        apply h c
        apply List.mem_append.mpr
        left
        exact List.mem_flatMap.mpr ⟨idx, by simp, hc⟩
      have heq := (gateClauses_correct (C.gateOutput idx) (C.gateAt idx)
        (C.gateBounded idx) A).mp hblock
      have hlt : C.inputs + i < C.wires := by simp only [Circuit.wires]; omega
      simpa [inputEnv, hlt, Circuit.gateOutput, Circuit.gateAt, idx] using heq
    · have hu := h (unitClause C.output true)
        (List.mem_append.mpr (Or.inr (List.mem_singleton.mpr rfl)))
      simpa [unitClause, Clause.eval, Literal.eval] using hu
  · rintro ⟨hc, ho⟩ c hmem
    rcases List.mem_append.mp hmem with hblock | hunit
    · obtain ⟨i, _, hci⟩ := List.mem_flatMap.mp hblock
      apply (gateClauses_correct (C.gateOutput i) (C.gateAt i)
        (C.gateBounded i) A).mpr ?_ c hci
      have heq := hc i.val i.isLt
      have hlt : C.inputs + i.val < C.wires := (C.gateOutput i).isLt
      simpa [inputEnv, hlt, Circuit.gateOutput, Circuit.gateAt] using heq
    · have heq : c = unitClause C.output true := List.mem_singleton.mp hunit
      subst c
      simpa [unitClause, Clause.eval, Literal.eval] using ho

def Circuit.restrictAssignment (C : Circuit) (A : Fin C.wires → Bool) :
    Fin C.inputs → Bool := fun j =>
  A ⟨j.val, by have hj := j.isLt; simp only [Circuit.wires]; omega⟩

theorem Circuit.toFormula_satisfiable_iff_eval (C : Circuit) :
    C.toFormula.Satisfiable ↔ ∃ input : Fin C.inputs → Bool, C.eval input = true := by
  constructor
  · rintro ⟨A, hA⟩
    rcases (C.toFormula_satisfied_iff A).mp hA with ⟨hc, ho⟩
    refine ⟨C.restrictAssignment A, ?_⟩
    have hinput : ∀ j, j < C.inputs →
        inputEnv (C.restrictAssignment A) j = inputEnv A j := by
      intro j hj
      have ht : j < C.wires := by simp only [Circuit.wires]; omega
      simp [inputEnv, hj, ht, Circuit.restrictAssignment]
    have hu := run_unique C.inputs C.gates (inputEnv (C.restrictAssignment A))
      (inputEnv A) C.ordered hc hinput C.output.val C.output.isLt
    have heval : C.eval (C.restrictAssignment A) = A C.output := by
      have hout : C.output.val < C.wires := C.output.isLt
      simpa [Circuit.eval, Circuit.evalWires, inputEnv, hout] using hu
    exact heval.trans ho
  · rintro ⟨input, hinput⟩
    let A : Fin C.wires → Bool := fun j => C.evalWires input j.val
    refine ⟨A, (C.toFormula_satisfied_iff A).mpr ⟨?_, hinput⟩⟩
    apply Consistent.congr (C.evalWires_consistent input) C.ordered
    intro j hj
    have ht : j < C.wires := hj
    simp [inputEnv, ht, A]

theorem Circuit.toFormula_extending_iff_eval (C : Circuit) (input : Fin C.inputs → Bool) :
    (∃ A : Fin C.wires → Bool, C.restrictAssignment A = input ∧
      ∀ c ∈ C.toFormula.clauses, c.eval A = true) ↔ C.eval input = true := by
  constructor
  · rintro ⟨A, hext, hA⟩
    rcases (C.toFormula_satisfied_iff A).mp hA with ⟨hc, ho⟩
    have hinput : ∀ j, j < C.inputs → inputEnv input j = inputEnv A j := by
      intro j hj
      rw [← hext]
      have ht : j < C.wires := by simp only [Circuit.wires]; omega
      simp [inputEnv, hj, ht, Circuit.restrictAssignment]
    have hu := run_unique C.inputs C.gates (inputEnv input) (inputEnv A)
      C.ordered hc hinput C.output.val C.output.isLt
    have heval : C.eval input = A C.output := by
      have hout : C.output.val < C.wires := C.output.isLt
      simpa [Circuit.eval, Circuit.evalWires, inputEnv, hout] using hu
    exact heval.trans ho
  · intro hinput
    let A : Fin C.wires → Bool := fun j => C.evalWires input j.val
    refine ⟨A, ?_, (C.toFormula_satisfied_iff A).mpr ⟨?_, hinput⟩⟩
    · funext j
      simpa [Circuit.restrictAssignment, A] using C.evalWires_input input j
    · apply Consistent.congr (C.evalWires_consistent input) C.ordered
      intro j hj
      have ht : j < C.wires := hj
      simp [inputEnv, ht, A]

end BinPackingGames.Foundations.Complexity.CookLevin

namespace BinPackingGames.Foundations.Complexity.CookLevin.StatementCircuit

open Turing
open StackEncoding BoundedExecution

inductive Expr (ι : Type*) where
  | input (index : ι)
  | const (value : Bool)
  | not (arg : Expr ι)
  | and (left right : Expr ι)
  | or (left right : Expr ι)

namespace Expr

variable {ι : Type*}

def eval (input : ι → Bool) : Expr ι → Bool
  | .input i => input i
  | .const b => b
  | .not e => !(eval input e)
  | .and e f => eval input e && eval input f
  | .or e f => eval input e || eval input f

theorem eval_congr (e : Expr ι) (u v : ι → Bool) (h : ∀ i, u i = v i) :
    e.eval u = e.eval v := by
  have : u = v := funext h
  rw [this]

def rename {κ : Type*} (f : ι → κ) : Expr ι → Expr κ
  | .input i => .input (f i)
  | .const b => .const b
  | .not e => .not (e.rename f)
  | .and e g => .and (e.rename f) (g.rename f)
  | .or e g => .or (e.rename f) (g.rename f)

@[simp] theorem eval_rename {κ : Type*} (f : ι → κ) (e : Expr ι) (input : κ → Bool) :
    (e.rename f).eval input = e.eval (fun i => input (f i)) := by
  induction e <;> simp_all [rename, eval]

def size : Expr ι → Nat
  | .input _ | .const _ => 1
  | .not e => e.size + 1
  | .and e f | .or e f => e.size + f.size + 1

theorem size_pos (e : Expr ι) : 0 < e.size := by
  cases e <;> simp [size]

@[simp] theorem size_rename {κ : Type*} (f : ι → κ) (e : Expr ι) :
    (e.rename f).size = e.size := by
  induction e <;> simp_all [rename, size]

def root (start : Nat) (e : Expr ι) : Nat := start + e.size - 1

theorem root_lt (start : Nat) (e : Expr ι) : e.root start < start + e.size := by
  have := e.size_pos
  unfold root
  omega

@[simp] theorem root_not (start : Nat) (e : Expr ι) :
    (Expr.not e).root start = start + e.size := by
  simp only [root, size]
  omega

@[simp] theorem root_and (start : Nat) (e f : Expr ι) :
    (Expr.and e f).root start = start + (e.size + f.size) := by
  simp only [root, size]
  omega

@[simp] theorem root_or (start : Nat) (e f : Expr ι) :
    (Expr.or e f).root start = start + (e.size + f.size) := by
  simp only [root, size]
  omega

def gates (wire : ι → Nat) (start : Nat) : Expr ι → List Gate
  | .input i => [.or (wire i) (wire i)]
  | .const b => [.const b]
  | .not e => e.gates wire start ++ [.not (e.root start)]
  | .and e f => e.gates wire start ++ f.gates wire (start + e.size) ++
      [.and (e.root start) (f.root (start + e.size))]
  | .or e f => e.gates wire start ++ f.gates wire (start + e.size) ++
      [.or (e.root start) (f.root (start + e.size))]

@[simp] theorem gates_length (e : Expr ι) (wire : ι → Nat) (start : Nat) :
    (e.gates wire start).length = e.size := by
  induction e generalizing start <;> simp_all [gates, size, Nat.add_assoc]

private theorem ordered_singleton (start : Nat) (g : Gate) (h : g.Bounded start) :
    Ordered start [g] := by
  exact (ordered_cons start g []).mpr ⟨h, ordered_nil _⟩

theorem gates_ordered (e : Expr ι) (wire : ι → Nat) (start : Nat)
    (hw : ∀ i, wire i < start) : Ordered start (e.gates wire start) := by
  induction e generalizing start with
  | input i => exact ordered_singleton start _ ⟨hw i, hw i⟩
  | const b => exact ordered_singleton start _ trivial
  | not e ih =>
    apply (ih start hw).append
    simpa only [gates_length] using
      ordered_singleton (start + e.size) (.not (e.root start)) (e.root_lt start)
  | and e f ihe ihf =>
    have hf := ihf (start + e.size) (fun i => lt_of_lt_of_le (hw i) (by omega))
    have hp : Ordered start (e.gates wire start ++ f.gates wire (start + e.size)) :=
      (ihe start hw).append (by simpa only [gates_length] using hf)
    apply hp.append
    simp only [List.length_append, gates_length]
    apply ordered_singleton
    exact ⟨lt_of_lt_of_le (e.root_lt start) (by omega), by
      simpa only [Nat.add_assoc] using f.root_lt (start + e.size)⟩
  | or e f ihe ihf =>
    have hf := ihf (start + e.size) (fun i => lt_of_lt_of_le (hw i) (by omega))
    have hp : Ordered start (e.gates wire start ++ f.gates wire (start + e.size)) :=
      (ihe start hw).append (by simpa only [gates_length] using hf)
    apply hp.append
    simp only [List.length_append, gates_length]
    apply ordered_singleton
    exact ⟨lt_of_lt_of_le (e.root_lt start) (by omega), by
      simpa only [Nat.add_assoc] using f.root_lt (start + e.size)⟩

private theorem consistent_singleton (start : Nat) (g : Gate) (A : Nat → Bool)
    (h : Consistent start [g] A) : A start = g.eval A := by
  exact ((consistent_cons start g [] A).mp h).1

theorem eval_of_consistent (e : Expr ι) (wire : ι → Nat) (start : Nat)
    (A : Nat → Bool) (h : Consistent start (e.gates wire start) A) :
    A (e.root start) = e.eval (fun i => A (wire i)) := by
  induction e generalizing start with
  | input i =>
    simpa [gates, root, size, Gate.eval, eval] using
      consistent_singleton start (.or (wire i) (wire i)) A h
  | const b =>
    simpa [gates, root, size, Gate.eval, eval] using
      consistent_singleton start (.const b) A h
  | not e ih =>
    obtain ⟨he, hg⟩ := (consistent_append start _ _ A).mp h
    simp only [gates_length] at hg
    have hg' := consistent_singleton _ _ _ hg
    simpa only [root_not, Gate.eval, eval, ih start he] using hg'
  | and e f ihe ihf =>
    obtain ⟨hef, hg⟩ := (consistent_append start _ _ A).mp h
    obtain ⟨he, hf⟩ := (consistent_append start _ _ A).mp hef
    simp only [gates_length] at hf
    simp only [List.length_append, gates_length] at hg
    have hg' := consistent_singleton _ _ _ hg
    have he' := ihe start he
    have hf' := ihf (start + e.size) hf
    simpa only [root_and, Gate.eval, eval,
      he', hf'] using hg'
  | or e f ihe ihf =>
    obtain ⟨hef, hg⟩ := (consistent_append start _ _ A).mp h
    obtain ⟨he, hf⟩ := (consistent_append start _ _ A).mp hef
    simp only [gates_length] at hf
    simp only [List.length_append, gates_length] at hg
    have hg' := consistent_singleton _ _ _ hg
    have he' := ihe start he
    have hf' := ihf (start + e.size) hf
    simpa only [root_or, Gate.eval, eval,
      he', hf'] using hg'

def circuit {n : Nat} (wire : ι → Fin n) (e : Expr ι) : Circuit where
  inputs := n
  gates := e.gates (fun i => (wire i).val) n
  ordered := e.gates_ordered _ _ (fun i => (wire i).isLt)
  output := ⟨e.root n, by simpa only [gates_length] using e.root_lt n⟩

theorem circuit_eval {n : Nat} (wire : ι → Fin n) (e : Expr ι) (input : Fin n → Bool) :
    (e.circuit wire).eval input = e.eval (fun i => input (wire i)) := by
  have h := e.eval_of_consistent (fun i => (wire i).val) n
    ((e.circuit wire).evalWires input) ((e.circuit wire).evalWires_consistent input)
  change (e.circuit wire).eval input = _ at h
  rw [h]
  apply eval_congr
  intro i
  exact (e.circuit wire).evalWires_input input (wire i)

def mux (condition yes no : Expr ι) : Expr ι :=
  .or (.and condition yes) (.and (.not condition) no)

@[simp] theorem eval_mux (input : ι → Bool) (c x y : Expr ι) :
    (mux c x y).eval input = if c.eval input then x.eval input else y.eval input := by
  cases hc : c.eval input <;> simp [mux, eval, hc]

def disjoin : List (Expr ι) → Expr ι
  | [] => .const false
  | e :: rest => .or e (disjoin rest)

theorem eval_disjoin_true (input : ι → Bool) (es : List (Expr ι)) :
    (disjoin es).eval input = true ↔ ∃ e ∈ es, e.eval input = true := by
  induction es with
  | nil => simp [disjoin, eval]
  | cons e es ih => simp [disjoin, eval, ih]

theorem size_disjoin_le (es : List (Expr ι)) (C : Nat)
    (h : ∀ e ∈ es, e.size ≤ C) : (disjoin es).size ≤ es.length * (C + 1) + 1 := by
  induction es generalizing C with
  | nil => simp [disjoin, size]
  | cons e es ih =>
    have he := h e (by simp)
    have ht := ih C (fun f hf => h f (by simp [hf]))
    simp only [disjoin, size, List.length_cons, Nat.succ_mul]
    omega

end Expr

private theorem bool_ext {a b : Bool} (h : a = true ↔ b = true) : a = b := by
  cases a <;> cases b <;> simp_all

noncomputable def table {ι A B : Type*} [Fintype A] [DecidableEq B]
    (f : A → B) (x : A → Expr ι) (b : B) : Expr ι :=
  Expr.disjoin (Finset.univ.toList.map (fun a => .and (x a) (.const (decide (f a = b)))))

theorem eval_table {ι A B : Type*} [Fintype A] [DecidableEq A] [DecidableEq B]
    (input : ι → Bool) (f : A → B) (x : A → Expr ι) (a : A)
    (hx : ∀ z, (x z).eval input = decide (a = z)) (b : B) :
    (table f x b).eval input = decide (f a = b) := by
  apply bool_ext
  simp only [table, Expr.eval_disjoin_true, List.mem_map]
  constructor
  · rintro ⟨_, ⟨z, _, rfl⟩, hz⟩
    simp only [Expr.eval, hx, Bool.and_eq_true, decide_eq_true_eq] at hz
    rcases hz with ⟨rfl, hz⟩
    exact decide_eq_true hz
  · intro h
    refine ⟨.and (x a) (.const (decide (f a = b))), ?_, ?_⟩
    · exact ⟨a, by simp, rfl⟩
    · simp [Expr.eval, hx, h]

noncomputable def table₂ {ι A B C : Type*} [Fintype A] [Fintype B] [DecidableEq C]
    (f : A → B → C) (x : A → Expr ι) (y : B → Expr ι) (c : C) : Expr ι :=
  table (fun p : A × B => f p.1 p.2) (fun p => .and (x p.1) (y p.2)) c

theorem eval_table₂ {ι A B C : Type*} [Fintype A] [Fintype B]
    [DecidableEq A] [DecidableEq B] [DecidableEq C]
    (input : ι → Bool) (f : A → B → C) (x : A → Expr ι) (y : B → Expr ι)
    (a : A) (b : B) (hx : ∀ z, (x z).eval input = decide (a = z))
    (hy : ∀ z, (y z).eval input = decide (b = z)) (c : C) :
    (table₂ f x y c).eval input = decide (f a b = c) := by
  apply eval_table input _ _ (a, b)
  rintro ⟨za, zb⟩
  simp [Expr.eval, hx, hy, Prod.mk.injEq]

theorem size_table_le {ι A B : Type*} [Fintype A] [DecidableEq B]
    (f : A → B) (x : A → Expr ι) (b : B) (C : Nat) (h : ∀ a, (x a).size ≤ C) :
    (table f x b).size ≤ Fintype.card A * (C + 3) + 1 := by
  unfold table
  have hb : ∀ e ∈ Finset.univ.toList.map (fun a => Expr.and (x a)
      (.const (decide (f a = b)))), e.size ≤ C + 2 := by
    intro e he
    obtain ⟨a, _, rfl⟩ := List.mem_map.mp he
    simpa only [Expr.size, Nat.add_assoc] using Nat.add_le_add_right (h a) 2
  simpa [Nat.add_assoc] using Expr.size_disjoin_le _ (C + 2) hb

theorem size_table₂_le {ι A B D : Type*} [Fintype A] [Fintype B] [DecidableEq D]
    (f : A → B → D) (x : A → Expr ι) (y : B → Expr ι) (d : D) (C : Nat)
    (hx : ∀ a, (x a).size ≤ C) (hy : ∀ b, (y b).size ≤ C) :
    (table₂ f x y d).size ≤ (Fintype.card A * Fintype.card B) * (2 * C + 4) + 1 := by
  have h := size_table_le (fun p : A × B => f p.1 p.2)
    (fun p => Expr.and (x p.1) (y p.2)) d (2 * C + 1) (fun p => by
      have := hx p.1
      have := hy p.2
      simp only [Expr.size]
      omega)
  simpa only [table₂, Fintype.card_prod, Nat.add_assoc] using h

section Statements

variable {K : Type} {Γ : K → Type} {Λ σ ι : Type}
variable [DecidableEq K] [Fintype σ] [DecidableEq σ]
variable [∀ k, Fintype (Γ k)] [∀ k, DecidableEq (Γ k)] [DecidableEq Λ]

structure DataBits (ι : Type) (Γ : K → Type) (σ : Type) (S : Nat) where
  state : σ → Expr ι
  cells : ∀ k, Fin S → Option (Γ k) → Expr ι

structure ResultBits (ι : Type) (Γ : K → Type) (Λ σ : Type) (S : Nat)
    extends DataBits ι Γ σ S where
  label : Option Λ → Expr ι

def DataBits.Realizes {S : Nat} (bits : DataBits ι Γ σ S) (input : ι → Bool)
    (state : σ) (tapes : ∀ k, List (Γ k)) : Prop :=
  (∀ v, (bits.state v).eval input = decide (state = v)) ∧
  ∀ k i a, (bits.cells k i a).eval input = decide (encode S (tapes k) i = a)

def ResultBits.Realizes {S : Nat} (bits : ResultBits ι Γ Λ σ S) (input : ι → Bool)
    (cfg : TM2.Cfg Γ Λ σ) : Prop :=
  bits.toDataBits.Realizes input cfg.var cfg.stk ∧
  ∀ label, (bits.label label).eval input = decide (cfg.l = label)

def readBits {A : Type} [DecidableEq A] {S : Nat}
    (cells : Fin S → Option A → Expr ι) (n : Nat) (a : Option A) : Expr ι :=
  if h : n < S then cells ⟨n, h⟩ a else .const (decide ((none : Option A) = a))

theorem eval_readBits {A : Type} [DecidableEq A] {S : Nat}
    (input : ι → Bool) (bits : Fin S → Option A → Expr ι) (xs : List A)
    (hlen : xs.length ≤ S)
    (hbits : ∀ i a, (bits i a).eval input = decide (encode S xs i = a))
    (n : Nat) (a : Option A) :
    (readBits bits n a).eval input = decide (xs[n]? = a) := by
  by_cases hn : n < S
  · simp only [readBits, dite_eq_left hn]
    exact hbits ⟨n, hn⟩ a
  · have hx : xs[n]? = none := List.getElem?_eq_none (by omega)
    simp only [readBits, dite_eq_right hn, Expr.eval, hx]

noncomputable def pushBits {S : Nat} (bits : DataBits ι Γ σ S) (k : K)
    (f : σ → Γ k) : DataBits ι Γ σ S where
  state := bits.state
  cells := Function.update bits.cells k (fun i a =>
    if h : i.val = 0 then table (fun v => some (f v)) bits.state a
    else bits.cells k ⟨i.val - 1, by omega⟩ a)

noncomputable def peekBits {S : Nat} (bits : DataBits ι Γ σ S) (k : K)
    (f : σ → Option (Γ k) → σ) : DataBits ι Γ σ S where
  state := table₂ f bits.state (readBits (bits.cells k) 0)
  cells := bits.cells

noncomputable def popBits {S : Nat} (bits : DataBits ι Γ σ S) (k : K)
    (f : σ → Option (Γ k) → σ) : DataBits ι Γ σ S where
  state := table₂ f bits.state (readBits (bits.cells k) 0)
  cells := Function.update bits.cells k (fun i a => readBits (bits.cells k) (i.val + 1) a)

noncomputable def loadBits {S : Nat} (bits : DataBits ι Γ σ S)
    (f : σ → σ) : DataBits ι Γ σ S where
  state := table f bits.state
  cells := bits.cells

def muxResult {S : Nat} (condition : Expr ι) (yes no : ResultBits ι Γ Λ σ S) :
    ResultBits ι Γ Λ σ S where
  state := fun v => .mux condition (yes.state v) (no.state v)
  cells := fun k i a => .mux condition (yes.cells k i a) (no.cells k i a)
  label := fun l => .mux condition (yes.label l) (no.label l)

omit [∀ stack, Fintype (Γ stack)] in
theorem realizes_pushBits {S : Nat} (bits : DataBits ι Γ σ S) (input : ι → Bool)
    (v : σ) (tapes : ∀ k, List (Γ k)) (h : bits.Realizes input v tapes)
    (k : K) (f : σ → Γ k) :
    (pushBits bits k f).Realizes input v (Function.update tapes k (f v :: tapes k)) := by
  refine ⟨h.1, ?_⟩
  intro j i a
  by_cases hj : j = k
  · subst j
    simp only [pushBits, Function.update_self]
    by_cases hi : i.val = 0
    · rw [dite_eq_left hi, eval_table input _ _ v h.1]
      simp [encode, hi]
    · rw [dite_eq_right hi, h.2]
      apply bool_ext
      simp [encode, List.getElem?_cons, hi]
      exact ⟨of_decide_eq_true, decide_eq_true⟩
  · simpa only [pushBits, Function.update_of_ne hj] using h.2 j i a

omit [DecidableEq K] in
theorem realizes_peekBits {S : Nat} (bits : DataBits ι Γ σ S) (input : ι → Bool)
    (v : σ) (tapes : ∀ k, List (Γ k)) (h : bits.Realizes input v tapes)
    (k : K) (f : σ → Option (Γ k) → σ) (hlen : (tapes k).length ≤ S) :
    (peekBits bits k f).Realizes input (f v (tapes k).head?) tapes := by
  refine ⟨?_, h.2⟩
  intro w
  apply eval_table₂ input _ _ _ v (tapes k).head? h.1
  intro a
  simpa [List.head?_eq_getElem?] using
    eval_readBits input (bits.cells k) (tapes k) hlen (h.2 k) 0 a

theorem realizes_popBits {S : Nat} (bits : DataBits ι Γ σ S) (input : ι → Bool)
    (v : σ) (tapes : ∀ k, List (Γ k)) (h : bits.Realizes input v tapes)
    (k : K) (f : σ → Option (Γ k) → σ) (hlen : (tapes k).length ≤ S) :
    (popBits bits k f).Realizes input (f v (tapes k).head?)
      (Function.update tapes k (tapes k).tail) := by
  refine ⟨(realizes_peekBits bits input v tapes h k f hlen).1, ?_⟩
  intro j i a
  by_cases hj : j = k
  · subst j
    simp only [popBits, Function.update_self]
    rw [eval_readBits input (bits.cells k) (tapes k) hlen (h.2 k)]
    simp [encode, List.getElem?_tail]
  · simpa only [popBits, Function.update_of_ne hj] using h.2 j i a

omit [DecidableEq K] [∀ stack, Fintype (Γ stack)] in
theorem realizes_loadBits {S : Nat} (bits : DataBits ι Γ σ S) (input : ι → Bool)
    (v : σ) (tapes : ∀ k, List (Γ k)) (h : bits.Realizes input v tapes)
    (f : σ → σ) : (loadBits bits f).Realizes input (f v) tapes := by
  exact ⟨fun w => eval_table input f bits.state v h.1 w, h.2⟩

omit [DecidableEq K] [Fintype σ] [∀ stack, Fintype (Γ stack)] in
theorem realizes_muxResult {S : Nat} (input : ι → Bool) (condition : Expr ι)
    (yes no : ResultBits ι Γ Λ σ S) (decision : Bool) (hc : condition.eval input = decision)
    (yesCfg noCfg : TM2.Cfg Γ Λ σ)
    (hy : decision = true → yes.Realizes input yesCfg)
    (hn : decision = false → no.Realizes input noCfg) :
    (muxResult condition yes no).Realizes input (if decision then yesCfg else noCfg) := by
  cases decision with
  | false =>
    rcases hn rfl with ⟨⟨hv, hs⟩, hl⟩
    refine ⟨⟨?_, ?_⟩, ?_⟩
    · intro v; simpa only [muxResult, Expr.eval_mux, hc, Bool.false_eq_true, ite_false, ite_true] using hv v
    · intro k i a; simpa only [muxResult, Expr.eval_mux, hc, Bool.false_eq_true, ite_false, ite_true] using hs k i a
    · intro l; simpa only [muxResult, Expr.eval_mux, hc, Bool.false_eq_true, ite_false, ite_true] using hl l
  | true =>
    rcases hy rfl with ⟨⟨hv, hs⟩, hl⟩
    refine ⟨⟨?_, ?_⟩, ?_⟩
    · intro v; simpa only [muxResult, Expr.eval_mux, hc, Bool.false_eq_true, ite_false, ite_true] using hv v
    · intro k i a; simpa only [muxResult, Expr.eval_mux, hc, Bool.false_eq_true, ite_false, ite_true] using hs k i a
    · intro l; simpa only [muxResult, Expr.eval_mux, hc, Bool.false_eq_true, ite_false, ite_true] using hl l

noncomputable def compileAux {S : Nat} :
    TM2.Stmt Γ Λ σ → DataBits ι Γ σ S → ResultBits ι Γ Λ σ S
  | .push k f next, bits => compileAux next (pushBits bits k f)
  | .peek k f next, bits => compileAux next (peekBits bits k f)
  | .pop k f next, bits => compileAux next (popBits bits k f)
  | .load f next, bits => compileAux next (loadBits bits f)
  | .branch guard yes no, bits =>
      muxResult (table guard bits.state true) (compileAux yes bits) (compileAux no bits)
  | .goto label, bits =>
      { toDataBits := bits, label := table (fun v => some (label v)) bits.state }
  | .halt, bits =>
      { toDataBits := bits, label := fun l => .const (decide ((none : Option Λ) = l)) }

theorem compileAux_correct {S : Nat} (stmt : TM2.Stmt Γ Λ σ)
    (bits : DataBits ι Γ σ S) (input : ι → Bool) (v : σ) (tapes : ∀ k, List (Γ k))
    (safe : StatementSafe S stmt v tapes) (h : bits.Realizes input v tapes) :
    (compileAux stmt bits).Realizes input (TM2.stepAux stmt v tapes) := by
  induction stmt generalizing bits v tapes with
  | push k f next ih =>
    exact ih _ _ _ safe.2.2 (realizes_pushBits bits input v tapes h k f)
  | peek k f next ih =>
    exact ih _ _ _ safe.2 (realizes_peekBits bits input v tapes h k f (safe.1 k))
  | pop k f next ih =>
    exact ih _ _ _ safe.2 (realizes_popBits bits input v tapes h k f (safe.1 k))
  | load f next ih =>
    exact ih _ _ _ safe.2 (realizes_loadBits bits input v tapes h f)
  | branch guard yes no ihy ihn =>
    have hc : (table guard bits.state true).eval input = guard v := by
      rw [eval_table input guard bits.state v h.1]
      cases guard v <;> rfl
    have hy : guard v = true → (compileAux yes bits).Realizes input (TM2.stepAux yes v tapes) := by
      intro hg
      apply ihy bits v tapes _ h
      simpa [StatementSafe, hg] using safe.2
    have hn : guard v = false → (compileAux no bits).Realizes input (TM2.stepAux no v tapes) := by
      intro hg
      apply ihn bits v tapes _ h
      simpa [StatementSafe, hg] using safe.2
    have hm := realizes_muxResult input _ _ _ (guard v) hc _ _ hy hn
    cases hg : guard v <;> simpa [compileAux, TM2.stepAux, hg] using hm
  | goto label =>
    exact ⟨h, fun l => eval_table input _ bits.state v h.1 l⟩
  | halt => exact ⟨h, fun _ => rfl⟩

end Statements

section Encoding

variable {K : Type} {Γ : K → Type} {Λ σ : Type}
variable [DecidableEq K] [Fintype σ] [DecidableEq σ]
variable [∀ k, Fintype (Γ k)] [∀ k, DecidableEq (Γ k)] [DecidableEq Λ]

abbrev InputBit (Γ : K → Type) (σ : Type) (S : Nat) :=
  σ ⊕ (Σ k, Fin S × Option (Γ k))

abbrev ConfigBit (Γ : K → Type) (Λ σ : Type) (S : Nat) :=
  Option Λ ⊕ InputBit Γ σ S

def inputBits (S : Nat) : DataBits (InputBit Γ σ S) Γ σ S where
  state := fun v => .input (.inl v)
  cells := fun k i a => .input (.inr ⟨k, i, a⟩)

def inputEncoding (S : Nat) (v : σ) (tapes : ∀ k, List (Γ k)) : InputBit Γ σ S → Bool
  | .inl w => decide (v = w)
  | .inr ⟨k, i, a⟩ => decide (encode S (tapes k) i = a)

def configEncoding (S : Nat) (cfg : TM2.Cfg Γ Λ σ) : ConfigBit Γ Λ σ S → Bool
  | .inl label => decide (cfg.l = label)
  | .inr i => inputEncoding S cfg.var cfg.stk i

def resultExpr {ι : Type} {S : Nat} (bits : ResultBits ι Γ Λ σ S) :
    ConfigBit Γ Λ σ S → Expr ι
  | .inl label => bits.label label
  | .inr (.inl v) => bits.state v
  | .inr (.inr ⟨k, i, a⟩) => bits.cells k i a

omit [DecidableEq K] [Fintype σ] [∀ stack, Fintype (Γ stack)] in
theorem inputBits_realizes (S : Nat) (v : σ) (tapes : ∀ k, List (Γ k)) :
    (inputBits S).Realizes (inputEncoding S v tapes) v tapes := by
  exact ⟨fun _ => rfl, fun _ _ _ => rfl⟩

omit [DecidableEq K] [Fintype σ] [∀ stack, Fintype (Γ stack)] in
theorem resultExpr_eval {ι : Type} {S : Nat} (bits : ResultBits ι Γ Λ σ S)
    (input : ι → Bool) (cfg : TM2.Cfg Γ Λ σ) (h : bits.Realizes input cfg)
    (bit : ConfigBit Γ Λ σ S) :
    (resultExpr bits bit).eval input = configEncoding S cfg bit := by
  rcases bit with label | (v | ⟨k, i, a⟩)
  · exact h.2 label
  · exact h.1.1 v
  · exact h.1.2 k i a

noncomputable def transitionExpr (S : Nat) (stmt : TM2.Stmt Γ Λ σ) :
    ConfigBit Γ Λ σ S → Expr (InputBit Γ σ S) :=
  resultExpr (compileAux stmt (inputBits S))

theorem transitionExpr_eval (S : Nat) (stmt : TM2.Stmt Γ Λ σ)
    (v : σ) (tapes : ∀ k, List (Γ k)) (safe : StatementSafe S stmt v tapes)
    (bit : ConfigBit Γ Λ σ S) :
    (transitionExpr S stmt bit).eval (inputEncoding S v tapes) =
      configEncoding S (TM2.stepAux stmt v tapes) bit :=
  resultExpr_eval _ _ _ (compileAux_correct stmt _ _ v tapes safe
    (inputBits_realizes S v tapes)) bit

noncomputable def outputCircuit [Fintype K] (S : Nat) (stmt : TM2.Stmt Γ Λ σ)
    (bit : ConfigBit Γ Λ σ S) : Circuit :=
  (transitionExpr S stmt bit).circuit (Fintype.equivFin (InputBit Γ σ S))

theorem outputCircuit_eval [Fintype K] (S : Nat) (stmt : TM2.Stmt Γ Λ σ)
    (v : σ) (tapes : ∀ k, List (Γ k)) (safe : StatementSafe S stmt v tapes)
    (bit : ConfigBit Γ Λ σ S) :
    (outputCircuit S stmt bit).eval (fun i => inputEncoding S v tapes
      ((Fintype.equivFin (InputBit Γ σ S)).symm i)) =
      configEncoding S (TM2.stepAux stmt v tapes) bit := by
  have he := Expr.circuit_eval (Fintype.equivFin (InputBit Γ σ S))
    (transitionExpr S stmt bit)
    (fun (i : Fin (Fintype.card (InputBit Γ σ S))) => inputEncoding S v tapes
      ((Fintype.equivFin (InputBit Γ σ S)).symm i))
  apply he.trans
  simpa only [Equiv.symm_apply_apply] using transitionExpr_eval S stmt v tapes safe bit

end Encoding

variable {K : Type} {Γ : K → Type} {Λ σ ι : Type}
variable [DecidableEq K] [Fintype σ] [DecidableEq σ]
variable [∀ k, Fintype (Γ k)] [∀ k, DecidableEq (Γ k)] [DecidableEq Λ]

def DataBits.Bounded {S : Nat} (bits : DataBits ι Γ σ S) (C : Nat) : Prop :=
  (∀ v, (bits.state v).size ≤ C) ∧ ∀ k i a, (bits.cells k i a).size ≤ C

def ResultBits.Bounded {S : Nat} (bits : ResultBits ι Γ Λ σ S) (C : Nat) : Prop :=
  bits.toDataBits.Bounded C ∧ ∀ l, (bits.label l).size ≤ C

theorem size_readBits_le {A : Type} [DecidableEq A] {S : Nat}
    (bits : Fin S → Option A → Expr ι) (C : Nat) (hC : 1 ≤ C)
    (h : ∀ i a, (bits i a).size ≤ C) (n : Nat) (a : Option A) :
    (readBits bits n a).size ≤ C := by
  unfold readBits
  split
  · exact h _ _
  · exact hC

noncomputable def unaryCost (σ : Type) [Fintype σ] (C : Nat) : Nat :=
  Fintype.card σ * (C + 3) + 1

noncomputable def headCost (σ A : Type) [Fintype σ] [Fintype A] (C : Nat) : Nat :=
  (Fintype.card σ * Fintype.card (Option A)) * (2 * C + 4) + 1

noncomputable def statementCost : TM2.Stmt Γ Λ σ → Nat → Nat
  | .push _ _ next, C => statementCost next (max C (unaryCost σ C))
  | .peek k _ next, C => statementCost next (max C (headCost σ (Γ k) C))
  | .pop k _ next, C => statementCost next (max C (headCost σ (Γ k) C))
  | .load _ next, C => statementCost next (max C (unaryCost σ C))
  | .branch _ yes no, C =>
      2 * unaryCost σ C + statementCost yes C + statementCost no C + 4
  | .goto _, C => max C (unaryCost σ C)
  | .halt, C => max C 1

omit [DecidableEq σ] [∀ stack, Fintype (Γ stack)] in
theorem pushBits_bounded {S : Nat} (bits : DataBits ι Γ σ S) (C : Nat)
    (h : bits.Bounded C) (k : K) (f : σ → Γ k) :
    (pushBits bits k f).Bounded (max C (unaryCost σ C)) := by
  refine ⟨fun v => (h.1 v).trans (Nat.le_max_left _ _), ?_⟩
  intro j i a
  by_cases hj : j = k
  · subst j
    simp only [pushBits, Function.update_self]
    split
    · exact (size_table_le _ _ _ C h.1).trans (Nat.le_max_right _ _)
    · exact (h.2 _ _ _).trans (Nat.le_max_left _ _)
  · simpa only [pushBits, Function.update_of_ne hj] using
      (h.2 j i a).trans (Nat.le_max_left C (unaryCost σ C))

omit [DecidableEq K] in
theorem peekBits_bounded {S : Nat} (bits : DataBits ι Γ σ S) (C : Nat) (hC : 1 ≤ C)
    (h : bits.Bounded C) (k : K) (f : σ → Option (Γ k) → σ) :
    (peekBits bits k f).Bounded (max C (headCost σ (Γ k) C)) := by
  refine ⟨?_, fun j i a => (h.2 j i a).trans (Nat.le_max_left _ _)⟩
  intro v
  exact (size_table₂_le _ _ _ v C h.1
    (fun a => size_readBits_le _ C hC (h.2 k) 0 a)).trans (Nat.le_max_right _ _)

theorem popBits_bounded {S : Nat} (bits : DataBits ι Γ σ S) (C : Nat) (hC : 1 ≤ C)
    (h : bits.Bounded C) (k : K) (f : σ → Option (Γ k) → σ) :
    (popBits bits k f).Bounded (max C (headCost σ (Γ k) C)) := by
  refine ⟨(peekBits_bounded bits C hC h k f).1, ?_⟩
  intro j i a
  by_cases hj : j = k
  · subst j
    simpa only [popBits, Function.update_self] using
      (size_readBits_le _ C hC (h.2 k) (i.val + 1) a).trans
        (Nat.le_max_left C (headCost σ (Γ k) C))
  · simpa only [popBits, Function.update_of_ne hj] using
      (h.2 j i a).trans (Nat.le_max_left C (headCost σ (Γ k) C))

omit [DecidableEq K] [∀ stack, Fintype (Γ stack)] [∀ stack, DecidableEq (Γ stack)] in
theorem loadBits_bounded {S : Nat} (bits : DataBits ι Γ σ S) (C : Nat)
    (h : bits.Bounded C) (f : σ → σ) :
    (loadBits bits f).Bounded (max C (unaryCost σ C)) := by
  exact ⟨fun v => (size_table_le f bits.state v C h.1).trans (Nat.le_max_right _ _),
    fun k i a => (h.2 k i a).trans (Nat.le_max_left _ _)⟩

omit [DecidableEq K] [Fintype σ] [DecidableEq σ] [∀ stack, Fintype (Γ stack)]
  [∀ stack, DecidableEq (Γ stack)] [DecidableEq Λ] in
theorem muxResult_bounded {S : Nat} (condition : Expr ι) (yes no : ResultBits ι Γ Λ σ S)
    (G Y N : Nat) (hc : condition.size ≤ G) (hy : yes.Bounded Y) (hn : no.Bounded N) :
    (muxResult condition yes no).Bounded (2 * G + Y + N + 4) := by
  have hm (x y : Expr ι) (hx : x.size ≤ Y) (hy : y.size ≤ N) :
      (Expr.mux condition x y).size ≤ 2 * G + Y + N + 4 := by
    simp only [Expr.mux, Expr.size]
    omega
  exact ⟨⟨fun v => hm _ _ (hy.1.1 v) (hn.1.1 v),
    fun k i a => hm _ _ (hy.1.2 k i a) (hn.1.2 k i a)⟩,
    fun l => hm _ _ (hy.2 l) (hn.2 l)⟩

theorem compileAux_bounded {S : Nat} (stmt : TM2.Stmt Γ Λ σ)
    (bits : DataBits ι Γ σ S) (C : Nat) (hC : 1 ≤ C) (h : bits.Bounded C) :
    (compileAux stmt bits).Bounded (statementCost stmt C) := by
  induction stmt generalizing bits C with
  | push k f next ih =>
    exact ih _ _ (hC.trans (Nat.le_max_left _ _)) (pushBits_bounded bits C h k f)
  | peek k f next ih =>
    exact ih _ _ (hC.trans (Nat.le_max_left _ _)) (peekBits_bounded bits C hC h k f)
  | pop k f next ih =>
    exact ih _ _ (hC.trans (Nat.le_max_left _ _)) (popBits_bounded bits C hC h k f)
  | load f next ih =>
    exact ih _ _ (hC.trans (Nat.le_max_left _ _)) (loadBits_bounded bits C h f)
  | branch guard yes no ihy ihn =>
    exact muxResult_bounded _ _ _ _ _ _ (size_table_le guard bits.state true C h.1)
      (ihy bits C hC h) (ihn bits C hC h)
  | goto label =>
    exact ⟨⟨fun v => (h.1 v).trans (Nat.le_max_left _ _),
      fun k i a => (h.2 k i a).trans (Nat.le_max_left _ _)⟩,
      fun l => (size_table_le _ _ l C h.1).trans (Nat.le_max_right _ _)⟩
  | halt =>
    exact ⟨⟨fun v => (h.1 v).trans (Nat.le_max_left _ _),
      fun k i a => (h.2 k i a).trans (Nat.le_max_left _ _)⟩,
      fun _ => Nat.le_max_right _ _⟩

theorem transitionExpr_size_le (S : Nat) (stmt : TM2.Stmt Γ Λ σ)
    (bit : ConfigBit Γ Λ σ S) :
    (transitionExpr S stmt bit).size ≤ statementCost stmt 1 := by
  have h := compileAux_bounded stmt (inputBits S) 1 (by decide)
    ⟨fun _ => Nat.le_refl _, fun _ _ _ => Nat.le_refl _⟩
  rcases bit with label | (v | ⟨k, i, a⟩)
  · exact h.2 label
  · exact h.1.1 v
  · exact h.1.2 k i a

theorem outputCircuit_gates_le [Fintype K] (S : Nat) (stmt : TM2.Stmt Γ Λ σ)
    (bit : ConfigBit Γ Λ σ S) :
    (outputCircuit S stmt bit).gates.length ≤ statementCost stmt 1 := by
  simpa only [outputCircuit, Expr.circuit, Expr.gates_length] using
    transitionExpr_size_le S stmt bit

end BinPackingGames.Foundations.Complexity.CookLevin.StatementCircuit

namespace BinPackingGames.Foundations.Complexity.CookLevin.ConfigIndex

open StatementCircuit

variable {K : Type} (Γ : K → Type) (Λ σ : Type)

abbrev SymbolBit := Σ k, Option (Γ k)

structure Indexing where
  labelCount : Nat
  stateCount : Nat
  symbolCount : Nat
  labels : Option Λ ≃ Fin labelCount
  states : σ ≃ Fin stateCount
  symbols : SymbolBit Γ ≃ Fin symbolCount

variable {Γ Λ σ}

def Indexing.width (indexing : Indexing Γ Λ σ) (S : Nat) : Nat :=
  indexing.labelCount + indexing.stateCount + S * indexing.symbolCount

def cellReorder (S : Nat) : (Σ k, Fin S × Option (Γ k)) ≃ (Fin S × SymbolBit Γ) where
  toFun cell := (cell.2.1, ⟨cell.1, cell.2.2⟩)
  invFun cell := ⟨cell.2.1, cell.1, cell.2.2⟩
  left_inv cell := by rcases cell with ⟨k, i, a⟩; rfl
  right_inv cell := by rcases cell with ⟨i, k, a⟩; rfl

def Indexing.configIndexEquiv (indexing : Indexing Γ Λ σ) (S : Nat) :
    ConfigBit Γ Λ σ S ≃ Fin (indexing.width S) :=
  (Equiv.sumCongr indexing.labels
    (Equiv.sumCongr indexing.states
      ((cellReorder S).trans
        ((Equiv.prodCongr (Equiv.refl (Fin S)) indexing.symbols).trans finProdFinEquiv)))).trans
    ((Equiv.sumAssoc (Fin indexing.labelCount) (Fin indexing.stateCount)
      (Fin (S * indexing.symbolCount))).symm.trans
      ((Equiv.sumCongr finSumFinEquiv (Equiv.refl (Fin (S * indexing.symbolCount)))).trans
        finSumFinEquiv))

@[simp] theorem Indexing.configIndex_label (indexing : Indexing Γ Λ σ)
    (S : Nat) (label : Option Λ) :
    (indexing.configIndexEquiv S (.inl label)).val = (indexing.labels label).val := by
  rfl

@[simp] theorem Indexing.configIndex_state (indexing : Indexing Γ Λ σ)
    (S : Nat) (state : σ) :
    (indexing.configIndexEquiv S (.inr (.inl state))).val =
      indexing.labelCount + (indexing.states state).val := by
  rfl

@[simp] theorem Indexing.configIndex_cell (indexing : Indexing Γ Λ σ)
    (S : Nat) (k : K) (i : Fin S) (symbol : Option (Γ k)) :
    (indexing.configIndexEquiv S (.inr (.inr ⟨k, i, symbol⟩))).val =
      indexing.labelCount + indexing.stateCount + i.val * indexing.symbolCount +
        (indexing.symbols ⟨k, symbol⟩).val := by
  change indexing.labelCount + indexing.stateCount +
    ((indexing.symbols ⟨k, symbol⟩).val + indexing.symbolCount * i.val) = _
  rw [Nat.mul_comm indexing.symbolCount i.val]
  omega

noncomputable def ofMachine (machine : Turing.FinTM2)
    [∀ k, Fintype (machine.Γ k)] : Indexing machine.Γ machine.Λ machine.σ := by
  letI := machine.kFin
  letI := machine.ΛFin
  letI := machine.σFin
  exact {
    labelCount := Fintype.card (Option machine.Λ)
    stateCount := Fintype.card machine.σ
    symbolCount := Fintype.card (SymbolBit machine.Γ)
    labels := Fintype.equivFin (Option machine.Λ)
    states := Fintype.equivFin machine.σ
    symbols := Fintype.equivFin (SymbolBit machine.Γ) }

end BinPackingGames.Foundations.Complexity.CookLevin.ConfigIndex

end OAI