| import Mathlib.Tactic.FinCases |
| import OAI.Computability.BinPacking.CookLevin.CircuitEncodingBridge |
|
|
| namespace OAI |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.CircuitProducerStages |
|
|
| open Turing |
| open BinPackingGames.Reduction |
| open CircuitProducerModel |
|
|
| theorem drainStep_cons (tape : Tape) (again next : Label) |
| (atAgain : program again = drain tape again next) |
| (base : Tape → List Bool) (bit : Bool) (input : List Bool) |
| (control : Unit × Context) (register : Option Bool) : |
| TM2.step program |
| ⟨some again, (control, register), Function.update base tape (bit :: input)⟩ = |
| some ⟨some again, (control, some bit), Function.update base tape input⟩ := by |
| change some (TM2.stepAux (program again) (control, register) |
| (Function.update base tape (bit :: input))) = _ |
| rw [atAgain] |
| simp [drain, TM2.stepAux] |
|
|
| theorem drainStep_nil (tape : Tape) (again next : Label) |
| (atAgain : program again = drain tape again next) |
| (base : Tape → List Bool) (control : Unit × Context) (register : Option Bool) : |
| TM2.step program |
| ⟨some again, (control, register), Function.update base tape []⟩ = |
| some ⟨some next, (control, none), Function.update base tape []⟩ := by |
| change some (TM2.stepAux (program again) (control, register) |
| (Function.update base tape [])) = _ |
| rw [atAgain] |
| simp [drain, TM2.stepAux] |
|
|
| theorem drainTrace (tape : Tape) (again next : Label) |
| (atAgain : program again = drain tape again next) |
| (base : Tape → List Bool) (input : List Bool) |
| (control : Unit × Context) (register : Option Bool) : |
| (MachineComposition.advance (TM2.step program))^[input.length + 1] |
| (some ⟨some again, (control, register), Function.update base tape input⟩) = |
| some ⟨some next, (control, none), Function.update base tape []⟩ := by |
| induction input generalizing register with |
| | nil => |
| simpa only [List.length_nil, Nat.zero_add, Function.iterate_one, |
| MachineComposition.advance_some] using |
| drainStep_nil tape again next atAgain base control register |
| | cons bit input ih => |
| rw [List.length_cons, Function.iterate_succ_apply] |
| change (MachineComposition.advance (TM2.step program))^[input.length + 1] |
| (TM2.step program ⟨some again, (control, register), |
| Function.update base tape (bit :: input)⟩) = _ |
| rw [drainStep_cons tape again next atAgain, ih] |
|
|
| theorem drainTrace_base (tape : Tape) (again next : Label) |
| (atAgain : program again = drain tape again next) |
| (base : Tape → List Bool) (control : Unit × Context) (register : Option Bool) : |
| (MachineComposition.advance (TM2.step program))^[(base tape).length + 1] |
| (some ⟨some again, (control, register), base⟩) = |
| some ⟨some next, (control, none), Function.update base tape []⟩ := by |
| simpa only [Function.update_eq_self] using |
| drainTrace tape again next atAgain base (base tape) control register |
|
|
| def drainInTime (tape : Tape) (again next : Label) |
| (atAgain : program again = drain tape again next) |
| (base : Tape → List Bool) (control : Unit × Context) (register : Option Bool) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some again, (control, register), base⟩ |
| (some ⟨some next, (control, none), Function.update base tape []⟩) |
| ((base tape).length + 1) where |
| steps := (base tape).length + 1 |
| evals_in_steps := drainTrace_base tape again next atAgain base control register |
| steps_le_m := Nat.le_refl _ |
|
|
| theorem tagStep (tag : Fin 5) (base : Tape → List Bool) (state : State) |
| (htag : base (.field 0) = encodeWord tag.val) : |
| TM2.step program ⟨some .decodeTag, state, base⟩ = |
| some ⟨some (.setup (.gate tag 0)), initialState, |
| Function.update base (.field 0) []⟩ := by |
| fin_cases tag <;> |
| simp [TM2.step, TM2.stepAux, program, tagDecoder, resetGoto, initialState, |
| encodeWord, htag] |
|
|
| def tagInTime (tag : Fin 5) (base : Tape → List Bool) (state : State) |
| (htag : base (.field 0) = encodeWord tag.val) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some .decodeTag, state, base⟩ |
| (some ⟨some (.setup (.gate tag 0)), initialState, |
| Function.update base (.field 0) []⟩) 1 where |
| steps := 1 |
| evals_in_steps := tagStep tag base state htag |
| steps_le_m := Nat.le_refl _ |
|
|
| def clearFields (base : Tape → List Bool) : Tape → List Bool := |
| Function.update (Function.update (Function.update (Function.update base |
| (.field 0) []) (.field 1) []) (.field 2) []) (.field 3) [] |
|
|
| @[simp] theorem clearFields_field (base : Tape → List Bool) (j : Fin 4) : |
| clearFields base (.field j) = [] := by |
| fin_cases j <;> simp [clearFields] |
|
|
| theorem clearFields_other (base : Tape → List Bool) (tape : Tape) |
| (h : ∀ j, tape ≠ .field j) : clearFields base tape = base tape := by |
| simp [clearFields, h] |
|
|
| def cleanupSteps (base : Tape → List Bool) : Nat := |
| (base (.field 0)).length + (base (.field 1)).length + |
| (base (.field 2)).length + (base (.field 3)).length + 4 |
|
|
| theorem cleanupTrace (base : Tape → List Bool) (control : Unit × Context) |
| (register : Option Bool) : |
| (MachineComposition.advance (TM2.step program))^[cleanupSteps base] |
| (some ⟨some (.cleanup 0), (control, register), base⟩) = |
| some ⟨some .guard, (control, none), clearFields base⟩ := by |
| let b1 := Function.update base (.field 0) [] |
| let b2 := Function.update b1 (.field 1) [] |
| let b3 := Function.update b2 (.field 2) [] |
| have h0 := drainTrace_base (.field 0) (.cleanup 0) (.cleanup 1) rfl |
| base control register |
| have h1 := drainTrace_base (.field 1) (.cleanup 1) (.cleanup 2) rfl b1 control none |
| have h2 := drainTrace_base (.field 2) (.cleanup 2) (.cleanup 3) rfl b2 control none |
| have h3 := drainTrace_base (.field 3) (.cleanup 3) .guard rfl b3 control none |
| have hn : cleanupSteps base = ((b3 (.field 3)).length + 1) + |
| ((b2 (.field 2)).length + 1) + ((b1 (.field 1)).length + 1) + |
| ((base (.field 0)).length + 1) := by |
| simp [cleanupSteps, b1, b2, b3] |
| omega |
| rw [hn, Function.iterate_add_apply, h0, Function.iterate_add_apply, h1, |
| Function.iterate_add_apply, h2, h3] |
| rfl |
|
|
| def cleanupInTime (base : Tape → List Bool) (control : Unit × Context) |
| (register : Option Bool) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some (.cleanup 0), (control, register), base⟩ |
| (some ⟨some .guard, (control, none), clearFields base⟩) |
| (cleanupSteps base) where |
| steps := cleanupSteps base |
| evals_in_steps := cleanupTrace base control register |
| steps_le_m := Nat.le_refl _ |
|
|
| def finishTapes (base : Tape → List Bool) : Tape → List Bool := |
| MachineTransfer.tapesAt .reversed .output |
| (Function.update (Function.update base .counter []) .selected []) [] |
| ((base .reversed).reverse ++ base .output) |
|
|
| theorem counterStep (base : Tape → List Bool) (hcounter : base .counter = [false]) : |
| TM2.step program ⟨some .finalCounter, initialState, base⟩ = |
| some ⟨some .clearSelected, initialState, Function.update base .counter []⟩ := by |
| simp [TM2.step, TM2.stepAux, program, initialState, hcounter] |
|
|
| theorem finishTrace (base : Tape → List Bool) (hcounter : base .counter = [false]) : |
| (MachineComposition.advance (TM2.step program))^[ |
| (base .selected).length + (base .reversed).length + 3] |
| (some ⟨some .finalCounter, initialState, base⟩) = |
| some ⟨none, initialState, finishTapes base⟩ := by |
| let b1 := Function.update base .counter [] |
| let b2 := Function.update b1 .selected [] |
| have first := counterStep base hcounter |
| have second := drainTrace_base .selected .clearSelected .finalReverse rfl |
| b1 ((), defaultControl) none |
| have last := MachineTransfer.transferAt_fromTapes Tape.reversed Tape.output |
| (by decide) id false Label.finalReverse none program rfl b2 |
| ((), defaultControl) none |
| have hnext : MachineTransfer.nextAt Tape.output program = |
| MachineComposition.advance (TM2.step program) := rfl |
| rw [hnext] at last |
| have last' : (MachineComposition.advance (TM2.step program))^[(base .reversed).length + 1] |
| (some ⟨some .finalReverse, initialState, b2⟩) = |
| some ⟨none, initialState, finishTapes base⟩ := by |
| simpa [finishTapes, b1, b2, |
| initialState] using last |
| have second' : (MachineComposition.advance (TM2.step program))^[(base .selected).length + 1] |
| (some ⟨some .clearSelected, initialState, b1⟩) = |
| some ⟨some .finalReverse, initialState, b2⟩ := by |
| simpa [b1, initialState] using second |
| rw [show (base .selected).length + (base .reversed).length + 3 = |
| ((base .reversed).length + 1) + ((base .selected).length + 1) + 1 by omega, |
| Function.iterate_succ_apply, MachineComposition.advance_some, first, |
| Function.iterate_add_apply, second', last'] |
|
|
| def finishInTime (base : Tape → List Bool) (hcounter : base .counter = [false]) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some .finalCounter, initialState, base⟩ |
| (some ⟨none, initialState, finishTapes base⟩) |
| ((base .selected).length + (base .reversed).length + 3) where |
| steps := (base .selected).length + (base .reversed).length + 3 |
| evals_in_steps := finishTrace base hcounter |
| steps_le_m := Nat.le_refl _ |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.CircuitProducerStages |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.CircuitProducerHeaders |
|
|
| open Turing |
| open BinPackingGames.Foundations.Hastad |
| open CircuitProducerModel CircuitEmission CircuitProducerStages |
|
|
| def parsedTapes (base : Tape → List Bool) (n m output : Nat) (suffix : List Bool) : |
| Tape → List Bool |
| | .input => suffix |
| | .header => encodeWord n |
| | .counter => encodeWord m |
| | .selected => encodeWord output |
| | tape => base tape |
|
|
| def resultTapes (base : Tape → List Bool) (n m output : Nat) (suffix : List Bool) : |
| Tape → List Bool |
| | .input => suffix |
| | .header => [] |
| | .counter => encodeWord m |
| | .selected => encodeWord output |
| | .reversed => (encodeWords [n, 3 * m + 1]).reverse |
| | tape => base tape |
|
|
| theorem parsedTapes_eq (base : Tape → List Bool) (n m output : Nat) (suffix : List Bool) |
| (hn : base .header = []) (hm : base .counter = []) (ho : base .selected = []) : |
| SourceMachine.afterField .input .selected |
| (SourceMachine.afterField .input .counter |
| (SourceMachine.afterField .input .header base n |
| (encodeWords [m, output] ++ suffix)) m (encodeWord output ++ suffix)) |
| output suffix = parsedTapes base n m output suffix := by |
| funext tape |
| cases tape <;> |
| simp [SourceMachine.afterField, SourceMachine.fieldTapes, parsedTapes, hn, hm, ho] |
|
|
| theorem headersTrace (base : Tape → List Bool) (n m output : Nat) (suffix : List Bool) |
| (hinput : base .input = encodeWords [n, m, output] ++ suffix) |
| (hn : base .header = []) (hm : base .counter = []) (ho : base .selected = []) |
| (hs : base .scratch = []) (hr : base .reversed = []) : |
| (MachineComposition.advance (TM2.step program))^[5 * n + 4 * m + output + 20] |
| (some ⟨some (.headerStart 0), initialState, base⟩) = |
| some ⟨some .guard, initialState, resultTapes base n m output suffix⟩ := by |
| let b0 := SourceMachine.afterField .input .header base n |
| (encodeWords [m, output] ++ suffix) |
| let b1 := SourceMachine.afterField .input .counter b0 m (encodeWord output ++ suffix) |
| let b2 := parsedTapes base n m output suffix |
| let b3 := Function.update b2 .reversed (encodeWord n).reverse |
| let b4 := Function.update b2 .reversed (encodeWords [n, 3 * m + 1]).reverse |
| have h0 : base .input = encodeWord n ++ (encodeWords [m, output] ++ suffix) := by |
| simpa only [encodeWords, List.append_nil, List.append_assoc] using hinput |
| have h1 : b0 .input = encodeWord m ++ (encodeWord output ++ suffix) := by |
| simp [b0, SourceMachine.afterField, encodeWords, List.append_assoc] |
| have h2 : b1 .input = encodeWord output ++ suffix := by |
| simp [b1, SourceMachine.afterField] |
| have p0 := (SourceMachine.fieldInTime .input .header (by decide) |
| (.headerStart 0) (.headerLoop 0) (some (.headerStart 1)) program rfl rfl |
| base n (encodeWords [m, output] ++ suffix) h0 ((), defaultControl) none).evals_in_steps |
| have p1 := (SourceMachine.fieldInTime .input .counter (by decide) |
| (.headerStart 1) (.headerLoop 1) (some (.headerStart 2)) program rfl rfl |
| b0 m (encodeWord output ++ suffix) h1 ((), defaultControl) none).evals_in_steps |
| have p2 := (SourceMachine.fieldInTime .input .selected (by decide) |
| (.headerStart 2) (.headerLoop 2) (some (.setup (.header 0))) program rfl rfl |
| b1 output suffix h2 ((), defaultControl) none).evals_in_steps |
| change (MachineComposition.advance (TM2.step program))^[n + 2] |
| (some ⟨some (.headerStart 0), initialState, base⟩) = |
| some ⟨some (.headerStart 1), initialState, b0⟩ at p0 |
| change (MachineComposition.advance (TM2.step program))^[m + 2] |
| (some ⟨some (.headerStart 1), initialState, b0⟩) = |
| some ⟨some (.headerStart 2), initialState, b1⟩ at p1 |
| change (MachineComposition.advance (TM2.step program))^[output + 2] |
| (some ⟨some (.headerStart 2), initialState, b1⟩) = |
| some ⟨some (.setup (.header 0)), initialState, |
| SourceMachine.afterField .input .selected b1 output suffix⟩ at p2 |
| have hb2 : SourceMachine.afterField .input .selected b1 output suffix = b2 := |
| parsedTapes_eq base n m output suffix hn hm ho |
| rw [hb2] at p2 |
| have p3 : (MachineComposition.advance (TM2.step program))^[3 * (n + 1) + 3] |
| (some ⟨some (.setup (.header 0)), initialState, b2⟩) = |
| some ⟨some (.setup (.header 1)), initialState, b3⟩ := by |
| simpa [contextWords, contextNext, b3, b2, parsedTapes, hr, encodeWords] using |
| contextTrace_word (.header 0) b2 (by simpa [b2, parsedTapes] using hs) |
| initialState n rfl |
| have p4 : (MachineComposition.advance (TM2.step program))^[3 * (m + 1) + 3] |
| (some ⟨some (.setup (.header 1)), initialState, b3⟩) = |
| some ⟨some .clearHeader, initialState, b4⟩ := by |
| have p := contextTrace_word (.header 1) b3 |
| (by simpa [b3, b2, parsedTapes] using hs) initialState m (by |
| simp [b3, b2, parsedTapes, contextSource]) |
| simpa [contextWords, contextNext, b4, b3, encodeWords, List.reverse_append] using p |
| have p5 : (MachineComposition.advance (TM2.step program))^[n + 2] |
| (some ⟨some .clearHeader, initialState, b4⟩) = |
| some ⟨some .guard, initialState, resultTapes base n m output suffix⟩ := by |
| have p := drainTrace_base .header .clearHeader .guard rfl b4 |
| ((), defaultControl) none |
| have he : Function.update b4 .header [] = resultTapes base n m output suffix := by |
| funext tape |
| cases tape <;> simp [b4, b2, parsedTapes, resultTapes] |
| rw [he] at p |
| simpa [b4, b2, parsedTapes, initialState] using p |
| rw [show 5 * n + 4 * m + output + 20 = (n + 2) + |
| (3 * (m + 1) + 3) + (3 * (n + 1) + 3) + (output + 2) + |
| (m + 2) + (n + 2) by omega, |
| Function.iterate_add_apply, p0, Function.iterate_add_apply, p1, |
| Function.iterate_add_apply, p2, Function.iterate_add_apply, p3, |
| Function.iterate_add_apply, p4, p5] |
|
|
| def headersInTime (base : Tape → List Bool) (n m output : Nat) (suffix : List Bool) |
| (hinput : base .input = encodeWords [n, m, output] ++ suffix) |
| (hn : base .header = []) (hm : base .counter = []) (ho : base .selected = []) |
| (hs : base .scratch = []) (hr : base .reversed = []) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some (.headerStart 0), initialState, base⟩ |
| (some ⟨some .guard, initialState, resultTapes base n m output suffix⟩) |
| (5 * n + 4 * m + output + 20) where |
| steps := 5 * n + 4 * m + output + 20 |
| evals_in_steps := headersTrace base n m output suffix hinput hn hm ho hs hr |
| steps_le_m := Nat.le_refl _ |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.CircuitProducerHeaders |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.CircuitProducerLoop |
|
|
| open Turing |
| open BinPackingGames.Foundations.Hastad |
| open CircuitProducerModel CircuitEmission CircuitProducerStages |
|
|
| def recordsInput (rs : List Record) : List Bool := rs.flatMap Record.bits |
| def recordsOutput (rs : List Record) : List Bool := rs.flatMap Record.outputBits |
|
|
| def tapes (base : Tape → List Bool) (input counter accumulator : List Bool) |
| (fields : Fin 4 → List Bool) : Tape → List Bool |
| | .input => input |
| | .counter => counter |
| | .field j => fields j |
| | .scratch => [] |
| | .reversed => accumulator |
| | tape => base tape |
|
|
| def parsedFields (r : Record) (j : Fin 4) : List Bool := encodeWord (r.fieldValue j) |
| def decodedFields (r : Record) (j : Fin 4) : List Bool := |
| if j.val = 0 then [] else parsedFields r j |
|
|
| theorem update_reversed (base : Tape → List Bool) (input counter acc out : List Bool) |
| (fields : Fin 4 → List Bool) : |
| Function.update (tapes base input counter acc fields) .reversed out = |
| tapes base input counter out fields := by |
| funext tape |
| cases tape <;> simp [tapes] |
|
|
| theorem counterTapes_eq (base : Tape → List Bool) (input counter acc : List Bool) |
| (fields : Fin 4 → List Bool) (n : Nat) : |
| MachineUnaryCounter.counterTapes .counter |
| (tapes base input counter acc fields) n [] = |
| tapes base input (encodeWord n) acc fields := by |
| funext tape |
| cases tape <;> simp [MachineUnaryCounter.counterTapes, tapes] |
|
|
| theorem fourTapes_eq (base : Tape → List Bool) (input counter acc suffix : List Bool) |
| (r : Record) : |
| SourceMachine.fourTapes .input Tape.field |
| (tapes base input counter acc (fun _ => [])) r.tag.val r.output r.first r.second suffix = |
| tapes base suffix counter acc (parsedFields r) := by |
| funext tape |
| cases tape with |
| | field j => |
| fin_cases j <;> |
| simp [SourceMachine.fourTapes, SourceMachine.afterField, SourceMachine.fieldTapes, |
| tapes, parsedFields, Record.fieldValue] |
| | _ => |
| simp [SourceMachine.fourTapes, SourceMachine.afterField, SourceMachine.fieldTapes, |
| tapes] |
|
|
| theorem decodeTapes_eq (base : Tape → List Bool) (input counter acc : List Bool) |
| (r : Record) : |
| Function.update (tapes base input counter acc (parsedFields r)) (.field 0) [] = |
| tapes base input counter acc (decodedFields r) := by |
| funext tape |
| cases tape with |
| | field j => fin_cases j <;> simp [tapes, decodedFields] |
| | _ => simp [tapes] |
|
|
| theorem clearFields_eq (base : Tape → List Bool) (input counter acc : List Bool) |
| (fields : Fin 4 → List Bool) : |
| clearFields (tapes base input counter acc fields) = |
| tapes base input counter acc (fun _ => []) := by |
| funext tape |
| cases tape with |
| | field j => simp [tapes] |
| | _ => simp [tapes, clearFields] |
|
|
| theorem cleanupSteps_eq (base : Tape → List Bool) (input counter acc : List Bool) |
| (r : Record) : |
| cleanupSteps (tapes base input counter acc (decodedFields r)) = |
| r.output + r.first + r.second + 7 := by |
| simp [cleanupSteps, tapes, decodedFields, parsedFields, Record.fieldValue] |
| omega |
|
|
| theorem recordBits_length (r : Record) : |
| r.bits.length = r.tag.val + r.output + r.first + r.second + 4 := by |
| simp [Record.bits, Record.words, encodeWords] |
| omega |
|
|
| def bodyCost (r : Record) : Nat := |
| (r.tag.val + r.output + r.first + r.second + 8) + 1 + |
| gateSteps r + (r.output + r.first + r.second + 7) |
|
|
| def bodyInTime (base : Tape → List Bool) (r : Record) (suffix counter acc : List Bool) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some (.fieldStart 0), initialState, |
| tapes base (r.bits ++ suffix) counter acc (fun _ => [])⟩ |
| (some ⟨some .guard, initialState, |
| tapes base suffix counter (r.outputBits.reverse ++ acc) (fun _ => [])⟩) |
| (bodyCost r) := by |
| let before := tapes base (r.bits ++ suffix) counter acc (fun _ => []) |
| let parsed := tapes base suffix counter acc (parsedFields r) |
| let decoded := tapes base suffix counter acc (decodedFields r) |
| let out := r.outputBits.reverse ++ acc |
| let emitted := tapes base suffix counter out (decodedFields r) |
| let parse := SourceMachine.fourFieldsInTime .input Tape.field |
| (by intro j h; cases h) Label.fieldStart Label.fieldLoop (some .decodeTag) |
| program (by intro j; rfl) (by intro j; rfl) |
| before r.tag.val r.output r.first r.second suffix rfl ((), defaultControl) none |
| have hp : SourceMachine.fourTapes .input Tape.field before |
| r.tag.val r.output r.first r.second suffix = parsed := fourTapes_eq _ _ _ _ _ _ |
| rw [hp] at parse |
| let decode := tagInTime r.tag parsed initialState rfl |
| have hd : Function.update parsed (.field 0) [] = decoded := decodeTapes_eq _ _ _ _ _ |
| rw [hd] at decode |
| let table := gateInTime r decoded rfl initialState rfl rfl rfl |
| have he : Function.update decoded .reversed (r.outputBits.reverse ++ decoded .reversed) = |
| emitted := update_reversed _ _ _ _ _ _ |
| rw [he] at table |
| let cleanup := cleanupInTime emitted ((), defaultControl) none |
| have hc : clearFields emitted = tapes base suffix counter out (fun _ => []) := |
| clearFields_eq _ _ _ _ _ |
| rw [hc] at cleanup |
| let p1 := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ parse decode |
| let p2 := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ p1 table |
| let p3 := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ p2 cleanup |
| exact { |
| toEvalsTo := p3.toEvalsTo |
| steps_le_m := by |
| have h := p3.steps_le_m |
| have hcost : cleanupSteps emitted = r.output + r.first + r.second + 7 := |
| cleanupSteps_eq _ _ _ _ _ |
| unfold bodyCost |
| omega } |
|
|
| def loopCost : List Record → Nat |
| | [] => 1 |
| | r :: rs => (1 + bodyCost r) + loopCost rs |
|
|
| def loopInTime (base : Tape → List Bool) (suffix : List Bool) |
| (rs : List Record) (acc : List Bool) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some .guard, initialState, |
| tapes base (recordsInput rs ++ suffix) (encodeWord rs.length) acc (fun _ => [])⟩ |
| (some ⟨some (.setup (.output 0)), initialState, |
| tapes base suffix (encodeWord 0) ((recordsOutput rs).reverse ++ acc) (fun _ => [])⟩) |
| (loopCost rs) := by |
| induction rs generalizing acc with |
| | nil => |
| let guard := MachineUnaryCounter.guardInTime_zero .counter Label.guard |
| (.fieldStart 0) (.setup (.output 0)) program rfl |
| (tapes base suffix (encodeWord 0) acc (fun _ => [])) [] |
| ((), defaultControl) none |
| simpa only [counterTapes_eq, loopCost, recordsInput, recordsOutput, |
| List.flatMap_nil, List.reverse_nil, List.nil_append, List.length_nil, |
| initialState] using guard |
| | cons r rs ih => |
| let before := tapes base (r.bits ++ (recordsInput rs ++ suffix)) |
| (encodeWord (rs.length + 1)) acc (fun _ => []) |
| let guard := MachineUnaryCounter.guardInTime_succ .counter Label.guard |
| (.fieldStart 0) (.setup (.output 0)) program rfl before rs.length [] |
| ((), defaultControl) none |
| simp only [before, counterTapes_eq] at guard |
| let body := bodyInTime base r (recordsInput rs ++ suffix) (encodeWord rs.length) acc |
| let rest := ih (r.outputBits.reverse ++ acc) |
| let first := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ guard body |
| let full := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ first rest |
| simpa only [loopCost, recordsInput, recordsOutput, List.flatMap_cons, |
| List.length_cons, List.reverse_append, List.append_assoc, initialState, |
| Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using full |
|
|
| theorem bodyCost_le (r : Record) : bodyCost r ≤ 50 * r.bits.length := by |
| have h := gateSteps_le r |
| rw [recordBits_length] |
| unfold bodyCost |
| omega |
|
|
| theorem loopCost_le (rs : List Record) : |
| loopCost rs ≤ 50 * (recordsInput rs).length + rs.length + 1 := by |
| induction rs with |
| | nil => simp [loopCost, recordsInput] |
| | cons r rs ih => |
| have h := bodyCost_le r |
| simp only [loopCost, recordsInput, List.flatMap_cons, List.length_append, |
| List.length_cons] at * |
| omega |
|
|
| theorem recordOutput_length_le (r : Record) : r.outputBits.length ≤ 9 * r.bits.length := by |
| have h := outputBits_length_le r |
| rw [recordBits_length] |
| omega |
|
|
| theorem recordsOutput_length_le (rs : List Record) : |
| (recordsOutput rs).length ≤ 9 * (recordsInput rs).length := by |
| induction rs with |
| | nil => simp [recordsOutput, recordsInput] |
| | cons r rs ih => |
| have h := recordOutput_length_le r |
| simp only [recordsOutput, recordsInput, List.flatMap_cons, List.length_append] at * |
| omega |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.CircuitProducerLoop |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.CircuitProducerRuntime |
|
|
| open Turing |
| open CircuitProducerModel CircuitProducerLoop |
|
|
| structure Input where |
| wireCount : Nat |
| selected : Nat |
| records : List Record |
|
|
| def inputBits (input : Input) : List Bool := |
| encodeWords [input.wireCount, input.records.length, input.selected] ++ recordsInput input.records |
|
|
| def outputHeaders (input : Input) : List Bool := |
| encodeWords [input.wireCount, 3 * input.records.length + 1] |
|
|
| def producedBits (input : Input) : List Bool := |
| outputHeaders input ++ recordsOutput input.records ++ encodeWords (outputWords input.selected) |
|
|
| def inputTapes (input : Input) : Tape → List Bool := |
| fun tape => if tape = .input then inputBits input else [] |
|
|
| def retainedTapes (input : Input) : Tape → List Bool := |
| fun tape => if tape = .selected then encodeWord input.selected else [] |
|
|
| def guardTapes (input : Input) : Tape → List Bool := |
| tapes (retainedTapes input) (recordsInput input.records) (encodeWord input.records.length) |
| (outputHeaders input).reverse (fun _ => []) |
|
|
| def afterLoopTapes (input : Input) : Tape → List Bool := |
| tapes (retainedTapes input) [] (encodeWord 0) |
| ((recordsOutput input.records).reverse ++ (outputHeaders input).reverse) (fun _ => []) |
|
|
| def beforeFinishTapes (input : Input) : Tape → List Bool := |
| tapes (retainedTapes input) [] (encodeWord 0) (producedBits input).reverse (fun _ => []) |
|
|
| theorem initList_eq (input : Input) : |
| initList machine (inputBits input) = |
| ⟨some (.headerStart 0), initialState, inputTapes input⟩ := by |
| change (⟨some (.headerStart 0), initialState, |
| (initList machine (inputBits input)).stk⟩ : machine.Cfg) = _ |
| apply congrArg (fun tapeContents => |
| (⟨some (.headerStart 0), initialState, tapeContents⟩ : machine.Cfg)) |
| funext tape |
| (cases tape <;> simp [initList, machine, inputTapes]); rfl |
|
|
| theorem headers_result_eq (input : Input) : |
| CircuitProducerHeaders.resultTapes (inputTapes input) input.wireCount |
| input.records.length input.selected (recordsInput input.records) = guardTapes input := by |
| funext tape |
| cases tape <;> simp [CircuitProducerHeaders.resultTapes, inputTapes, guardTapes, |
| tapes, retainedTapes, outputHeaders] |
|
|
| theorem output_result_eq (input : Input) : |
| Function.update (afterLoopTapes input) .reversed |
| ((encodeWords (outputWords input.selected)).reverse ++ afterLoopTapes input .reversed) = |
| beforeFinishTapes input := by |
| rw [afterLoopTapes, update_reversed] |
| simp [beforeFinishTapes, producedBits, tapes, List.reverse_append, List.append_assoc] |
|
|
| theorem finish_eq (input : Input) : |
| (⟨none, initialState, |
| CircuitProducerStages.finishTapes (beforeFinishTapes input)⟩ : machine.Cfg) = |
| haltList machine (producedBits input) := by |
| apply congrArg (fun tapeContents => (⟨none, initialState, tapeContents⟩ : machine.Cfg)) |
| funext tape |
| (cases tape <;> |
| simp [CircuitProducerStages.finishTapes, Reduction.MachineTransfer.tapesAt, |
| beforeFinishTapes, tapes, retainedTapes, machine]); rfl |
|
|
| theorem inputBits_length (input : Input) : |
| (inputBits input).length = input.wireCount + input.records.length + input.selected + 3 + |
| (recordsInput input.records).length := by |
| simp [inputBits, encodeWords] |
| omega |
|
|
| theorem producedBits_length_le (input : Input) : |
| (producedBits input).length ≤ input.wireCount + 3 * input.records.length + |
| 3 * input.selected + 9 * (recordsInput input.records).length + 12 := by |
| have h := recordsOutput_length_le input.records |
| simp only [producedBits, outputHeaders, List.length_append, outputWords, encodeWords, |
| encodeWord_length, List.length_nil] |
| omega |
|
|
| def fullRunInTime (input : Input) : |
| TM2OutputsInTime machine (inputBits input) (some (producedBits input)) |
| (100 * (inputBits input).length + 100) := by |
| let first := CircuitProducerHeaders.headersInTime (inputTapes input) input.wireCount |
| input.records.length input.selected (recordsInput input.records) rfl rfl rfl rfl rfl rfl |
| have first' : StateTransition.EvalsToInTime (TM2.step program) |
| (initList machine (inputBits input)) |
| (some ⟨some .guard, initialState, guardTapes input⟩) |
| (5 * input.wireCount + 4 * input.records.length + input.selected + 20) := by |
| simpa only [initList_eq, headers_result_eq] using! first |
| let middle := loopInTime (retainedTapes input) [] input.records (outputHeaders input).reverse |
| have middle' : StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some .guard, initialState, guardTapes input⟩ |
| (some ⟨some (.setup (.output 0)), initialState, afterLoopTapes input⟩) |
| (loopCost input.records) := by |
| simpa only [List.append_nil, guardTapes, afterLoopTapes] using middle |
| let unitClause := CircuitEmission.outputInTime input.selected (afterLoopTapes input) |
| rfl initialState rfl |
| have unitClause' : StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some (.setup (.output 0)), initialState, afterLoopTapes input⟩ |
| (some ⟨some .finalCounter, initialState, beforeFinishTapes input⟩) |
| (9 * (input.selected + 1) + 9) := by |
| simpa only [output_result_eq] using unitClause |
| let last := CircuitProducerStages.finishInTime (beforeFinishTapes input) rfl |
| have last' : StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some .finalCounter, initialState, beforeFinishTapes input⟩ |
| (some (haltList machine (producedBits input))) |
| (input.selected + (producedBits input).length + 4) := by |
| erw [finish_eq] at last |
| convert last using 1 |
| simp [beforeFinishTapes, tapes, retainedTapes] |
| omega |
| let firstTwo := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ first' middle' |
| let firstThree := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ firstTwo unitClause' |
| let complete := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ firstThree last' |
| refine { toEvalsTo := complete.toEvalsTo, steps_le_m := complete.steps_le_m.trans ?_ } |
| have hlo := loopCost_le input.records |
| have hout := producedBits_length_le input |
| rw [inputBits_length] |
| omega |
|
|
| noncomputable def computableInPolyTime : |
| TM2ComputableInPolyTime inputBits (id : List Bool → List Bool) producedBits where |
| tm := machine |
| inputAlphabet := Equiv.refl Bool |
| outputAlphabet := Equiv.refl Bool |
| time := Polynomial.C 100 * Polynomial.X + Polynomial.C 100 |
| outputsFun input := by |
| change TM2OutputsInTime machine ((inputBits input).map id) |
| (some ((producedBits input).map id)) _ |
| have input_eq : @List.map (machine.Γ machine.k₀) (machine.Γ machine.k₀) id |
| (inputBits input) = inputBits input := List.map_id _ |
| have output_eq : @List.map (machine.Γ machine.k₁) (machine.Γ machine.k₁) id |
| (producedBits input) = producedBits input := List.map_id _ |
| simpa only [Equiv.refl, input_eq, output_eq, id_eq, |
| Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_C, Polynomial.eval_X] |
| using fullRunInTime input |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.CircuitProducerRuntime |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.CircuitProducer |
|
|
| open Turing |
| open CircuitProducerModel |
|
|
| def asInput (C : Circuit) : CircuitProducerRuntime.Input := |
| ⟨C.wires, C.output.val, C.records⟩ |
|
|
| theorem recordsInput_eq (rs : List Record) : |
| CircuitProducerLoop.recordsInput rs = encodeWords (rs.flatMap Record.words) := by |
| induction rs with |
| | nil => rfl |
| | cons r rs ih => |
| simp only [CircuitProducerLoop.recordsInput, List.flatMap_cons, encodeWords_append] at * |
| rw [ih] |
| rfl |
|
|
| theorem recordsOutput_eq (rs : List Record) : |
| CircuitProducerLoop.recordsOutput rs = encodeWords (rs.flatMap Record.outputWords) := by |
| induction rs with |
| | nil => rfl |
| | cons r rs ih => |
| simp only [CircuitProducerLoop.recordsOutput, List.flatMap_cons, encodeWords_append] at * |
| rw [ih] |
| rfl |
|
|
| theorem inputBits_asInput (C : Circuit) : |
| CircuitProducerRuntime.inputBits (asInput C) = circuitBits C := by |
| simp only [CircuitProducerRuntime.inputBits, asInput, Circuit.records_length, |
| recordsInput_eq, circuitBits, circuitWords, encodeWords_append, recordsWords] |
|
|
| theorem producedBits_asInput (C : Circuit) : |
| CircuitProducerRuntime.producedBits (asInput C) = formulaBits C.toFormula := by |
| rw [formulaBits, C.formulaWords_eq_records] |
| simp only [CircuitProducerRuntime.producedBits, CircuitProducerRuntime.outputHeaders, |
| asInput, Circuit.records_length, recordsOutput_eq, encodeWords_append] |
|
|
| def fullRunInTime (C : Circuit) : |
| TM2OutputsInTime machine (circuitBits C) (some (formulaBits C.toFormula)) |
| (100 * (circuitBits C).length + 100) := by |
| simpa only [inputBits_asInput, producedBits_asInput] using |
| CircuitProducerRuntime.fullRunInTime (asInput C) |
|
|
| noncomputable def computableInPolyTime : |
| TM2ComputableInPolyTime circuitBits formulaBits Circuit.toFormula where |
| tm := machine |
| inputAlphabet := Equiv.refl Bool |
| outputAlphabet := Equiv.refl Bool |
| time := Polynomial.C 100 * Polynomial.X + Polynomial.C 100 |
| outputsFun C := by |
| change TM2OutputsInTime machine ((circuitBits C).map id) |
| (some ((formulaBits C.toFormula).map id)) _ |
| have input_eq : @List.map (machine.Γ machine.k₀) (machine.Γ machine.k₀) id |
| (circuitBits C) = circuitBits C := List.map_id _ |
| have output_eq : @List.map (machine.Γ machine.k₁) (machine.Γ machine.k₁) id |
| (formulaBits C.toFormula) = formulaBits C.toFormula := List.map_id _ |
| simpa only [Equiv.refl, input_eq, output_eq, |
| Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_C, Polynomial.eval_X] |
| using fullRunInTime C |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.CircuitProducer |
|
|
| end OAI |
|
|
