Download data/lean/OAI/Computability/BinPacking/CookLevin/VerifierCircuit.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 53 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/BinPacking/CookLevin/VerifierCircuit.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/BinPacking/CookLevin/VerifierCircuit.lean
-
curl -L -o VerifierCircuit.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/BinPacking/CookLevin/VerifierCircuit.lean
53 kB
import Mathlib.Algebra.BigOperators.Group.Finset.Basic
import Mathlib.Data.List.OfFn
import Mathlib.Tactic.Linarith
import OAI.Computability.BinPacking.CookLevin.Bounds
import OAI.Computability.BinPacking.CookLevin.OutputOrder
namespace OAI
noncomputable section
namespace BinPackingGames.Foundations.Complexity.CookLevin
def decodePairAux : Nat → List Bool → Option (List Bool × List Bool)
| _, [] => none
| read, true :: rest => decodePairAux (read + 1) rest
| read, false :: rest =>
if read ≤ rest.length then some (rest.take read, rest.drop read) else none
def decodePair (bits : List Bool) : Option (List Bool × List Bool) :=
decodePairAux 0 bits
theorem decodePairAux_frame (read count : Nat) (rest : List Bool) :
decodePairAux read (List.replicate count true ++ false :: rest) =
if read + count ≤ rest.length then
some (rest.take (read + count), rest.drop (read + count)) else none := by
induction count generalizing read with
| zero => simp [decodePairAux]
| succ count ih =>
simp only [List.replicate_succ, List.cons_append, decodePairAux, ih]
simp only [Nat.add_assoc, Nat.add_comm 1 count]
@[simp] theorem decodePair_pairBits (input : List Bool × List Bool) :
decodePair (pairBits input) = some input := by
rcases input with ⟨x, witness⟩
simp [decodePair, pairBits, encodeWord, List.append_assoc,
decodePairAux_frame]
theorem pairBits_injective : Function.Injective pairBits := by
intro first second same
have h := congrArg decodePair same
simpa only [decodePair_pairBits, Option.some.injEq] using h
@[simp] theorem pairBits_length (input : List Bool × List Bool) :
(pairBits input).length = 2 * input.1.length + input.2.length + 1 := by
simp only [pairBits, List.length_append, encodeWord_length]
omega
def pairEncoding : Computability.Encoding (List Bool × List Bool) Bool where
encode := pairBits
decode := decodePair
decode_encode := decodePair_pairBits
theorem NPVerifier.acceptedLanguage_inNP (verifier : NPVerifier) :
InNP verifier.Accepts := ⟨verifier, fun _ => Iff.rfl⟩
structure PolynomialThreeSATReduction (language : List Bool → Prop) where
reduce : List Bool → Target.Formula
computation : Turing.TM2ComputableInPolyTime id formulaBits reduce
correct : ∀ input, language input ↔ (reduce input).Satisfiable
noncomputable def NPVerifier.horizon (verifier : NPVerifier) (inputLength : Nat) : Nat :=
verifier.computation.time.eval
(2 * inputLength + verifier.witnessBound.eval inputLength + 1)
theorem NPVerifier.input_time_le_horizon (verifier : NPVerifier)
(input witness : List Bool)
(bounded : witness.length ≤ verifier.witnessBound.eval input.length) :
verifier.computation.time.eval (pairBits (input, witness)).length ≤
verifier.horizon input.length := by
apply MachineComposition.natPolynomial_eval_mono
rw [pairBits_length]
exact Nat.add_le_add_right (Nat.add_le_add_left bounded _) _
def NPVerifier.runWithinHorizon (verifier : NPVerifier)
(input witness : List Bool)
(bounded : witness.length ≤ verifier.witnessBound.eval input.length) :
Turing.TM2OutputsInTime verifier.computation.tm
((pairBits (input, witness)).map verifier.computation.inputAlphabet.invFun)
(some ([verifier.verify (input, witness)].map verifier.computation.outputAlphabet.invFun))
(verifier.horizon input.length) where
toEvalsTo := (verifier.computation.outputsFun (input, witness)).toEvalsTo
steps_le_m := Nat.le_trans
(verifier.computation.outputsFun (input, witness)).steps_le_m
(verifier.input_time_le_horizon input witness bounded)
end BinPackingGames.Foundations.Complexity.CookLevin
namespace BinPackingGames.Foundations.Complexity.CookLevin.WitnessEncoding
open scoped BigOperators
abbrev Bits (q : Nat) := Fin (2 * q + 1) → Bool
def selector {q : Nat} (bits : Bits q) (i : Fin (q + 1)) : Bool :=
bits ⟨i.val, by omega⟩
def payload {q : Nat} (bits : Bits q) (i : Fin q) : Bool :=
bits ⟨q + 1 + i.val, by omega⟩
def pack {q : Nat} (lengthBits : Fin (q + 1) → Bool)
(payloadBits : Fin q → Bool) : Bits q := fun i =>
if h : i.val < q + 1 then lengthBits ⟨i.val, h⟩
else payloadBits ⟨i.val - (q + 1), by omega⟩
@[simp] theorem selector_pack {q : Nat} (lengthBits : Fin (q + 1) → Bool)
(payloadBits : Fin q → Bool) (i : Fin (q + 1)) :
selector (pack lengthBits payloadBits) i = lengthBits i := by
simp [selector, pack, i.isLt]
@[simp] theorem payload_pack {q : Nat} (lengthBits : Fin (q + 1) → Bool)
(payloadBits : Fin q → Bool) (i : Fin q) :
payload (pack lengthBits payloadBits) i = payloadBits i := by
simp [payload, pack]
omega
def Valid {q : Nat} (bits : Bits q) : Prop :=
∃ length : Fin (q + 1), ∀ i, selector bits i = decide (i = length)
theorem valid_iff_local {q : Nat} (bits : Bits q) :
Valid bits ↔
(∃ i, selector bits i = true) ∧
(∀ i j, selector bits i = true → selector bits j = true → i = j) := by
constructor
· rintro ⟨length, h⟩
refine ⟨⟨length, by simp [h]⟩, ?_⟩
intro i j hi hj
have hil : i = length := by simpa [h] using hi
have hjl : j = length := by simpa [h] using hj
exact hil.trans hjl.symm
· rintro ⟨⟨length, hl⟩, hu⟩
refine ⟨length, fun i => ?_⟩
by_cases hi : i = length
· subst i; simp [hl]
· have hf : selector bits i = false := by
cases hbi : selector bits i
· rfl
· exact False.elim (hi (hu i length hbi hl))
simp [hi, hf]
def selectedLength {q : Nat} (bits : Bits q) : Nat :=
∑ i : Fin (q + 1), if selector bits i then i.val else 0
theorem selectedLength_eq {q : Nat} (bits : Bits q) (length : Fin (q + 1))
(h : ∀ i, selector bits i = decide (i = length)) :
selectedLength bits = length.val := by
simp [selectedLength, h]
def decode {q : Nat} (bits : Bits q) : List Bool :=
(List.ofFn (payload bits)).take (selectedLength bits)
theorem decode_length_le {q : Nat} (bits : Bits q) : (decode bits).length ≤ q := by
simp [decode]
theorem decode_length_eq {q : Nat} (bits : Bits q) (length : Fin (q + 1))
(h : ∀ i, selector bits i = decide (i = length)) :
(decode bits).length = length.val := by
simp [decode, selectedLength_eq bits length h, Nat.min_eq_left (by omega : length.val ≤ q)]
def encode (q : Nat) (witness : List Bool) (h : witness.length ≤ q) : Bits q :=
pack (fun i => decide (i = ⟨witness.length, by omega⟩))
(fun i => witness[i.val]?.getD false)
@[simp] theorem selector_encode (q : Nat) (witness : List Bool)
(h : witness.length ≤ q) (i : Fin (q + 1)) :
selector (encode q witness h) i =
decide (i = ⟨witness.length, by omega⟩) := by
simp [encode]
@[simp] theorem payload_encode (q : Nat) (witness : List Bool)
(h : witness.length ≤ q) (i : Fin q) :
payload (encode q witness h) i = witness[i.val]?.getD false := by
simp [encode]
theorem encode_valid (q : Nat) (witness : List Bool) (h : witness.length ≤ q) :
Valid (encode q witness h) :=
⟨⟨witness.length, by omega⟩, selector_encode q witness h⟩
@[simp] theorem selectedLength_encode (q : Nat) (witness : List Bool)
(h : witness.length ≤ q) : selectedLength (encode q witness h) = witness.length :=
selectedLength_eq _ ⟨witness.length, by omega⟩ (selector_encode q witness h)
@[simp] theorem decode_encode (q : Nat) (witness : List Bool) (h : witness.length ≤ q) :
decode (encode q witness h) = witness := by
unfold decode
rw [selectedLength_encode]
apply List.ext_getElem?
intro n
by_cases hn : n < witness.length
· have hnq : n < q := Nat.lt_of_lt_of_le hn h
simp [hn, hnq]
· simp [hn]
theorem exists_valid_iff (q : Nat) (P : List Bool → Prop) :
(∃ bits : Bits q, Valid bits ∧ P (decode bits)) ↔
∃ witness : List Bool, witness.length ≤ q ∧ P witness := by
constructor
· rintro ⟨bits, _, hp⟩
exact ⟨decode bits, decode_length_le bits, hp⟩
· rintro ⟨witness, h, hp⟩
exact ⟨encode q witness h, encode_valid q witness h, by simpa using hp⟩
def present {q : Nat} (bits : Bits q) (n : Nat) : Bool :=
decide (∃ length : Fin (q + 1), selector bits length = true ∧ n < length.val)
theorem present_eq {q : Nat} (bits : Bits q) (length : Fin (q + 1))
(h : ∀ i, selector bits i = decide (i = length)) (n : Nat) :
present bits n = decide (n < length.val) := by
simp [present, h]
def witnessCell {q : Nat} (bits : Bits q) (n : Nat) : Option Bool :=
if h : n < q then
if present bits n then some (payload bits ⟨n, h⟩) else none
else none
theorem witnessCell_eq_getElem? {q : Nat} (bits : Bits q) (hv : Valid bits) (n : Nat) :
witnessCell bits n = (decode bits)[n]? := by
obtain ⟨length, h⟩ := hv
simp only [witnessCell, decode, selectedLength_eq bits length h,
present_eq bits length h, List.getElem?_take, List.getElem?_ofFn]
by_cases hnq : n < q <;> by_cases hnl : n < length.val <;> simp [hnq, hnl]
theorem witnessCell_end {q : Nat} (bits : Bits q) (hv : Valid bits)
(n : Nat) (hn : (decode bits).length ≤ n) : witnessCell bits n = none := by
rw [witnessCell_eq_getElem? bits hv, List.getElem?_eq_none hn]
def inputPrefix (input : List Bool) : List Bool := encodeWord input.length ++ input
@[simp] theorem inputPrefix_length (input : List Bool) :
(inputPrefix input).length = 2 * input.length + 1 := by
simp only [inputPrefix, List.length_append, encodeWord_length]
omega
def pairCell {q : Nat} (input : List Bool) (bits : Bits q) (n : Nat) : Option Bool :=
if n < (inputPrefix input).length then (inputPrefix input)[n]?
else witnessCell bits (n - (inputPrefix input).length)
theorem pairCell_eq_getElem? {q : Nat} (input : List Bool) (bits : Bits q)
(hv : Valid bits) (n : Nat) :
pairCell input bits n = (pairBits (input, decode bits))[n]? := by
rw [pairBits]
change pairCell input bits n = (inputPrefix input ++ decode bits)[n]?
rw [List.getElem?_append]
simp only [pairCell, witnessCell_eq_getElem? bits hv]
theorem pairBits_decode_length_le {q : Nat} (input : List Bool) (bits : Bits q) :
(pairBits (input, decode bits)).length ≤ 2 * input.length + q + 1 := by
rw [pairBits_length]
change 2 * input.length + (decode bits).length + 1 ≤ 2 * input.length + q + 1
have h := decode_length_le bits
omega
theorem pairCells_eq_stackEncoding {q : Nat} (input : List Bool) (bits : Bits q)
(hv : Valid bits) (capacity : Nat) :
(fun i : Fin capacity => pairCell input bits i.val) =
StackEncoding.encode capacity (pairBits (input, decode bits)) := by
funext i
exact pairCell_eq_getElem? input bits hv i.val
noncomputable def freeInputPolynomial (q : Polynomial Nat) : Polynomial Nat := 2 * q + 1
@[simp] theorem freeInputPolynomial_eval (q : Polynomial Nat) (n : Nat) :
(freeInputPolynomial q).eval n = 2 * q.eval n + 1 := by
simp [freeInputPolynomial]
def localConstraintSites (q : Nat) : Nat := (q + 1) + (q + 1) ^ 2 + q * (q + 1)
theorem localConstraintSites_le (q : Nat) : localConstraintSites q ≤ 3 * (q + 1) ^ 2 := by
unfold localConstraintSites
nlinarith
noncomputable def localConstraintPolynomial (q : Polynomial Nat) : Polynomial Nat := 3 * (q + 1) ^ 2
theorem localConstraintSites_le_eval (q : Polynomial Nat) (n : Nat) :
localConstraintSites (q.eval n) ≤ (localConstraintPolynomial q).eval n := by
simpa [localConstraintPolynomial] using localConstraintSites_le (q.eval n)
variable (verifier : NPVerifier) (input : List Bool)
def initial (bits : Bits (verifier.witnessBound.eval input.length)) :
verifier.computation.tm.Cfg :=
Turing.initList verifier.computation.tm
((pairBits (input, decode bits)).map verifier.computation.inputAlphabet.invFun)
@[simp] theorem initial_control (bits : Bits (verifier.witnessBound.eval input.length)) :
(initial verifier input bits).l = some verifier.computation.tm.main := rfl
@[simp] theorem initial_state (bits : Bits (verifier.witnessBound.eval input.length)) :
(initial verifier input bits).var = verifier.computation.tm.initialState := rfl
@[simp] theorem initial_input_stack (bits : Bits (verifier.witnessBound.eval input.length)) :
(initial verifier input bits).stk verifier.computation.tm.k₀ =
(pairBits (input, decode bits)).map verifier.computation.inputAlphabet.invFun := by
simp [initial, Turing.initList]
theorem initial_other_stack (bits : Bits (verifier.witnessBound.eval input.length))
(k : verifier.computation.tm.K) (hk : k ≠ verifier.computation.tm.k₀) :
(initial verifier input bits).stk k = [] := by
simp [initial, Turing.initList, hk]
theorem initial_input_cell (bits : Bits (verifier.witnessBound.eval input.length))
(hv : Valid bits) (n : Nat) :
((initial verifier input bits).stk verifier.computation.tm.k₀)[n]? =
(pairCell input bits n).map verifier.computation.inputAlphabet.invFun := by
rw [initial_input_stack, List.getElem?_map, pairCell_eq_getElem? input bits hv]
theorem initial_input_end (bits : Bits (verifier.witnessBound.eval input.length))
(n : Nat) (hn : 2 * input.length + (decode bits).length + 1 ≤ n) :
((initial verifier input bits).stk verifier.computation.tm.k₀)[n]? = none := by
rw [initial_input_stack]
apply List.getElem?_eq_none
simpa only [List.length_map, pairBits_length] using hn
theorem initial_stack_length_le (bits : Bits (verifier.witnessBound.eval input.length))
(k : verifier.computation.tm.K) :
((initial verifier input bits).stk k).length ≤
2 * input.length + verifier.witnessBound.eval input.length + 1 := by
by_cases hk : k = verifier.computation.tm.k₀
· subst k
rw [initial_input_stack, List.length_map]
exact pairBits_decode_length_le input bits
· rw [initial_other_stack verifier input bits k hk]
simp
theorem initial_encode (witness : List Bool)
(h : witness.length ≤ verifier.witnessBound.eval input.length) :
initial verifier input (encode _ witness h) =
Turing.initList verifier.computation.tm
((pairBits (input, witness)).map verifier.computation.inputAlphabet.invFun) := by
simp [initial]
theorem accepts_iff_valid_assignment :
verifier.Accepts input ↔
∃ bits : Bits (verifier.witnessBound.eval input.length),
Valid bits ∧ verifier.verify (input, decode bits) = true := by
exact (exists_valid_iff _ (fun witness => verifier.verify (input, witness) = true)).symm
end BinPackingGames.Foundations.Complexity.CookLevin.WitnessEncoding
namespace BinPackingGames.Foundations.Complexity.CookLevin.WitnessCircuit
open StatementCircuit WitnessEncoding
private theorem bool_ext {a b : Bool} (h : a = true ↔ b = true) : a = b := by
cases a <;> cases b <;> simp_all
private theorem eval_disjoin_ofFn_true {ι : Type*} {n : Nat}
(input : ι → Bool) (es : Fin n → Expr ι) :
(Expr.disjoin (List.ofFn es)).eval input = true ↔ ∃ i, (es i).eval input = true := by
rw [Expr.eval_disjoin_true]
constructor
· rintro ⟨e, he, h⟩
obtain ⟨i, rfl⟩ := List.mem_ofFn.mp he
exact ⟨i, h⟩
· rintro ⟨i, h⟩
exact ⟨es i, List.mem_ofFn.mpr ⟨i, rfl⟩, h⟩
def selectorExpr (q : Nat) (i : Fin (q + 1)) : Expr (Fin (2 * q + 1)) :=
.input ⟨i.val, by omega⟩
def payloadExpr (q : Nat) (i : Fin q) : Expr (Fin (2 * q + 1)) :=
.input ⟨q + 1 + i.val, by omega⟩
@[simp] theorem eval_selectorExpr {q : Nat} (bits : Bits q) (i : Fin (q + 1)) :
(selectorExpr q i).eval bits = selector bits i := rfl
@[simp] theorem eval_payloadExpr {q : Nat} (bits : Bits q) (i : Fin q) :
(payloadExpr q i).eval bits = payload bits i := rfl
def nonemptyExpr (q : Nat) : Expr (Fin (2 * q + 1)) :=
.disjoin (List.ofFn (selectorExpr q))
def clashPairExpr (q : Nat) (i j : Fin (q + 1)) : Expr (Fin (2 * q + 1)) :=
if i = j then .const false else .and (selectorExpr q i) (selectorExpr q j)
def clashExpr (q : Nat) : Expr (Fin (2 * q + 1)) :=
.disjoin (List.ofFn fun i => .disjoin (List.ofFn (clashPairExpr q i)))
def validityExpr (q : Nat) : Expr (Fin (2 * q + 1)) :=
.and (nonemptyExpr q) (.not (clashExpr q))
theorem eval_nonemptyExpr {q : Nat} (bits : Bits q) :
(nonemptyExpr q).eval bits = true ↔ ∃ i, selector bits i = true := by
simp only [nonemptyExpr, eval_disjoin_ofFn_true, eval_selectorExpr]
theorem eval_clashPairExpr {q : Nat} (bits : Bits q) (i j : Fin (q + 1)) :
(clashPairExpr q i j).eval bits = true ↔
i ≠ j ∧ selector bits i = true ∧ selector bits j = true := by
by_cases h : i = j <;> simp [clashPairExpr, h, Expr.eval]
theorem eval_clashExpr {q : Nat} (bits : Bits q) :
(clashExpr q).eval bits = true ↔
∃ i j, i ≠ j ∧ selector bits i = true ∧ selector bits j = true := by
simp only [clashExpr, eval_disjoin_ofFn_true, eval_clashPairExpr]
theorem eval_validityExpr {q : Nat} (bits : Bits q) :
(validityExpr q).eval bits = true ↔ Valid bits := by
rw [valid_iff_local]
simp only [validityExpr, Expr.eval, Bool.and_eq_true, Bool.not_eq_true']
rw [eval_nonemptyExpr]
have hc := eval_clashExpr bits
constructor
· rintro ⟨hne, hclash⟩
refine ⟨hne, fun i j hi hj => ?_⟩
by_contra hij
have ht := hc.mpr ⟨i, j, hij, hi, hj⟩
simp [hclash] at ht
· rintro ⟨hne, hu⟩
refine ⟨hne, ?_⟩
cases hb : (clashExpr q).eval bits
· rfl
· obtain ⟨i, j, hij, hi, hj⟩ := hc.mp hb
exact False.elim (hij (hu i j hi hj))
def presenceExpr (q n : Nat) : Expr (Fin (2 * q + 1)) :=
.disjoin (List.ofFn fun length : Fin (q + 1) =>
.and (selectorExpr q length) (.const (decide (n < length.val))))
theorem eval_presenceExpr {q : Nat} (bits : Bits q) (n : Nat) :
(presenceExpr q n).eval bits = present bits n := by
apply bool_ext
simp only [presenceExpr, eval_disjoin_ofFn_true, Expr.eval, eval_selectorExpr,
Bool.and_eq_true, present, decide_eq_true_eq]
section Symbols
variable {A : Type*} [DecidableEq A]
def payloadSymbolExpr (q : Nat) (f : Bool → A) (i : Fin q) (a : Option A) :
Expr (Fin (2 * q + 1)) :=
.mux (payloadExpr q i)
(.const (decide (some (f true) = a))) (.const (decide (some (f false) = a)))
theorem eval_payloadSymbolExpr {q : Nat} (bits : Bits q) (f : Bool → A)
(i : Fin q) (a : Option A) :
(payloadSymbolExpr q f i a).eval bits = decide (some (f (payload bits i)) = a) := by
rw [payloadSymbolExpr, Expr.eval_mux, eval_payloadExpr]
cases payload bits i <;> simp [Expr.eval]
def inputCellExpr (q : Nat) (input : List Bool) (f : Bool → A) (n : Nat) (a : Option A) :
Expr (Fin (2 * q + 1)) :=
if n < (inputPrefix input).length then
.const (decide (((inputPrefix input)[n]?).map f = a))
else if h : n - (inputPrefix input).length < q then
.mux (presenceExpr q (n - (inputPrefix input).length))
(payloadSymbolExpr q f ⟨n - (inputPrefix input).length, h⟩ a)
(.const (decide ((none : Option A) = a)))
else .const (decide ((none : Option A) = a))
theorem eval_inputCellExpr {q : Nat} (bits : Bits q) (input : List Bool)
(f : Bool → A) (n : Nat) (a : Option A) :
(inputCellExpr q input f n a).eval bits = decide ((pairCell input bits n).map f = a) := by
by_cases hp : n < (inputPrefix input).length
· simp only [inputCellExpr, pairCell, ite_eq_left hp, Expr.eval]
· by_cases hq : n - (inputPrefix input).length < q
· simp only [inputCellExpr, hp, ite_false, hq, dite_eq_left, Expr.eval_mux,
eval_presenceExpr, eval_payloadSymbolExpr, Expr.eval, pairCell, witnessCell]
cases present bits (n - (inputPrefix input).length) <;> simp
· simp only [inputCellExpr, pairCell, witnessCell, ite_eq_right hp, dite_eq_right hq,
Expr.eval, Option.map_none]
end Symbols
section Size
@[simp] theorem size_selectorExpr (q : Nat) (i : Fin (q + 1)) :
(selectorExpr q i).size = 1 := rfl
@[simp] theorem size_payloadExpr (q : Nat) (i : Fin q) :
(payloadExpr q i).size = 1 := rfl
theorem size_mux {ι : Type*} (c y n : Expr ι) :
(Expr.mux c y n).size = 2 * c.size + y.size + n.size + 4 := by
simp only [Expr.mux, Expr.size]
omega
theorem size_nonemptyExpr_le (q : Nat) :
(nonemptyExpr q).size ≤ 2 * (q + 1) + 1 := by
have h := Expr.size_disjoin_le (List.ofFn (selectorExpr q)) 1 (by
intro e he
obtain ⟨i, rfl⟩ := List.mem_ofFn.mp he
simp)
simpa [nonemptyExpr, Nat.mul_comm] using h
theorem size_clashPairExpr_le (q : Nat) (i j : Fin (q + 1)) :
(clashPairExpr q i j).size ≤ 3 := by
by_cases h : i = j <;> simp [clashPairExpr, h, Expr.size, selectorExpr]
theorem size_clashExpr_le (q : Nat) :
(clashExpr q).size ≤ (q + 1) * (4 * (q + 1) + 2) + 1 := by
have hi (i : Fin (q + 1)) :
(Expr.disjoin (List.ofFn (clashPairExpr q i))).size ≤ 4 * (q + 1) + 1 := by
have h := Expr.size_disjoin_le (List.ofFn (clashPairExpr q i)) 3 (by
intro e he
obtain ⟨j, rfl⟩ := List.mem_ofFn.mp he
exact size_clashPairExpr_le q i j)
simpa [Nat.mul_comm] using h
have h := Expr.size_disjoin_le
(List.ofFn fun i => Expr.disjoin (List.ofFn (clashPairExpr q i)))
(4 * (q + 1) + 1) (by
intro e he
obtain ⟨i, rfl⟩ := List.mem_ofFn.mp he
exact hi i)
simpa [clashExpr, Nat.add_assoc] using h
theorem size_validityExpr_le (q : Nat) : (validityExpr q).size ≤ 12 * (q + 1) ^ 2 := by
have hn := size_nonemptyExpr_le q
have hc := size_clashExpr_le q
simp only [validityExpr, Expr.size]
nlinarith
theorem size_presenceExpr_le (q n : Nat) : (presenceExpr q n).size ≤ 4 * (q + 1) + 1 := by
have h := Expr.size_disjoin_le
(List.ofFn fun length : Fin (q + 1) =>
Expr.and (selectorExpr q length) (.const (decide (n < length.val)))) 3 (by
intro e he
obtain ⟨i, rfl⟩ := List.mem_ofFn.mp he
simp [Expr.size])
simpa [presenceExpr, Nat.mul_comm] using h
theorem size_payloadSymbolExpr {A : Type*} [DecidableEq A]
(q : Nat) (f : Bool → A) (i : Fin q) (a : Option A) :
(payloadSymbolExpr q f i a).size = 8 := by
simp [payloadSymbolExpr, size_mux, Expr.size]
theorem size_inputCellExpr_le {A : Type*} [DecidableEq A]
(q : Nat) (input : List Bool) (f : Bool → A) (n : Nat) (a : Option A) :
(inputCellExpr q input f n a).size ≤ 8 * (q + 1) + 15 := by
unfold inputCellExpr
split
· simp [Expr.size]
· split
· rw [size_mux, size_payloadSymbolExpr]
have h := size_presenceExpr_le q (n - (inputPrefix input).length)
simp only [Expr.size]
omega
· simp [Expr.size]
end Size
section Initial
variable (verifier : NPVerifier)
variable [DecidableEq verifier.computation.tm.Λ]
variable [DecidableEq verifier.computation.tm.σ]
variable [∀ k, DecidableEq (verifier.computation.tm.Γ k)]
def initialCellExpr (input : List Bool) (S : Nat)
(k : verifier.computation.tm.K) (i : Fin S) (a : Option (verifier.computation.tm.Γ k)) :
Expr (Fin (2 * verifier.witnessBound.eval input.length + 1)) :=
if h : k = verifier.computation.tm.k₀ then by
subst k
exact inputCellExpr _ input verifier.computation.inputAlphabet.invFun i.val a
else .const (decide ((none : Option (verifier.computation.tm.Γ k)) = a))
omit [DecidableEq verifier.computation.tm.Λ] [DecidableEq verifier.computation.tm.σ] in
theorem eval_initialCellExpr (input : List Bool) (S : Nat)
(bits : Bits (verifier.witnessBound.eval input.length)) (hv : Valid bits)
(k : verifier.computation.tm.K) (i : Fin S) (a : Option (verifier.computation.tm.Γ k)) :
(initialCellExpr verifier input S k i a).eval bits =
decide (StackEncoding.encode S ((initial verifier input bits).stk k) i = a) := by
by_cases hk : k = verifier.computation.tm.k₀
· subst k
simpa [initialCellExpr, StackEncoding.encode,
pairCell_eq_getElem? input bits hv i.val] using
eval_inputCellExpr bits input verifier.computation.inputAlphabet.invFun i.val a
· simp [initialCellExpr, hk, initial_other_stack verifier input bits k hk,
StackEncoding.encode, Expr.eval]
def initExpr (input : List Bool) (S : Nat) :
ConfigBit verifier.computation.tm.Γ verifier.computation.tm.Λ verifier.computation.tm.σ S →
Expr (Fin (2 * verifier.witnessBound.eval input.length + 1))
| .inl label => .const (decide (some verifier.computation.tm.main = label))
| .inr (.inl state) => .const (decide (verifier.computation.tm.initialState = state))
| .inr (.inr ⟨k, i, a⟩) => initialCellExpr verifier input S k i a
theorem eval_initExpr (input : List Bool) (S : Nat)
(bits : Bits (verifier.witnessBound.eval input.length)) (hv : Valid bits)
(bit : ConfigBit verifier.computation.tm.Γ verifier.computation.tm.Λ
verifier.computation.tm.σ S) :
(initExpr verifier input S bit).eval bits =
configEncoding S (initial verifier input bits) bit := by
rcases bit with label | (state | ⟨k, i, a⟩)
· rfl
· rfl
· exact eval_initialCellExpr verifier input S bits hv k i a
omit [DecidableEq verifier.computation.tm.Λ] [DecidableEq verifier.computation.tm.σ] in
theorem size_initialCellExpr_le (input : List Bool) (S : Nat)
(k : verifier.computation.tm.K) (i : Fin S) (a : Option (verifier.computation.tm.Γ k)) :
(initialCellExpr verifier input S k i a).size ≤
8 * (verifier.witnessBound.eval input.length + 1) + 15 := by
by_cases hk : k = verifier.computation.tm.k₀
· subst k
simpa [initialCellExpr] using
size_inputCellExpr_le (verifier.witnessBound.eval input.length) input
verifier.computation.inputAlphabet.invFun i.val a
· simp [initialCellExpr, hk, Expr.size]
theorem size_initExpr_le (input : List Bool) (S : Nat)
(bit : ConfigBit verifier.computation.tm.Γ verifier.computation.tm.Λ
verifier.computation.tm.σ S) :
(initExpr verifier input S bit).size ≤
8 * (verifier.witnessBound.eval input.length + 1) + 15 := by
rcases bit with label | (state | ⟨k, i, a⟩)
· simp [initExpr, Expr.size]
· simp [initExpr, Expr.size]
· exact size_initialCellExpr_le verifier input S k i a
end Initial
def validityCircuit (q : Nat) : Circuit := (validityExpr q).circuit id
theorem validityCircuit_eval {q : Nat} (bits : Bits q) :
(validityCircuit q).eval bits = true ↔ Valid bits := by
change ((validityExpr q).circuit id).eval bits = true ↔ Valid bits
rw [Expr.circuit_eval]
exact eval_validityExpr bits
theorem validityCircuit_gates_le (q : Nat) :
(validityCircuit q).gates.length ≤ 12 * (q + 1) ^ 2 := by
simpa only [validityCircuit, Expr.circuit, Expr.gates_length] using size_validityExpr_le q
end BinPackingGames.Foundations.Complexity.CookLevin.WitnessCircuit
namespace BinPackingGames.Foundations.Complexity.CookLevin.VerifierBounds
open Polynomial
def initializationPolynomial (q : Polynomial ℕ) : Polynomial ℕ :=
C 8 * (q + 1) + C 15
def validationPolynomial (q : Polynomial ℕ) : Polynomial ℕ :=
C 12 * (q + 1) ^ 2
@[simp] theorem initializationPolynomial_eval (q : Polynomial ℕ) (n : ℕ) :
(initializationPolynomial q).eval n = 8 * (q.eval n + 1) + 15 := by
simp [initializationPolynomial]
@[simp] theorem validationPolynomial_eval (q : Polynomial ℕ) (n : ℕ) :
(validationPolynomial q).eval n = 12 * (q.eval n + 1) ^ 2 := by
simp [validationPolynomial]
def gatesPolynomial (p q : Polynomial ℕ)
(pushes controlBits alphabetBits expressionCost : ℕ)
(initialization validation : Polynomial ℕ) : Polynomial ℕ :=
let W := Bounds.configurationWidthPolynomial p q pushes controlBits alphabetBits
W * initialization + validation +
Bounds.horizonPolynomial p q * ((W + 1) * C expressionCost) +
(C 3 * W + C 4)
@[simp] theorem gatesPolynomial_eval (p q : Polynomial ℕ)
(pushes controlBits alphabetBits expressionCost : ℕ)
(initialization validation : Polynomial ℕ) (n : ℕ) :
(gatesPolynomial p q pushes controlBits alphabetBits expressionCost initialization validation).eval n =
(Bounds.configurationWidthPolynomial p q pushes controlBits alphabetBits).eval n *
initialization.eval n + validation.eval n +
(Bounds.horizonPolynomial p q).eval n *
(((Bounds.configurationWidthPolynomial p q pushes controlBits alphabetBits).eval n + 1) *
expressionCost) +
(3 * (Bounds.configurationWidthPolynomial p q pushes controlBits alphabetBits).eval n + 4) := by
simp [gatesPolynomial]
def bitsPolynomial (p q : Polynomial ℕ)
(pushes controlBits alphabetBits expressionCost : ℕ)
(initialization validation : Polynomial ℕ) : Polynomial ℕ :=
Bounds.circuitBitsPolynomial (WitnessEncoding.freeInputPolynomial q)
(gatesPolynomial p q pushes controlBits alphabetBits expressionCost initialization validation)
def machineGatesPolynomial (p q : Polynomial ℕ)
(pushes controlBits alphabetBits expressionCost : ℕ) : Polynomial ℕ :=
gatesPolynomial p q pushes controlBits alphabetBits expressionCost
(initializationPolynomial q) (validationPolynomial q)
def machineBitsPolynomial (p q : Polynomial ℕ)
(pushes controlBits alphabetBits expressionCost : ℕ) : Polynomial ℕ :=
bitsPolynomial p q pushes controlBits alphabetBits expressionCost
(initializationPolynomial q) (validationPolynomial q)
@[simp] theorem machineGatesPolynomial_eval (p q : Polynomial ℕ)
(pushes controlBits alphabetBits expressionCost n : ℕ) :
(machineGatesPolynomial p q pushes controlBits alphabetBits expressionCost).eval n =
(Bounds.configurationWidthPolynomial p q pushes controlBits alphabetBits).eval n *
(8 * (q.eval n + 1) + 15) + 12 * (q.eval n + 1) ^ 2 +
(Bounds.horizonPolynomial p q).eval n *
(((Bounds.configurationWidthPolynomial p q pushes controlBits alphabetBits).eval n + 1) *
expressionCost) +
(3 * (Bounds.configurationWidthPolynomial p q pushes controlBits alphabetBits).eval n + 4) := by
simp only [machineGatesPolynomial, gatesPolynomial_eval,
initializationPolynomial_eval, validationPolynomial_eval]
theorem toFormula_bits_le (circuit : Circuit) (p q : Polynomial ℕ)
(pushes controlBits alphabetBits expressionCost : ℕ)
(initialization validation : Polynomial ℕ) (n : ℕ)
(hi : circuit.inputs ≤ 2 * q.eval n + 1)
(hg : circuit.gates.length ≤
(Bounds.configurationWidthPolynomial p q pushes controlBits alphabetBits).eval n *
initialization.eval n + validation.eval n +
(Bounds.horizonPolynomial p q).eval n *
(((Bounds.configurationWidthPolynomial p q pushes controlBits alphabetBits).eval n + 1) *
expressionCost) +
(3 * (Bounds.configurationWidthPolynomial p q pushes controlBits alphabetBits).eval n + 4)) :
(formulaBits circuit.toFormula).length ≤
(bitsPolynomial p q pushes controlBits alphabetBits expressionCost initialization validation).eval n := by
apply Bounds.toFormula_bits_length_le_polynomial
· simpa only [WitnessEncoding.freeInputPolynomial_eval] using hi
· simpa only [gatesPolynomial_eval] using hg
theorem toFormula_bits_le_machinePolynomial (circuit : Circuit) (p q : Polynomial ℕ)
(pushes controlBits alphabetBits expressionCost n : ℕ)
(hi : circuit.inputs ≤ 2 * q.eval n + 1)
(hg : circuit.gates.length ≤
(machineGatesPolynomial p q pushes controlBits alphabetBits expressionCost).eval n) :
(formulaBits circuit.toFormula).length ≤
(machineBitsPolynomial p q pushes controlBits alphabetBits expressionCost).eval n := by
apply Bounds.toFormula_bits_length_le_polynomial
· simpa only [WitnessEncoding.freeInputPolynomial_eval] using hi
· exact hg
end BinPackingGames.Foundations.Complexity.CookLevin.VerifierBounds
namespace BinPackingGames.Foundations.Complexity.CookLevin.VerifierCircuit
open Turing StatementCircuit CircuitBatch
open scoped BigOperators
local instance alphabetFinite (V : NPVerifier) : ∀ k, Fintype (V.computation.tm.Γ k) :=
V.finiteAlphabet
local instance labelFinite (V : NPVerifier) : Fintype V.computation.tm.Λ :=
V.computation.tm.ΛFin
local instance stateFinite (V : NPVerifier) : Fintype V.computation.tm.σ :=
V.computation.tm.σFin
local instance labelDecidable (V : NPVerifier) : DecidableEq V.computation.tm.Λ :=
Classical.decEq _
local instance stateDecidable (V : NPVerifier) : DecidableEq V.computation.tm.σ :=
Classical.decEq _
local instance alphabetDecidable (V : NPVerifier) : ∀ k, DecidableEq (V.computation.tm.Γ k) :=
fun _ => Classical.decEq _
def capacity (V : NPVerifier) (n : Nat) : Nat :=
2 * n + V.witnessBound.eval n + 1 + V.horizon n * Runtime.programPushBound V.computation.tm
theorem capacity_pos (V : NPVerifier) (n : Nat) : 1 ≤ capacity V n := by
unfold capacity
omega
abbrev FreeBits (V : NPVerifier) (input : List Bool) :=
WitnessEncoding.Bits (V.witnessBound.eval input.length)
def machineInput (V : NPVerifier) (input : List Bool) (bits : FreeBits V input) :=
(pairBits (input, WitnessEncoding.decode bits)).map V.computation.inputAlphabet.invFun
def actualRun (V : NPVerifier) (input : List Bool) (bits : FreeBits V input) (t : Nat) :
V.computation.tm.Cfg := BoundedExecution.run V.computation.tm (machineInput V input bits) t
def accepting (V : NPVerifier) : V.computation.tm.Cfg :=
haltList V.computation.tm ([true].map V.computation.outputAlphabet.invFun)
theorem stackCapacity_le (V : NPVerifier) (input : List Bool) (bits : FreeBits V input) :
BoundedExecution.stackCapacity V.computation.tm (machineInput V input bits)
(V.horizon input.length) ≤ capacity V input.length := by
have h := WitnessEncoding.pairBits_decode_length_le input bits
simp only [BoundedExecution.stackCapacity, machineInput, List.length_map, capacity]
omega
theorem actualRun_stack_le (V : NPVerifier) (input : List Bool) (bits : FreeBits V input)
(t : Nat) (ht : t ≤ V.horizon input.length) (k : V.computation.tm.K) :
((actualRun V input bits t).stk k).length ≤ capacity V input.length :=
(BoundedExecution.run_stack_le V.computation.tm (machineInput V input bits)
(V.horizon input.length) t ht k).trans (stackCapacity_le V input bits)
theorem actualRun_stepSafe (V : NPVerifier) (input : List Bool) (bits : FreeBits V input)
(t : Nat) (ht : t < V.horizon input.length) :
MachineCircuit.StepSafe (capacity V input.length) V.computation.tm.m
(actualRun V input bits t) := by
intro label _
apply BoundedExecution.statementSafe_of_budget
intro k
exact (BoundedExecution.statement_budget V.computation.tm (machineInput V input bits)
(V.horizon input.length) t ht label k).trans (stackCapacity_le V input bits)
theorem accepting_stack_le (V : NPVerifier) (input : List Bool) (k : V.computation.tm.K) :
((accepting V).stk k).length ≤ capacity V input.length := by
by_cases hk : k = V.computation.tm.k₁
· subst k
simpa [accepting, haltList] using capacity_pos V input.length
· simp [accepting, haltList, hk]
theorem actualRun_accepting_iff (V : NPVerifier) (input : List Bool) (bits : FreeBits V input) :
actualRun V input bits (V.horizon input.length) = accepting V ↔
V.verify (input, WitnessEncoding.decode bits) = true := by
have hr := BoundedExecution.run_eq_halt_of_outputs V.computation.tm
(machineInput V input bits)
([V.verify (input, WitnessEncoding.decode bits)].map V.computation.outputAlphabet.invFun)
(V.horizon input.length)
(V.runWithinHorizon input (WitnessEncoding.decode bits) (WitnessEncoding.decode_length_le bits))
change actualRun V input bits (V.horizon input.length) = _ at hr
rw [hr]
constructor
· intro h
have hs := congrArg (fun c : V.computation.tm.Cfg => c.stk V.computation.tm.k₁) h
have he : V.computation.outputAlphabet.invFun (V.verify (input, WitnessEncoding.decode bits)) =
V.computation.outputAlphabet.invFun true := by
simpa [accepting, haltList] using hs
exact V.computation.outputAlphabet.symm.injective he
· intro h
simp [h, accepting]
abbrev Bit (V : NPVerifier) (input : List Bool) :=
ConfigBit V.computation.tm.Γ V.computation.tm.Λ V.computation.tm.σ (capacity V input.length)
def indexing (V : NPVerifier) :
ConfigIndex.Indexing V.computation.tm.Γ V.computation.tm.Λ V.computation.tm.σ :=
ConfigIndex.ofMachine V.computation.tm
abbrev width (V : NPVerifier) (input : List Bool) : Nat :=
(indexing V).width (capacity V input.length)
def bitEquiv (V : NPVerifier) (input : List Bool) : Bit V input ≃ Fin (width V input) :=
(indexing V).configIndexEquiv (capacity V input.length)
def bitWire (V : NPVerifier) (input : List Bool) (b : Bit V input) : Fin (width V input + 1) :=
(bitEquiv V input b).castSucc
def stateEncoding (V : NPVerifier) (input : List Bool) (cfg : V.computation.tm.Cfg)
(valid : Bool) : Fin (width V input + 1) → Bool :=
Fin.lastCases valid (fun j => configEncoding (capacity V input.length) cfg
((bitEquiv V input).symm j))
@[simp] theorem stateEncoding_last (V : NPVerifier) (input : List Bool)
(cfg : V.computation.tm.Cfg) (valid : Bool) :
stateEncoding V input cfg valid (Fin.last (width V input)) = valid := by
simp [stateEncoding]
@[simp] theorem stateEncoding_bitWire (V : NPVerifier) (input : List Bool)
(cfg : V.computation.tm.Cfg) (valid : Bool) (b : Bit V input) :
stateEncoding V input cfg valid (bitWire V input b) =
configEncoding (capacity V input.length) cfg b := by
simp [stateEncoding, bitWire]
def initialExpressions (V : NPVerifier) (input : List Bool) :
Fin (width V input + 1) → Expr (Fin (2 * V.witnessBound.eval input.length + 1)) :=
Fin.lastCases (WitnessCircuit.validityExpr (V.witnessBound.eval input.length))
(fun j => WitnessCircuit.initExpr V input (capacity V input.length)
((bitEquiv V input).symm j))
def stepExpressions (V : NPVerifier) (input : List Bool) :
Fin (width V input + 1) → Expr (Fin (width V input + 1)) :=
Fin.lastCases (.input (Fin.last (width V input)))
(fun j => (MachineCircuit.stickyExpr (capacity V input.length) V.computation.tm.m
((bitEquiv V input).symm j)).rename (bitWire V input))
theorem initialExpressions_eval (V : NPVerifier) (input : List Bool) (bits : FreeBits V input)
(hv : WitnessEncoding.Valid bits) :
(fun j => (initialExpressions V input j).eval bits) =
stateEncoding V input (WitnessEncoding.initial V input bits)
((WitnessCircuit.validityExpr _).eval bits) := by
funext j
refine Fin.lastCases ?_ (fun i => ?_) j
· simp [initialExpressions, stateEncoding]
· simpa [initialExpressions, stateEncoding] using
WitnessCircuit.eval_initExpr V input (capacity V input.length) bits hv
((bitEquiv V input).symm i)
theorem stepExpressions_eval (V : NPVerifier) (input : List Bool) (cfg : V.computation.tm.Cfg)
(safe : MachineCircuit.StepSafe (capacity V input.length) V.computation.tm.m cfg)
(valid : Bool) :
Frame.network (stepExpressions V input) (stateEncoding V input cfg valid) =
stateEncoding V input (BoundedExecution.stickyNext V.computation.tm cfg) valid := by
funext j
refine Fin.lastCases ?_ (fun i => ?_) j
· simp [Frame.network, stepExpressions, Expr.eval, stateEncoding]
· simp only [Frame.network, stepExpressions, Fin.lastCases_castSucc, Expr.eval_rename]
have he : (fun b => stateEncoding V input cfg valid (bitWire V input b)) =
configEncoding (capacity V input.length) cfg := by funext b; simp
rw [he, MachineCircuit.stickyExpr_eval _ _ cfg safe]
simp only [stateEncoding, Fin.lastCases_castSucc]
rfl
def initialFrame (V : NPVerifier) (input : List Bool) :
Frame (2 * V.witnessBound.eval input.length + 1) (width V input + 1) :=
(Frame.initial id).step (initialExpressions V input)
def timeFrame (V : NPVerifier) (input : List Bool) (t : Nat) :
Frame (2 * V.witnessBound.eval input.length + 1) (width V input + 1) :=
(initialFrame V input).repeat (stepExpressions V input) t
theorem initialFrame_eval (V : NPVerifier) (input : List Bool) (bits : FreeBits V input)
(hv : WitnessEncoding.Valid bits) :
(initialFrame V input).eval bits = stateEncoding V input
(WitnessEncoding.initial V input bits) ((WitnessCircuit.validityExpr _).eval bits) := by
rw [initialFrame, Frame.step_eval_fun]
have hi : (Frame.initial id).eval bits = bits := by funext i; simp
rw [hi]
exact initialExpressions_eval V input bits hv
theorem timeFrame_validity (V : NPVerifier) (input : List Bool) (bits : FreeBits V input)
(t : Nat) :
(timeFrame V input t).eval bits (Fin.last (width V input)) =
(WitnessCircuit.validityExpr (V.witnessBound.eval input.length)).eval bits := by
induction t with
| zero =>
simp only [timeFrame, Frame.repeat, initialFrame, Frame.step_eval,
initialExpressions, Fin.lastCases_last]
apply Expr.eval_congr
intro i
exact Frame.initial_eval id bits i
| succ t ih =>
simpa only [timeFrame, Frame.repeat, Frame.step_eval, stepExpressions,
Fin.lastCases_last, Expr.eval] using ih
theorem timeFrame_eval (V : NPVerifier) (input : List Bool) (bits : FreeBits V input)
(hv : WitnessEncoding.Valid bits) (t : Nat) (ht : t ≤ V.horizon input.length) :
(timeFrame V input t).eval bits = stateEncoding V input (actualRun V input bits t)
((WitnessCircuit.validityExpr _).eval bits) := by
induction t with
| zero => exact initialFrame_eval V input bits hv
| succ t ih =>
have hprev := ih (by omega)
change ((timeFrame V input t).step (stepExpressions V input)).eval bits = _
rw [Frame.step_eval_fun, hprev]
have hs := stepExpressions_eval V input (actualRun V input bits t)
(actualRun_stepSafe V input bits t (by omega))
((WitnessCircuit.validityExpr _).eval bits)
change (fun i => (stepExpressions V input i).eval
(stateEncoding V input (actualRun V input bits t)
((WitnessCircuit.validityExpr _).eval bits))) = _ at hs
simpa only [actualRun, BoundedExecution.run_succ] using hs
def mismatchExpr (V : NPVerifier) (input : List Bool) (j : Fin (width V input)) :
Expr (Fin (width V input + 1)) :=
if configEncoding (capacity V input.length) (accepting V) ((bitEquiv V input).symm j)
then .not (.input j.castSucc) else .input j.castSucc
def acceptanceExpr (V : NPVerifier) (input : List Bool) : Expr (Fin (width V input + 1)) :=
.and (.input (Fin.last (width V input)))
(.not (Expr.disjoin (List.ofFn (mismatchExpr V input))))
theorem mismatchExpr_eval (V : NPVerifier) (input : List Bool)
(state : Fin (width V input + 1) → Bool) (j : Fin (width V input)) :
(mismatchExpr V input j).eval state = true ↔
state j.castSucc ≠ configEncoding (capacity V input.length) (accepting V)
((bitEquiv V input).symm j) := by
cases ht : configEncoding (capacity V input.length) (accepting V)
((bitEquiv V input).symm j) <;> cases hs : state j.castSucc <;>
simp [mismatchExpr, Expr.eval, ht, hs]
theorem acceptanceExpr_eval (V : NPVerifier) (input : List Bool)
(state : Fin (width V input + 1) → Bool) :
(acceptanceExpr V input).eval state = true ↔
state (Fin.last (width V input)) = true ∧
∀ j : Fin (width V input), state j.castSucc =
configEncoding (capacity V input.length) (accepting V) ((bitEquiv V input).symm j) := by
have hd : (Expr.disjoin (List.ofFn (mismatchExpr V input))).eval state = true ↔
∃ j : Fin (width V input), state j.castSucc ≠
configEncoding (capacity V input.length) (accepting V) ((bitEquiv V input).symm j) := by
rw [Expr.eval_disjoin_true]
constructor
· rintro ⟨e, he, hv⟩
obtain ⟨j, rfl⟩ := List.mem_ofFn.mp he
exact ⟨j, (mismatchExpr_eval V input state j).mp hv⟩
· rintro ⟨j, hj⟩
exact ⟨_, List.mem_ofFn.mpr ⟨j, rfl⟩, (mismatchExpr_eval V input state j).mpr hj⟩
have hz : (Expr.disjoin (List.ofFn (mismatchExpr V input))).eval state = false ↔
∀ j : Fin (width V input), state j.castSucc =
configEncoding (capacity V input.length) (accepting V) ((bitEquiv V input).symm j) := by
constructor
· intro h j
by_contra hj
have ht := hd.mpr ⟨j, hj⟩
rw [h] at ht
contradiction
· intro h
cases ht : (Expr.disjoin (List.ofFn (mismatchExpr V input))).eval state with
| false => rfl
| true =>
obtain ⟨j, hj⟩ := hd.mp ht
exact False.elim (hj (h j))
simp only [acceptanceExpr, Expr.eval, Bool.and_eq_true, Bool.not_eq_true_eq_eq_false]
exact and_congr_right (fun _ => hz)
theorem acceptanceExpr_stateEncoding (V : NPVerifier) (input : List Bool)
(cfg : V.computation.tm.Cfg) (valid : Bool)
(hcfg : ∀ k, (cfg.stk k).length ≤ capacity V input.length) :
(acceptanceExpr V input).eval (stateEncoding V input cfg valid) = true ↔
valid = true ∧ cfg = accepting V := by
rw [acceptanceExpr_eval]
constructor
· rintro ⟨hv, hbits⟩
refine ⟨by simpa using hv, ?_⟩
apply MachineCircuit.configEncoding_injective (capacity V input.length)
cfg (accepting V) hcfg (accepting_stack_le V input)
funext b
have h := hbits (bitEquiv V input b)
simpa [stateEncoding] using h
· rintro ⟨hv, rfl⟩
simp [stateEncoding, hv]
def circuitOfVerifier (V : NPVerifier) (input : List Bool) : Circuit :=
((timeFrame V input (V.horizon input.length)).step
(fun _ : Fin 1 => acceptanceExpr V input)).toCircuit 0
@[simp] theorem circuitOfVerifier_inputs (V : NPVerifier) (input : List Bool) :
(circuitOfVerifier V input).inputs = 2 * V.witnessBound.eval input.length + 1 := rfl
theorem circuitOfVerifier_eval (V : NPVerifier) (input : List Bool) (bits : FreeBits V input) :
(circuitOfVerifier V input).eval bits =
(acceptanceExpr V input).eval ((timeFrame V input (V.horizon input.length)).eval bits) := by
change (((timeFrame V input (V.horizon input.length)).step
(fun _ : Fin 1 => acceptanceExpr V input)).toCircuit 0).eval bits = _
rw [Frame.toCircuit_eval, Frame.step_eval]
theorem circuitOfVerifier_accepts_iff (V : NPVerifier) (input : List Bool)
(bits : FreeBits V input) :
(circuitOfVerifier V input).eval bits = true ↔
WitnessEncoding.Valid bits ∧ V.verify (input, WitnessEncoding.decode bits) = true := by
rw [circuitOfVerifier_eval]
constructor
· intro h
have hvalid := ((acceptanceExpr_eval V input _).mp h).1
rw [timeFrame_validity] at hvalid
have hv : WitnessEncoding.Valid bits := (WitnessCircuit.eval_validityExpr bits).mp hvalid
rw [timeFrame_eval V input bits hv _ le_rfl] at h
have he := (acceptanceExpr_stateEncoding V input
(actualRun V input bits (V.horizon input.length)) _
(actualRun_stack_le V input bits _ le_rfl)).mp h
exact ⟨hv, (actualRun_accepting_iff V input bits).mp he.2⟩
· rintro ⟨hv, hverify⟩
rw [timeFrame_eval V input bits hv _ le_rfl]
apply (acceptanceExpr_stateEncoding V input
(actualRun V input bits (V.horizon input.length)) _
(actualRun_stack_le V input bits _ le_rfl)).mpr
exact ⟨(WitnessCircuit.eval_validityExpr bits).mpr hv,
(actualRun_accepting_iff V input bits).mpr hverify⟩
theorem circuitOfVerifier_correct (V : NPVerifier) (input : List Bool) :
(circuitOfVerifier V input).toFormula.Satisfiable ↔ V.Accepts input := by
rw [Circuit.toFormula_satisfiable_iff_eval, WitnessEncoding.accepts_iff_valid_assignment]
change (∃ bits : FreeBits V input, (circuitOfVerifier V input).eval bits = true) ↔ _
exact exists_congr (fun bits => circuitOfVerifier_accepts_iff V input bits)
theorem mismatchExpr_size_le (V : NPVerifier) (input : List Bool) (j : Fin (width V input)) :
(mismatchExpr V input j).size ≤ 2 := by
unfold mismatchExpr
split <;> simp [Expr.size]
theorem acceptanceExpr_size_le (V : NPVerifier) (input : List Bool) :
(acceptanceExpr V input).size ≤ 3 * width V input + 4 := by
have h := Expr.size_disjoin_le (List.ofFn (mismatchExpr V input)) 2 (by
intro e he
obtain ⟨j, rfl⟩ := List.mem_ofFn.mp he
exact mismatchExpr_size_le V input j)
simp only [List.length_ofFn] at h
simp only [acceptanceExpr, Expr.size]
omega
theorem stepExpressions_size_le (V : NPVerifier) (input : List Bool)
(j : Fin (width V input + 1)) :
(stepExpressions V input j).size ≤ MachineCircuit.expressionCost V.computation.tm.m := by
refine Fin.lastCases ?_ (fun i => ?_) j
· simp only [stepExpressions, Fin.lastCases_last, Expr.size, MachineCircuit.expressionCost]
omega
· simpa [stepExpressions] using MachineCircuit.stickyExpr_size_le
(capacity V input.length) V.computation.tm.m ((bitEquiv V input).symm i)
theorem initialExpressions_cost_le (V : NPVerifier) (input : List Bool) :
Batch.cost (List.ofFn (initialExpressions V input)) ≤
width V input * (8 * (V.witnessBound.eval input.length + 1) + 15) +
12 * (V.witnessBound.eval input.length + 1) ^ 2 := by
rw [Batch.cost_ofFn, Fin.sum_univ_castSucc]
simp only [initialExpressions, Fin.lastCases_castSucc, Fin.lastCases_last]
apply Nat.add_le_add
· calc
_ ≤ ∑ _ : Fin (width V input), (8 * (V.witnessBound.eval input.length + 1) + 15) := by
apply Finset.sum_le_sum
intro i _
exact WitnessCircuit.size_initExpr_le V input (capacity V input.length)
((bitEquiv V input).symm i)
_ = _ := by simp
· exact WitnessCircuit.size_validityExpr_le _
theorem circuitOfVerifier_gate_count (V : NPVerifier) (input : List Bool) :
(circuitOfVerifier V input).gates.length =
Batch.cost (List.ofFn (initialExpressions V input)) +
V.horizon input.length * Batch.cost (List.ofFn (stepExpressions V input)) +
(acceptanceExpr V input).size := by
change ((timeFrame V input (V.horizon input.length)).step
(fun _ : Fin 1 => acceptanceExpr V input)).fragment.gates.length = _
rw [Frame.step_gate_count]
simp only [timeFrame, Frame.repeat_gate_count, initialFrame, Frame.step_gate_count,
Frame.initial, Fragment.empty, List.length_nil, Nat.zero_add]
have hsingle : Batch.cost (List.ofFn (fun _ : Fin 1 => acceptanceExpr V input)) =
(acceptanceExpr V input).size := by simp [Batch.cost]
rw [hsingle]
theorem circuitOfVerifier_gates_le (V : NPVerifier) (input : List Bool) :
(circuitOfVerifier V input).gates.length ≤
width V input * (8 * (V.witnessBound.eval input.length + 1) + 15) +
12 * (V.witnessBound.eval input.length + 1) ^ 2 +
V.horizon input.length * ((width V input + 1) *
MachineCircuit.expressionCost V.computation.tm.m) + (3 * width V input + 4) := by
rw [circuitOfVerifier_gate_count]
exact Nat.add_le_add
(Nat.add_le_add (initialExpressions_cost_le V input)
(Nat.mul_le_mul_left _ (Batch.cost_ofFn_le _ _ (stepExpressions_size_le V input))))
(acceptanceExpr_size_le V input)
def widthPolynomial (V : NPVerifier) : Polynomial Nat :=
Bounds.configurationWidthPolynomial V.computation.time V.witnessBound
(Runtime.programPushBound V.computation.tm)
((indexing V).labelCount + (indexing V).stateCount) (indexing V).symbolCount
theorem widthPolynomial_eval (V : NPVerifier) (input : List Bool) :
(widthPolynomial V).eval input.length = width V input := by
simp [widthPolynomial, width, ConfigIndex.Indexing.width, capacity,
NPVerifier.horizon, Nat.mul_comm]
def gatePolynomial (V : NPVerifier) : Polynomial Nat :=
VerifierBounds.machineGatesPolynomial V.computation.time V.witnessBound
(Runtime.programPushBound V.computation.tm)
((indexing V).labelCount + (indexing V).stateCount) (indexing V).symbolCount
(MachineCircuit.expressionCost V.computation.tm.m)
def formulaPolynomial (V : NPVerifier) : Polynomial Nat :=
VerifierBounds.machineBitsPolynomial V.computation.time V.witnessBound
(Runtime.programPushBound V.computation.tm)
((indexing V).labelCount + (indexing V).stateCount) (indexing V).symbolCount
(MachineCircuit.expressionCost V.computation.tm.m)
theorem circuitOfVerifier_gates_le_polynomial (V : NPVerifier) (input : List Bool) :
(circuitOfVerifier V input).gates.length ≤ (gatePolynomial V).eval input.length := by
have hw := widthPolynomial_eval V input
unfold widthPolynomial at hw
simpa only [gatePolynomial, VerifierBounds.machineGatesPolynomial_eval, hw,
Bounds.horizonPolynomial_eval, NPVerifier.horizon] using
circuitOfVerifier_gates_le V input
theorem circuitOfVerifier_formulaBits_length_le (V : NPVerifier) (input : List Bool) :
(formulaBits (circuitOfVerifier V input).toFormula).length ≤
(formulaPolynomial V).eval input.length := by
unfold formulaPolynomial
apply VerifierBounds.toFormula_bits_le_machinePolynomial
· exact Nat.le_refl _
· exact circuitOfVerifier_gates_le_polynomial V input
end BinPackingGames.Foundations.Complexity.CookLevin.VerifierCircuit
end
end OAI
import Mathlib.Algebra.BigOperators.Group.Finset.Basic
import Mathlib.Data.List.OfFn
import Mathlib.Tactic.Linarith
import OAI.Computability.BinPacking.CookLevin.Bounds
import OAI.Computability.BinPacking.CookLevin.OutputOrder
namespace OAI
noncomputable section
namespace BinPackingGames.Foundations.Complexity.CookLevin
def decodePairAux : Nat → List Bool → Option (List Bool × List Bool)
| _, [] => none
| read, true :: rest => decodePairAux (read + 1) rest
| read, false :: rest =>
if read ≤ rest.length then some (rest.take read, rest.drop read) else none
def decodePair (bits : List Bool) : Option (List Bool × List Bool) :=
decodePairAux 0 bits
theorem decodePairAux_frame (read count : Nat) (rest : List Bool) :
decodePairAux read (List.replicate count true ++ false :: rest) =
if read + count ≤ rest.length then
some (rest.take (read + count), rest.drop (read + count)) else none := by
induction count generalizing read with
| zero => simp [decodePairAux]
| succ count ih =>
simp only [List.replicate_succ, List.cons_append, decodePairAux, ih]
simp only [Nat.add_assoc, Nat.add_comm 1 count]
@[simp] theorem decodePair_pairBits (input : List Bool × List Bool) :
decodePair (pairBits input) = some input := by
rcases input with ⟨x, witness⟩
simp [decodePair, pairBits, encodeWord, List.append_assoc,
decodePairAux_frame]
theorem pairBits_injective : Function.Injective pairBits := by
intro first second same
have h := congrArg decodePair same
simpa only [decodePair_pairBits, Option.some.injEq] using h
@[simp] theorem pairBits_length (input : List Bool × List Bool) :
(pairBits input).length = 2 * input.1.length + input.2.length + 1 := by
simp only [pairBits, List.length_append, encodeWord_length]
omega
def pairEncoding : Computability.Encoding (List Bool × List Bool) Bool where
encode := pairBits
decode := decodePair
decode_encode := decodePair_pairBits
theorem NPVerifier.acceptedLanguage_inNP (verifier : NPVerifier) :
InNP verifier.Accepts := ⟨verifier, fun _ => Iff.rfl⟩
structure PolynomialThreeSATReduction (language : List Bool → Prop) where
reduce : List Bool → Target.Formula
computation : Turing.TM2ComputableInPolyTime id formulaBits reduce
correct : ∀ input, language input ↔ (reduce input).Satisfiable
noncomputable def NPVerifier.horizon (verifier : NPVerifier) (inputLength : Nat) : Nat :=
verifier.computation.time.eval
(2 * inputLength + verifier.witnessBound.eval inputLength + 1)
theorem NPVerifier.input_time_le_horizon (verifier : NPVerifier)
(input witness : List Bool)
(bounded : witness.length ≤ verifier.witnessBound.eval input.length) :
verifier.computation.time.eval (pairBits (input, witness)).length ≤
verifier.horizon input.length := by
apply MachineComposition.natPolynomial_eval_mono
rw [pairBits_length]
exact Nat.add_le_add_right (Nat.add_le_add_left bounded _) _
def NPVerifier.runWithinHorizon (verifier : NPVerifier)
(input witness : List Bool)
(bounded : witness.length ≤ verifier.witnessBound.eval input.length) :
Turing.TM2OutputsInTime verifier.computation.tm
((pairBits (input, witness)).map verifier.computation.inputAlphabet.invFun)
(some ([verifier.verify (input, witness)].map verifier.computation.outputAlphabet.invFun))
(verifier.horizon input.length) where
toEvalsTo := (verifier.computation.outputsFun (input, witness)).toEvalsTo
steps_le_m := Nat.le_trans
(verifier.computation.outputsFun (input, witness)).steps_le_m
(verifier.input_time_le_horizon input witness bounded)
end BinPackingGames.Foundations.Complexity.CookLevin
namespace BinPackingGames.Foundations.Complexity.CookLevin.WitnessEncoding
open scoped BigOperators
abbrev Bits (q : Nat) := Fin (2 * q + 1) → Bool
def selector {q : Nat} (bits : Bits q) (i : Fin (q + 1)) : Bool :=
bits ⟨i.val, by omega⟩
def payload {q : Nat} (bits : Bits q) (i : Fin q) : Bool :=
bits ⟨q + 1 + i.val, by omega⟩
def pack {q : Nat} (lengthBits : Fin (q + 1) → Bool)