math / data /lean /OAI /Computability /BinPacking /CookLevin /ConfigIndex.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
55.8 kB
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
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]