| import Mathlib.Data.List.FinRange |
| import Mathlib.Tactic.DeriveFintype |
| import OAI.Computability.BinPacking.Computation.MachineHorner |
| import OAI.Computability.BinPacking.CookLevin.ConfigIndex |
|
|
| namespace OAI |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.CircuitProducerModel |
|
|
| open Turing |
| open BinPackingGames.Foundations.Hastad |
| open BinPackingGames.Reduction |
|
|
| def gateTemplate (tag : Fin 5) (position : Fin 9) : Fin 3 × Bool := |
| match tag.val with |
| | 0 => (0, false) |
| | 1 => (0, true) |
| | 2 => [(0, true), (1, true), (1, true), |
| (0, false), (1, false), (1, false), |
| (0, true), (1, true), (1, true)].get position |
| | 3 => [(0, false), (1, true), (1, true), |
| (0, false), (2, true), (2, true), |
| (0, true), (1, false), (2, false)].get position |
| | _ => [(0, true), (1, false), (1, false), |
| (0, true), (2, false), (2, false), |
| (0, false), (1, true), (2, true)].get position |
|
|
| structure Record where |
| tag : Fin 5 |
| output : Nat |
| first : Nat |
| second : Nat |
| deriving DecidableEq |
|
|
| def Record.slot (r : Record) (j : Fin 3) : Nat := |
| match j.val with |
| | 0 => r.output |
| | 1 => r.first |
| | _ => r.second |
|
|
| def Record.words (r : Record) : List Nat := |
| [r.tag.val, r.output, r.first, r.second] |
|
|
| def Record.bits (r : Record) : List Bool := encodeWords r.words |
|
|
| def Record.fieldValue (r : Record) (j : Fin 4) : Nat := |
| match j.val with |
| | 0 => r.tag.val |
| | 1 => r.output |
| | 2 => r.first |
| | _ => r.second |
|
|
| def templateWords (tag : Fin 5) (values : Fin 3 → Nat) : List Nat := |
| (List.finRange 9).flatMap fun j => |
| [values (gateTemplate tag j).1, if (gateTemplate tag j).2 then 1 else 0] |
|
|
| def Record.outputWords (r : Record) : List Nat := templateWords r.tag r.slot |
| def Record.outputBits (r : Record) : List Bool := encodeWords r.outputWords |
|
|
| def outputWords (selected : Nat) : List Nat := |
| [selected, 1, selected, 1, selected, 1] |
|
|
| inductive Tape where |
| | input | header | counter | selected | field (slot : Fin 4) |
| | scratch | reversed | output |
| deriving DecidableEq, Fintype |
|
|
| inductive Context where |
| | header (slot : Fin 2) |
| | gate (tag : Fin 5) (position : Fin 9) |
| | output (position : Fin 3) |
| deriving DecidableEq, Fintype |
|
|
| abbrev State := (Unit × Context) × Option Bool |
| abbrev Alphabet (_ : Tape) := Bool |
|
|
| inductive Label where |
| | headerStart (slot : Fin 3) |
| | headerLoop (slot : Fin 3) |
| | setup (context : Context) |
| | scan (context : Context) |
| | emit (context control : Context) (symbol : Bool) |
| | restore (context : Context) |
| | clearHeader | guard |
| | fieldStart (slot : Fin 4) |
| | fieldLoop (slot : Fin 4) |
| | decodeTag |
| | cleanup (slot : Fin 4) |
| | finalCounter | clearSelected | finalReverse |
| deriving DecidableEq, Fintype |
|
|
| def defaultControl : Context := .header 0 |
| def initialState : State := (((), defaultControl), none) |
|
|
| def headerTape (slot : Fin 3) : Tape := |
| match slot.val with |
| | 0 => .header |
| | 1 => .counter |
| | _ => .selected |
|
|
| def headerNext (slot : Fin 3) : Option Label := |
| if h : slot.val + 1 < 3 then some (.headerStart ⟨slot.val + 1, h⟩) |
| else some (.setup (.header 0)) |
|
|
| def contextSource : Context → Tape |
| | .header j => if j.val = 0 then .header else .counter |
| | .gate tag j => .field ⟨(gateTemplate tag j).1.val + 1, by |
| have := (gateTemplate tag j).1.isLt |
| omega⟩ |
| | .output _ => .selected |
|
|
| def affineEmit (scale offset : Nat) : Bool → List Bool |
| | true => List.replicate scale true |
| | false => encodeWord offset |
|
|
| def literalEmit (positive : Bool) : Bool → List Bool |
| | true => [true] |
| | false => [false] ++ encodeWord (if positive then 1 else 0) |
|
|
| def emission : Context → Bool → List Bool |
| | .header j => if j.val = 0 then affineEmit 1 0 else affineEmit 3 1 |
| | .gate tag j => literalEmit (gateTemplate tag j).2 |
| | .output _ => literalEmit true |
|
|
| def contextNext : Context → Option Label |
| | .header j => if j.val = 0 then some (.setup (.header 1)) else some .clearHeader |
| | .gate tag j => if h : j.val + 1 < 9 then |
| some (.setup (.gate tag ⟨j.val + 1, h⟩)) else some (.cleanup 0) |
| | .output j => if h : j.val + 1 < 3 then |
| some (.setup (.output ⟨j.val + 1, h⟩)) else some .finalCounter |
|
|
| def cleanupNext (j : Fin 4) : Label := |
| if h : j.val + 1 < 4 then .cleanup ⟨j.val + 1, h⟩ else .guard |
|
|
| def drain (tape : Tape) (again next : Label) : TM2.Stmt Alphabet Label State := |
| .pop tape (fun state head => (state.1, head)) |
| (.branch (fun state => state.2.isSome) |
| (.goto fun _ => again) |
| (.load (fun state => (state.1, none)) (.goto fun _ => next))) |
|
|
| def resetGoto (next : Label) : TM2.Stmt Alphabet Label State := |
| .load (fun _ => initialState) (.goto fun _ => next) |
|
|
| def tagDecoder : Nat → Fin 5 → TM2.Stmt Alphabet Label State |
| | 0, tag => .pop (.field 0) (fun state head => (state.1, head)) |
| (.branch (fun state => state.2.getD false) .halt |
| (resetGoto (.setup (.gate tag 0)))) |
| | fuel + 1, tag => .pop (.field 0) (fun state head => (state.1, head)) |
| (.branch (fun state => state.2.getD false) |
| (tagDecoder fuel ⟨min (tag.val + 1) 4, by omega⟩) |
| (resetGoto (.setup (.gate tag 0)))) |
|
|
| def program : Label → TM2.Stmt Alphabet Label State |
| | .headerStart j => SourceMachine.fieldStart (headerTape j) (.headerLoop j) |
| | .headerLoop j => SourceMachine.fieldLoop .input (headerTape j) (.headerLoop j) |
| (headerNext j) |
| | .setup c => .load (fun _ => (((), c), none)) (.goto fun _ => .scan c) |
| | .scan c => MachineTransducerCopy.scanLoop (contextSource c) .scratch |
| defaultControl (fun q b => .emit c q b) (.restore c) |
| | .emit c q b => MachineTransducerCopy.emitter .reversed (fun q _ => q) |
| emission (.scan c) q b |
| | .restore c => MachineTransfer.loopAt .scratch (contextSource c) id false |
| (.restore c) (contextNext c) |
| | .clearHeader => drain .header .clearHeader .guard |
| | .guard => MachineUnaryCounter.guard .counter (.fieldStart 0) (.setup (.output 0)) |
| | .fieldStart j => SourceMachine.fieldStart (.field j) (.fieldLoop j) |
| | .fieldLoop j => SourceMachine.fieldLoop .input (.field j) (.fieldLoop j) |
| (SourceMachine.fieldNext Label.fieldStart (some .decodeTag) j) |
| | .decodeTag => tagDecoder 4 0 |
| | .cleanup j => drain (.field j) (.cleanup j) (cleanupNext j) |
| | .finalCounter => .pop .counter (fun state _ => (state.1, none)) |
| (.goto fun _ => .clearSelected) |
| | .clearSelected => drain .selected .clearSelected .finalReverse |
| | .finalReverse => MachineTransfer.loopAt .reversed .output id false .finalReverse none |
|
|
| def machine : FinTM2 where |
| K := Tape |
| k₀ := .input |
| k₁ := .output |
| Γ := Alphabet |
| Λ := Label |
| main := .headerStart 0 |
| σ := State |
| initialState := initialState |
| m := program |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.CircuitProducerModel |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin |
|
|
| open CircuitProducerModel |
|
|
| def gateRecord (output : Nat) : Gate → Record |
| | .const false => ⟨0, output, 0, 0⟩ |
| | .const true => ⟨1, output, 0, 0⟩ |
| | .not a => ⟨2, output, a, 0⟩ |
| | .and a b => ⟨3, output, a, b⟩ |
| | .or a b => ⟨4, output, a, b⟩ |
|
|
| def gateRecords (start : Nat) : List Gate → List Record |
| | [] => [] |
| | g :: gs => gateRecord start g :: gateRecords (start + 1) gs |
|
|
| def Circuit.records (C : Circuit) : List Record := gateRecords C.inputs C.gates |
|
|
| def recordsWords (rs : List Record) : List Nat := rs.flatMap Record.words |
| def recordsBits (rs : List Record) : List Bool := encodeWords (recordsWords rs) |
|
|
| def circuitWords (C : Circuit) : List Nat := |
| [C.wires, C.gates.length, C.output.val] ++ recordsWords C.records |
|
|
| def circuitBits (C : Circuit) : List Bool := encodeWords (circuitWords C) |
|
|
| @[simp] theorem gateRecords_length (start : Nat) (gs : List Gate) : |
| (gateRecords start gs).length = gs.length := by |
| induction gs generalizing start with |
| | nil => rfl |
| | cons g gs ih => simp [gateRecords, ih] |
|
|
| @[simp] theorem Circuit.records_length (C : Circuit) : C.records.length = C.gates.length := |
| gateRecords_length C.inputs C.gates |
|
|
| @[simp] theorem recordsWords_cons (r : Record) (rs : List Record) : |
| recordsWords (r :: rs) = r.words ++ recordsWords rs := rfl |
|
|
| @[simp] theorem recordsBits_cons (r : Record) (rs : List Record) : |
| recordsBits (r :: rs) = r.bits ++ recordsBits rs := by |
| simp [recordsBits, Record.bits] |
|
|
| @[simp] theorem recordsWords_length (rs : List Record) : |
| (recordsWords rs).length = 4 * rs.length := by |
| induction rs with |
| | nil => rfl |
| | cons r rs ih => |
| rw [recordsWords_cons, List.length_append, ih] |
| simp only [Record.words, List.length_cons, List.length_nil] |
| omega |
|
|
| @[simp] theorem circuitWords_length (C : Circuit) : |
| (circuitWords C).length = 3 + 4 * C.gates.length := by |
| simp [circuitWords] |
| omega |
|
|
| def gateFromFields (tag first second : Nat) : Gate := |
| match tag with |
| | 0 => .const false |
| | 1 => .const true |
| | 2 => .not first |
| | 3 => .and first second |
| | _ => .or first second |
|
|
| def decodeGateWords : List Nat → List Gate |
| | tag :: _ :: first :: second :: rest => |
| gateFromFields tag first second :: decodeGateWords rest |
| | _ => [] |
|
|
| theorem decodeGateWords_gateRecord (output : Nat) (g : Gate) (rest : List Nat) : |
| decodeGateWords ((gateRecord output g).words ++ rest) = |
| g :: decodeGateWords rest := by |
| cases g with |
| | const b => cases b <;> rfl |
| | not a => rfl |
| | and a b => rfl |
| | or a b => rfl |
|
|
| @[simp] theorem decodeGateWords_gateRecords (start : Nat) (gs : List Gate) : |
| decodeGateWords (recordsWords (gateRecords start gs)) = gs := by |
| induction gs generalizing start with |
| | nil => rfl |
| | cons g gs ih => |
| rw [gateRecords, recordsWords_cons, decodeGateWords_gateRecord, ih] |
|
|
| theorem circuitWords_injective : Function.Injective circuitWords := by |
| intro C D h |
| have hh : C.wires = D.wires ∧ C.gates.length = D.gates.length ∧ |
| C.output.val = D.output.val ∧ recordsWords C.records = recordsWords D.records := by |
| simpa only [circuitWords, List.cons_append, List.nil_append, List.cons.injEq] using h |
| have hg : C.gates = D.gates := by |
| have hd := congrArg decodeGateWords hh.2.2.2 |
| simpa only [Circuit.records, decodeGateWords_gateRecords] using hd |
| have hi : C.inputs = D.inputs := by |
| have hw := hh.1 |
| simp only [Circuit.wires] at hw |
| rw [hg] at hw |
| omega |
| cases C with |
| | mk ci cg co cx => |
| cases D with |
| | mk di dg dord dx => |
| dsimp at hi hg hh |
| subst di |
| subst dg |
| have hx : cx = dx := Fin.ext hh.2.2.1 |
| subst dx |
| rfl |
|
|
| theorem circuitBits_injective : Function.Injective circuitBits := by |
| intro C D h |
| exact circuitWords_injective (encodeWords_injective h) |
|
|
| theorem gateRecord_fields_le (start bound : Nat) (g : Gate) |
| (hs : start ≤ bound) (hg : g.Bounded bound) : |
| ∀ n ∈ (gateRecord start g).words, n ≤ bound + 4 := by |
| cases g with |
| | const b => cases b <;> simp [gateRecord, Record.words] <;> omega |
| | not a => simp [gateRecord, Record.words, Gate.Bounded] at *; omega |
| | and a b => simp [gateRecord, Record.words, Gate.Bounded] at *; omega |
| | or a b => simp [gateRecord, Record.words, Gate.Bounded] at *; omega |
|
|
| theorem gateRecords_fields_le (start : Nat) (gs : List Gate) (ho : Ordered start gs) : |
| ∀ n ∈ recordsWords (gateRecords start gs), n ≤ start + gs.length + 4 := by |
| induction gs generalizing start with |
| | nil => simp [gateRecords, recordsWords] |
| | cons g gs ih => |
| rcases (ordered_cons start g gs).mp ho with ⟨hg, hgs⟩ |
| intro n hn |
| rw [gateRecords, recordsWords_cons, List.mem_append] at hn |
| rcases hn with hn | hn |
| · have h := gateRecord_fields_le start start g (Nat.le_refl _) hg n hn |
| simp only [List.length_cons] |
| omega |
| · have h := ih (start + 1) hgs n hn |
| simp only [List.length_cons] |
| omega |
|
|
| theorem circuitWords_bounded (C : Circuit) : |
| ∀ n ∈ circuitWords C, n ≤ C.wires + 4 := by |
| intro n hn |
| simp only [circuitWords, List.mem_append, List.mem_cons, List.not_mem_nil, or_false] at hn |
| rcases hn with (rfl | rfl | rfl) | hn |
| · omega |
| · simp only [Circuit.wires]; omega |
| · have := C.output.isLt |
| change C.output.val ≤ C.inputs + C.gates.length + 4 |
| omega |
| · exact gateRecords_fields_le C.inputs C.gates C.ordered n hn |
|
|
| theorem circuitBits_length_le (C : Circuit) : |
| (circuitBits C).length ≤ (3 + 4 * C.gates.length) * (C.wires + 5) := by |
| have h := encodeWords_length_le (circuitWords C) (C.wires + 4) |
| (circuitWords_bounded C) |
| simpa only [circuitBits, circuitWords_length, Nat.add_assoc] using h |
|
|
| theorem circuit_header_le_length (C : Circuit) : |
| C.wires + C.gates.length + C.output.val + 3 ≤ (circuitBits C).length := by |
| simp only [circuitBits, circuitWords, encodeWords_append, List.length_append, |
| encodeWords, encodeWord_length, List.length_nil] |
| omega |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.CircuitEmission |
|
|
| open Turing |
| open BinPackingGames.Reduction |
| open CircuitProducerModel |
|
|
| theorem contextSource_ne_scratch (context : Context) : |
| contextSource context ≠ Tape.scratch := by |
| cases context with |
| | header slot => simp only [contextSource]; split <;> simp |
| | gate tag position => simp [contextSource] |
| | output position => simp [contextSource] |
|
|
| theorem contextSource_ne_reversed (context : Context) : |
| contextSource context ≠ Tape.reversed := by |
| cases context with |
| | header slot => simp only [contextSource]; split <;> simp |
| | gate tag position => simp [contextSource] |
| | output position => simp [contextSource] |
|
|
| def contextOutput (context : Context) (base : Tape → List Bool) : List Bool := |
| MachineTransducer.output (fun control _ => control) emission |
| context (base (contextSource context)) |
|
|
| def contextSteps (context : Context) (base : Tape → List Bool) : Nat := |
| 3 * (base (contextSource context)).length + 3 |
|
|
| def contextTapes (context : Context) (base : Tape → List Bool) : Tape → List Bool := |
| Function.update base .reversed ((contextOutput context base).reverse ++ base .reversed) |
|
|
| @[simp] theorem contextTapes_other (context : Context) (base : Tape → List Bool) |
| (tape : Tape) (different : tape ≠ .reversed) : |
| contextTapes context base tape = base tape := by |
| simp [contextTapes, different] |
|
|
| @[simp] theorem contextTapes_source (context other : Context) (base : Tape → List Bool) : |
| contextTapes context base (contextSource other) = base (contextSource other) := |
| contextTapes_other context base _ (contextSource_ne_reversed other) |
|
|
| @[simp] theorem contextTapes_scratch (context : Context) (base : Tape → List Bool) : |
| contextTapes context base .scratch = base .scratch := |
| contextTapes_other context base _ (by decide) |
|
|
| @[simp] theorem contextOutput_update (context : Context) (base : Tape → List Bool) |
| (out : List Bool) : |
| contextOutput context (Function.update base .reversed out) = contextOutput context base := by |
| simp [contextOutput, contextSource_ne_reversed] |
|
|
| @[simp] theorem contextSteps_update (context : Context) (base : Tape → List Bool) |
| (out : List Bool) : |
| contextSteps context (Function.update base .reversed out) = contextSteps context base := by |
| simp [contextSteps, contextSource_ne_reversed] |
|
|
| theorem setupStep (context : Context) (base : Tape → List Bool) (state : State) : |
| TM2.step program ⟨some (.setup context), state, base⟩ = |
| some ⟨some (.scan context), (((), context), none), base⟩ := rfl |
|
|
| theorem contextTrace (context : Context) (base : Tape → List Bool) |
| (scratchEmpty : base .scratch = []) (state : State) : |
| (MachineComposition.advance (TM2.step program))^[contextSteps context base] |
| (some ⟨some (.setup context), state, base⟩) = |
| some ⟨contextNext context, initialState, contextTapes context base⟩ := by |
| have copied := MachineTransducerCopy.transduceCopyTrace |
| (contextSource context) Tape.scratch Tape.reversed |
| (contextSource_ne_scratch context) (contextSource_ne_reversed context) (by decide) |
| defaultControl (fun control _ => control) emission |
| (.scan context) (.restore context) (fun control symbol => .emit context control symbol) |
| (contextNext context) program rfl (by intros; rfl) rfl base scratchEmpty () context none |
| rw [contextSteps, show 3 * (base (contextSource context)).length + 3 = |
| (3 * (base (contextSource context)).length + 2) + 1 by omega, |
| Function.iterate_succ_apply] |
| change (MachineComposition.advance (TM2.step program))^[ |
| 3 * (base (contextSource context)).length + 2] |
| (TM2.step program ⟨some (.setup context), state, base⟩) = _ |
| rw [setupStep] |
| exact copied |
|
|
| def contextInTime (context : Context) (base : Tape → List Bool) |
| (scratchEmpty : base .scratch = []) (state : State) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some (.setup context), state, base⟩ |
| (some ⟨contextNext context, initialState, contextTapes context base⟩) |
| (contextSteps context base) where |
| steps := contextSteps context base |
| evals_in_steps := contextTrace context base scratchEmpty state |
| steps_le_m := Nat.le_refl _ |
|
|
| theorem output_eq_flatMap (context : Context) (input : List Bool) : |
| MachineTransducer.output (fun control _ => control) emission context input = |
| input.flatMap (emission context) := by |
| induction input with |
| | nil => rfl |
| | cons symbol input ih => |
| simp only [MachineTransducer.output, List.flatMap_cons, ih] |
|
|
| theorem literalEmit_word (positive : Bool) (value : Nat) : |
| (encodeWord value).flatMap (literalEmit positive) = |
| encodeWords [value, if positive then 1 else 0] := by |
| induction value with |
| | zero => simp [encodeWord, encodeWords, literalEmit] |
| | succ value ih => |
| simpa [encodeWord, encodeWords, List.replicate_succ, literalEmit] using |
| congrArg (List.cons true) ih |
|
|
| theorem affineEmit_word (scale offset value : Nat) : |
| (encodeWord value).flatMap (affineEmit scale offset) = |
| encodeWord (offset + scale * value) := by |
| have hrep : (List.replicate value true).flatMap (affineEmit scale offset) = |
| List.replicate (scale * value) true := by |
| rw [List.flatMap_replicate] |
| change (List.replicate value (List.replicate scale true)).flatten = _ |
| rw [List.flatten_replicate_replicate, Nat.mul_comm value scale] |
| simp only [encodeWord, List.flatMap_append, List.flatMap_cons, List.flatMap_nil, |
| List.append_nil, hrep, affineEmit] |
| rw [← List.append_assoc, List.replicate_append_replicate, Nat.add_comm (scale * value) offset] |
|
|
| def contextWords (context : Context) (value : Nat) : List Nat := |
| match context with |
| | .header j => if j.val = 0 then [value] else [3 * value + 1] |
| | .gate tag j => [value, if (gateTemplate tag j).2 then 1 else 0] |
| | .output _ => [value, 1] |
|
|
| theorem output_word (context : Context) (value : Nat) : |
| MachineTransducer.output (fun control _ => control) emission context (encodeWord value) = |
| encodeWords (contextWords context value) := by |
| rw [output_eq_flatMap] |
| cases context with |
| | header j => |
| by_cases hj : j.val = 0 <;> |
| simp [emission, contextWords, hj, affineEmit_word, encodeWords, Nat.add_comm] |
| | gate tag j => exact literalEmit_word (gateTemplate tag j).2 value |
| | output j => simpa [emission, contextWords] using literalEmit_word true value |
|
|
| theorem contextTrace_word (context : Context) (base : Tape → List Bool) |
| (scratchEmpty : base .scratch = []) (state : State) (value : Nat) |
| (cached : base (contextSource context) = encodeWord value) : |
| (MachineComposition.advance (TM2.step program))^[3 * (value + 1) + 3] |
| (some ⟨some (.setup context), state, base⟩) = |
| some ⟨contextNext context, initialState, |
| Function.update base .reversed |
| ((encodeWords (contextWords context value)).reverse ++ base .reversed)⟩ := by |
| simpa only [contextSteps, contextTapes, contextOutput, cached, encodeWord_length, output_word] |
| using contextTrace context base scratchEmpty state |
|
|
| def contextListOutput (contexts : List Context) (base : Tape → List Bool) : List Bool := |
| contexts.flatMap (fun context => contextOutput context base) |
|
|
| def contextListSteps (contexts : List Context) (base : Tape → List Bool) : Nat := |
| (contexts.map (fun context => contextSteps context base)).sum |
|
|
| def contextListStart (contexts : List Context) (exit : Option Label) : Option Label := |
| match contexts with |
| | [] => exit |
| | context :: _ => some (.setup context) |
|
|
| def ContextListLinked : List Context → Option Label → Prop |
| | [], _ => True |
| | context :: rest, exit => |
| contextNext context = contextListStart rest exit ∧ ContextListLinked rest exit |
|
|
| @[simp] theorem contextListOutput_update (contexts : List Context) (base : Tape → List Bool) |
| (out : List Bool) : |
| contextListOutput contexts (Function.update base .reversed out) = contextListOutput contexts base := by |
| simp [contextListOutput] |
|
|
| @[simp] theorem contextListSteps_update (contexts : List Context) (base : Tape → List Bool) |
| (out : List Bool) : |
| contextListSteps contexts (Function.update base .reversed out) = contextListSteps contexts base := by |
| simp [contextListSteps] |
|
|
| private theorem chain {α : Type*} {f : α → α} {x y z : α} {m n : Nat} |
| (first : f^[m] x = y) (second : f^[n] y = z) : f^[n + m] x = z := by |
| rw [Function.iterate_add_apply, first, second] |
|
|
| theorem contextListTrace (contexts : List Context) (exit : Option Label) |
| (linked : ContextListLinked contexts exit) (base : Tape → List Bool) |
| (scratchEmpty : base .scratch = []) (state : State) |
| (emptyInitial : contexts = [] → state = initialState) : |
| (MachineComposition.advance (TM2.step program))^[contextListSteps contexts base] |
| (some ⟨contextListStart contexts exit, state, base⟩) = |
| some ⟨exit, initialState, Function.update base .reversed |
| ((contextListOutput contexts base).reverse ++ base .reversed)⟩ := by |
| induction contexts generalizing base state with |
| | nil => |
| rw [emptyInitial rfl] |
| simp [contextListSteps, contextListOutput, contextListStart] |
| | cons context rest ih => |
| let after := contextTapes context base |
| have first := contextTrace context base scratchEmpty state |
| have second := ih linked.2 after (by simpa [after] using scratchEmpty) |
| initialState (by intro _; rfl) |
| rw [linked.1] at first |
| have combined := chain first second |
| simp only [after, contextTapes, contextListSteps_update, contextListOutput_update, |
| Function.update_self, Function.update_idem] at combined |
| rw [show contextListSteps (context :: rest) base = |
| contextListSteps rest base + contextSteps context base by |
| simp [contextListSteps, Nat.add_comm]] |
| simpa only [contextListStart, contextListOutput, List.flatMap_cons, |
| List.reverse_append, List.append_assoc] using combined |
|
|
| def gateContexts (tag : Fin 5) : List Context := |
| (List.finRange 9).map (Context.gate tag) |
|
|
| def outputContexts : List Context := [.output 0, .output 1, .output 2] |
|
|
| theorem gateContexts_linked (tag : Fin 5) : |
| ContextListLinked (gateContexts tag) (some (.cleanup 0)) := by |
| simp [gateContexts, List.finRange, List.ofFn_succ, ContextListLinked, |
| contextListStart, contextNext] |
|
|
| theorem outputContexts_linked : |
| ContextListLinked outputContexts (some .finalCounter) := by |
| simp [outputContexts, ContextListLinked, contextListStart, contextNext] |
|
|
| theorem contextOutput_gate_word (record : Record) (position : Fin 9) |
| (base : Tape → List Bool) |
| (h1 : base (.field 1) = encodeWord record.output) |
| (h2 : base (.field 2) = encodeWord record.first) |
| (h3 : base (.field 3) = encodeWord record.second) : |
| contextOutput (.gate record.tag position) base = encodeWords |
| [record.slot (gateTemplate record.tag position).1, |
| if (gateTemplate record.tag position).2 then 1 else 0] := by |
| have fields (slot : Fin 3) : |
| base (.field ⟨slot.val + 1, by omega⟩) = encodeWord (record.slot slot) := by |
| have slotCases : slot.val = 0 ∨ slot.val = 1 ∨ slot.val = 2 := by omega |
| rcases slotCases with h | h | h |
| · simpa [Record.slot, h] using h1 |
| · simpa [Record.slot, h] using h2 |
| · simpa [Record.slot, h] using h3 |
| unfold contextOutput |
| rw [show base (contextSource (.gate record.tag position)) = |
| encodeWord (record.slot (gateTemplate record.tag position).1) from fields _] |
| exact output_word (.gate record.tag position) _ |
|
|
| theorem encodeWords_flatMap {A : Type*} (items : List A) (words : A → List Nat) : |
| encodeWords (items.flatMap words) = items.flatMap (fun item => encodeWords (words item)) := by |
| induction items with |
| | nil => rfl |
| | cons item rest ih => simp only [List.flatMap_cons, encodeWords_append, ih] |
|
|
| theorem gateOutput_words (record : Record) (base : Tape → List Bool) |
| (h1 : base (.field 1) = encodeWord record.output) |
| (h2 : base (.field 2) = encodeWord record.first) |
| (h3 : base (.field 3) = encodeWord record.second) : |
| contextListOutput (gateContexts record.tag) base = record.outputBits := by |
| simp only [contextListOutput, gateContexts, List.flatMap_map, |
| Record.outputBits, Record.outputWords, templateWords, encodeWords_flatMap] |
| congr 1 |
| funext position |
| exact contextOutput_gate_word record position base h1 h2 h3 |
|
|
| def gateSteps (record : Record) : Nat := |
| ((List.finRange 9).map fun position => |
| 3 * (record.slot (gateTemplate record.tag position).1 + 1) + 3).sum |
|
|
| theorem gateSteps_eq (record : Record) (base : Tape → List Bool) |
| (h1 : base (.field 1) = encodeWord record.output) |
| (h2 : base (.field 2) = encodeWord record.first) |
| (h3 : base (.field 3) = encodeWord record.second) : |
| contextListSteps (gateContexts record.tag) base = gateSteps record := by |
| have fields (slot : Fin 3) : |
| base (.field ⟨slot.val + 1, by omega⟩) = encodeWord (record.slot slot) := by |
| have slotCases : slot.val = 0 ∨ slot.val = 1 ∨ slot.val = 2 := by omega |
| rcases slotCases with h | h | h |
| · simpa [Record.slot, h] using h1 |
| · simpa [Record.slot, h] using h2 |
| · simpa [Record.slot, h] using h3 |
| simp only [contextListSteps, gateContexts, List.map_map, gateSteps] |
| congr 2 |
| funext position |
| simp only [Function.comp_apply, contextSteps, contextSource, fields, encodeWord_length] |
|
|
| theorem slot_le_sum (record : Record) (slot : Fin 3) : |
| record.slot slot ≤ record.output + record.first + record.second := by |
| unfold Record.slot |
| split <;> omega |
|
|
| private theorem sum_map_le_length_mul {A : Type*} (items : List A) |
| (value : A → Nat) (bound : Nat) (bounded : ∀ item ∈ items, value item ≤ bound) : |
| (items.map value).sum ≤ items.length * bound := by |
| induction items with |
| | nil => simp |
| | cons item rest ih => |
| have head := bounded item (by simp) |
| have tail := ih (fun a ha => bounded a (by simp [ha])) |
| simp only [List.map_cons, List.sum_cons, List.length_cons, Nat.add_mul, Nat.one_mul] |
| omega |
|
|
| theorem gateSteps_le (record : Record) : |
| gateSteps record ≤ 27 * (record.output + record.first + record.second) + 54 := by |
| have bound := sum_map_le_length_mul (List.finRange 9) |
| (fun position => 3 * (record.slot (gateTemplate record.tag position).1 + 1) + 3) |
| (3 * (record.output + record.first + record.second) + 6) (by |
| intro position _ |
| have := slot_le_sum record (gateTemplate record.tag position).1 |
| omega) |
| simp only [List.length_finRange] at bound |
| unfold gateSteps |
| omega |
|
|
| private theorem length_flatMap_le_length_mul {A : Type*} (items : List A) |
| (word : A → List Bool) (bound : Nat) (bounded : ∀ item ∈ items, (word item).length ≤ bound) : |
| (items.flatMap word).length ≤ items.length * bound := by |
| induction items with |
| | nil => simp |
| | cons item rest ih => |
| have head := bounded item (by simp) |
| have tail := ih (fun a ha => bounded a (by simp [ha])) |
| simp only [List.flatMap_cons, List.length_append, List.length_cons, |
| Nat.add_mul, Nat.one_mul] |
| omega |
|
|
| theorem outputBits_length_le (record : Record) : |
| record.outputBits.length ≤ 9 * (record.output + record.first + record.second) + 27 := by |
| have bound := length_flatMap_le_length_mul (List.finRange 9) |
| (fun position => encodeWords |
| [record.slot (gateTemplate record.tag position).1, |
| if (gateTemplate record.tag position).2 then 1 else 0]) |
| (record.output + record.first + record.second + 3) (by |
| intro position _ |
| have index := slot_le_sum record (gateTemplate record.tag position).1 |
| have sign : (if (gateTemplate record.tag position).2 then 1 else 0 : Nat) ≤ 1 := by |
| split <;> omega |
| simp only [encodeWords, List.length_append, encodeWord_length, List.length_nil] |
| omega) |
| simp only [List.length_finRange] at bound |
| unfold Record.outputBits Record.outputWords templateWords |
| rw [encodeWords_flatMap] |
| omega |
|
|
| theorem recordBits_length (record : Record) : |
| record.bits.length = record.tag.val + record.output + record.first + record.second + 4 := by |
| simp [Record.bits, Record.words, encodeWords_length] |
| omega |
|
|
| theorem gateSteps_le_inputSize (record : Record) : |
| gateSteps record ≤ 27 * record.bits.length := by |
| have bound := gateSteps_le record |
| rw [recordBits_length] |
| omega |
|
|
| theorem outputBits_length_le_inputSize (record : Record) : |
| record.outputBits.length ≤ 9 * record.bits.length := by |
| have bound := outputBits_length_le record |
| rw [recordBits_length] |
| omega |
|
|
| theorem gateTrace (record : Record) (base : Tape → List Bool) |
| (scratchEmpty : base .scratch = []) (state : State) |
| (h1 : base (.field 1) = encodeWord record.output) |
| (h2 : base (.field 2) = encodeWord record.first) |
| (h3 : base (.field 3) = encodeWord record.second) : |
| (MachineComposition.advance (TM2.step program))^[gateSteps record] |
| (some ⟨some (.setup (.gate record.tag 0)), state, base⟩) = |
| some ⟨some (.cleanup 0), initialState, Function.update base .reversed |
| (record.outputBits.reverse ++ base .reversed)⟩ := by |
| have trace := contextListTrace (gateContexts record.tag) (some (.cleanup 0)) |
| (gateContexts_linked record.tag) base scratchEmpty state |
| (by intro h; have := congrArg List.length h; simp [gateContexts] at this) |
| rw [gateSteps_eq record base h1 h2 h3, gateOutput_words record base h1 h2 h3] at trace |
| simpa [contextListStart, gateContexts, List.finRange] using trace |
|
|
| def gateInTime (record : Record) (base : Tape → List Bool) |
| (scratchEmpty : base .scratch = []) (state : State) |
| (h1 : base (.field 1) = encodeWord record.output) |
| (h2 : base (.field 2) = encodeWord record.first) |
| (h3 : base (.field 3) = encodeWord record.second) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some (.setup (.gate record.tag 0)), state, base⟩ |
| (some ⟨some (.cleanup 0), initialState, Function.update base .reversed |
| (record.outputBits.reverse ++ base .reversed)⟩) |
| (gateSteps record) where |
| steps := gateSteps record |
| evals_in_steps := gateTrace record base scratchEmpty state h1 h2 h3 |
| steps_le_m := Nat.le_refl _ |
|
|
| theorem outputTrace (selected : Nat) (base : Tape → List Bool) |
| (scratchEmpty : base .scratch = []) (state : State) |
| (cached : base .selected = encodeWord selected) : |
| (MachineComposition.advance (TM2.step program))^[9 * (selected + 1) + 9] |
| (some ⟨some (.setup (.output 0)), state, base⟩) = |
| some ⟨some .finalCounter, initialState, Function.update base .reversed |
| ((encodeWords (outputWords selected)).reverse ++ base .reversed)⟩ := by |
| have trace := contextListTrace outputContexts (some .finalCounter) |
| outputContexts_linked base scratchEmpty state (by simp [outputContexts]) |
| have steps : contextListSteps outputContexts base = 9 * (selected + 1) + 9 := by |
| simp [contextListSteps, outputContexts, contextSteps, contextSource, cached] |
| omega |
| have out : contextListOutput outputContexts base = encodeWords (outputWords selected) := by |
| simp [contextListOutput, outputContexts, contextOutput, contextSource, cached, |
| output_word, contextWords, outputWords, encodeWords, List.append_assoc] |
| rw [steps, out] at trace |
| exact trace |
|
|
| def outputInTime (selected : Nat) (base : Tape → List Bool) |
| (scratchEmpty : base .scratch = []) (state : State) |
| (cached : base .selected = encodeWord selected) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some (.setup (.output 0)), state, base⟩ |
| (some ⟨some .finalCounter, initialState, Function.update base .reversed |
| ((encodeWords (outputWords selected)).reverse ++ base .reversed)⟩) |
| (9 * (selected + 1) + 9) where |
| steps := 9 * (selected + 1) + 9 |
| evals_in_steps := outputTrace selected base scratchEmpty state cached |
| steps_le_m := Nat.le_refl _ |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.CircuitEmission |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.PostfixModel |
|
|
| inductive Token where |
| | const (value : Bool) |
| | not | and | or |
| | input (wire : Nat) |
| deriving DecidableEq |
|
|
| namespace Token |
|
|
| def tag : Token → Fin 6 |
| | .const false => 0 |
| | .const true => 1 |
| | .not => 2 |
| | .and => 3 |
| | .or => 4 |
| | .input _ => 5 |
|
|
| def words : Token → List Nat |
| | .const false => [0] |
| | .const true => [1] |
| | .not => [2] |
| | .and => [3] |
| | .or => [4] |
| | .input wire => [5, wire] |
|
|
| def bits (token : Token) : List Bool := encodeWords token.words |
|
|
| def takeGate : Token → List Nat → Option (Gate × List Nat) |
| | .const value, roots => some (.const value, roots) |
| | .input wire, roots => some (.or wire wire, roots) |
| | .not, arg :: roots => some (.not arg, roots) |
| | .and, right :: left :: roots => some (.and left right, roots) |
| | .or, right :: left :: roots => some (.or left right, roots) |
| | _, _ => none |
|
|
| end Token |
|
|
| def tokenWords (tokens : List Token) : List Nat := tokens.flatMap Token.words |
| def tokenBits (tokens : List Token) : List Bool := encodeWords (tokenWords tokens) |
|
|
| def compileTokens (start : Nat) (roots : List Nat) : |
| List Token → Option (Nat × List Nat × List Gate) |
| | [] => some (start, roots, []) |
| | token :: tokens => do |
| let (gate, remaining) ← token.takeGate roots |
| let (next, finalRoots, gates) ← compileTokens (start + 1) (start :: remaining) tokens |
| pure (next, finalRoots, gate :: gates) |
|
|
| def inputBits (start : Nat) (tokens : List Token) : List Bool := |
| encodeWords [start, tokens.length] ++ tokenBits tokens |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.PostfixModel |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin |
|
|
| open Target CircuitProducerModel |
|
|
| theorem gateClauses_words {n : Nat} (output : Fin n) (g : Gate) (h : g.Bounded n) : |
| (gateClauses output g h).flatMap clauseWords = (gateRecord output.val g).outputWords := by |
| cases g with |
| | const b => cases b <;> rfl |
| | not x => rfl |
| | and x y => rfl |
| | or x y => rfl |
|
|
| @[simp] theorem unitClause_words {n : Nat} (output : Fin n) : |
| clauseWords (unitClause output true) = outputWords output.val := rfl |
|
|
| theorem gateRecords_outputWords (start : Nat) (gs : List Gate) : |
| (List.finRange gs.length).flatMap |
| (fun i => (gateRecord (start + i.val) gs[i.val]).outputWords) = |
| (gateRecords start gs).flatMap Record.outputWords := by |
| induction gs generalizing start with |
| | nil => rfl |
| | cons g gs ih => |
| change (List.finRange (gs.length + 1)).flatMap |
| (fun i => (gateRecord (start + i.val) (g :: gs)[i.val]).outputWords) = _ |
| rw [List.finRange_succ, List.flatMap_cons, List.flatMap_map] |
| change (gateRecord start g).outputWords ++ |
| (List.finRange gs.length).flatMap |
| (fun i => (gateRecord (start + (i.val + 1)) gs[i.val]).outputWords) = |
| (gateRecord start g).outputWords ++ |
| (gateRecords (start + 1) gs).flatMap Record.outputWords |
| apply congrArg ((gateRecord start g).outputWords ++ ·) |
| simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using ih (start + 1) |
|
|
| theorem Circuit.gateBlocks_words (C : Circuit) : |
| ((List.finRange C.gates.length).flatMap C.gateBlock).flatMap clauseWords = |
| C.records.flatMap Record.outputWords := by |
| rw [List.flatMap_assoc] |
| calc |
| _ = (List.finRange C.gates.length).flatMap |
| (fun i => (gateRecord (C.inputs + i.val) C.gates[i.val]).outputWords) := by |
| apply List.flatMap_congr |
| intro i _ |
| exact gateClauses_words (C.gateOutput i) (C.gateAt i) (C.gateBounded i) |
| _ = C.records.flatMap Record.outputWords := gateRecords_outputWords C.inputs C.gates |
|
|
| theorem Circuit.formulaWords_eq_records (C : Circuit) : |
| formulaWords C.toFormula = |
| [C.wires, 3 * C.gates.length + 1] ++ |
| C.records.flatMap Record.outputWords ++ outputWords C.output.val := by |
| unfold formulaWords |
| change [C.wires, C.toFormula.clauses.length] ++ C.toFormula.clauses.flatMap clauseWords = _ |
| rw [C.toFormula_clause_count] |
| change [C.wires, 3 * C.gates.length + 1] ++ |
| (((List.finRange C.gates.length).flatMap C.gateBlock ++ |
| [unitClause C.output true]).flatMap clauseWords) = _ |
| rw [List.flatMap_append, C.gateBlocks_words] |
| simp only [List.flatMap_cons, List.flatMap_nil, List.append_nil, unitClause_words, |
| List.append_assoc] |
|
|
| theorem Circuit.formulaBits_eq_records (C : Circuit) : |
| formulaBits C.toFormula = |
| encodeWords ([C.wires, 3 * C.gates.length + 1] ++ |
| C.records.flatMap Record.outputWords ++ outputWords C.output.val) := |
| congrArg encodeWords C.formulaWords_eq_records |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin |
|
|
| end OAI |
|
|
