| import Mathlib.Tactic.Ring |
| import OAI.Computability.BinPacking.CookLevin.CircuitEncodingBridge |
|
|
| namespace OAI |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.CircuitFinish |
|
|
| open Turing MachineComposition |
| open MachineCloudPadding |
|
|
| inductive Tape |
| | current | freeInputs | root | reversedRecords | output | gateCount | scratch |
| deriving DecidableEq |
|
|
| protected abbrev Tape.enumList : List Tape := [.current, .freeInputs, .root, .reversedRecords, |
| .output, .gateCount, .scratch] |
|
|
| protected theorem Tape.enumList_getElem?_ctorIdx_eq (x : Tape) : |
| Tape.enumList[x.ctorIdx]? = some x := by |
| cases x <;> rfl |
|
|
| protected theorem Tape.enumList_nodup : Tape.enumList.Nodup := by decide |
|
|
| instance : Fintype Tape where |
| elems := ⟨Tape.enumList, Tape.enumList_nodup⟩ |
| complete x := by cases x <;> decide |
|
|
| inductive Label |
| | copyOut | copyBack | cancel | records |
| | rootOut | rootBack | countOut | countBack | currentOut | currentBack |
| deriving DecidableEq |
|
|
| protected abbrev Label.enumList : List Label := [.copyOut, .copyBack, .cancel, .records, .rootOut, |
| .rootBack, .countOut, .countBack, .currentOut, .currentBack] |
|
|
| protected theorem Label.enumList_getElem?_ctorIdx_eq (x : Label) : |
| Label.enumList[x.ctorIdx]? = some x := by |
| cases x <;> rfl |
|
|
| protected theorem Label.enumList_nodup : Label.enumList.Nodup := by decide |
|
|
| instance : Fintype Label where |
| elems := ⟨Label.enumList, Label.enumList_nodup⟩ |
| complete x := by cases x <;> decide |
|
|
| abbrev Alphabet (_ : Tape) := Bool |
| abbrev State (σ : Type) := σ × Option Bool |
|
|
| def memory (current freeInputs root reversedRecords output gateCount scratch : List Bool) : |
| Tape → List Bool |
| | .current => current |
| | .freeInputs => freeInputs |
| | .root => root |
| | .reversedRecords => reversedRecords |
| | .output => output |
| | .gateCount => gateCount |
| | .scratch => scratch |
|
|
| @[simp] theorem update_current (a b c d e f g x : List Bool) : |
| Function.update (memory a b c d e f g) .current x = memory x b c d e f g := by |
| funext t; cases t <;> rfl |
| @[simp] theorem update_freeInputs (a b c d e f g x : List Bool) : |
| Function.update (memory a b c d e f g) .freeInputs x = memory a x c d e f g := by |
| funext t; cases t <;> rfl |
| @[simp] theorem update_root (a b c d e f g x : List Bool) : |
| Function.update (memory a b c d e f g) .root x = memory a b x d e f g := by |
| funext t; cases t <;> rfl |
| @[simp] theorem update_reversedRecords (a b c d e f g x : List Bool) : |
| Function.update (memory a b c d e f g) .reversedRecords x = memory a b c x e f g := by |
| funext t; cases t <;> rfl |
| @[simp] theorem update_output (a b c d e f g x : List Bool) : |
| Function.update (memory a b c d e f g) .output x = memory a b c d x f g := by |
| funext t; cases t <;> rfl |
| @[simp] theorem update_gateCount (a b c d e f g x : List Bool) : |
| Function.update (memory a b c d e f g) .gateCount x = memory a b c d e x g := by |
| funext t; cases t <;> rfl |
| @[simp] theorem update_scratch (a b c d e f g x : List Bool) : |
| Function.update (memory a b c d e f g) .scratch x = memory a b c d e f x := by |
| funext t; cases t <;> rfl |
|
|
| variable {σ : Type} |
|
|
| def cancelLoop : TM2.Stmt Alphabet Label (State σ) := |
| .pop .freeInputs (fun state head => (state.1, head)) |
| (.branch (fun state => state.2.getD false) |
| (.pop .gateCount (fun state _ => (state.1, none)) (.goto fun _ => .cancel)) |
| (.load (fun state => (state.1, none)) (.goto fun _ => .records))) |
|
|
| def program : Label → TM2.Stmt Alphabet Label (State σ) |
| | .copyOut => Reduction.MachineTransfer.loopAt .current .scratch id false |
| .copyOut (some .copyBack) |
| | .copyBack => MachineCopy.forkLoop .scratch .current .gateCount false |
| .copyBack (some .cancel) |
| | .cancel => cancelLoop |
| | .records => Reduction.MachineTransfer.loopAt .reversedRecords .output id false |
| .records (some .rootOut) |
| | .rootOut => Reduction.MachineTransfer.loopAt .root .scratch id false |
| .rootOut (some .rootBack) |
| | .rootBack => Reduction.MachineTransfer.loopAt .scratch .output id false |
| .rootBack (some .countOut) |
| | .countOut => Reduction.MachineTransfer.loopAt .gateCount .scratch id false |
| .countOut (some .countBack) |
| | .countBack => Reduction.MachineTransfer.loopAt .scratch .output id false |
| .countBack (some .currentOut) |
| | .currentOut => Reduction.MachineTransfer.loopAt .current .scratch id false |
| .currentOut (some .currentBack) |
| | .currentBack => Reduction.MachineTransfer.loopAt .scratch .output id false |
| .currentBack none |
|
|
| private theorem appendTrace {α : Type*} (f : α → α) {a b : Nat} {x y z : α} |
| (first : f^[a] x = y) (second : f^[b] y = z) : f^[a + b] x = z := by |
| rw [Nat.add_comm a b, Function.iterate_add_apply, first, second] |
|
|
| theorem prependTrace {K Λ α : Type} [DecidableEq K] |
| (source destination scratch : K) |
| (sourceDestination : source ≠ destination) (sourceScratch : source ≠ scratch) |
| (destinationScratch : destination ≠ scratch) |
| (firstLabel secondLabel : Λ) (exit : Option Λ) |
| (target : Λ → TM2.Stmt (fun _ : K => Bool) Λ (α × Option Bool)) |
| (atFirst : target firstLabel = Reduction.MachineTransfer.loopAt source scratch id false |
| firstLabel (some secondLabel)) |
| (atSecond : target secondLabel = Reduction.MachineTransfer.loopAt scratch destination |
| id false secondLabel exit) |
| (base : K → List Bool) (scratchEmpty : base scratch = []) |
| (ambient : α) (register : Option Bool) : |
| (advance (TM2.step target))^[2 * ((base source).length + 1)] |
| (some ⟨some firstLabel, (ambient, register), base⟩) = |
| some ⟨exit, (ambient, none), |
| Reduction.MachineTransfer.tapesAt source destination base [] |
| (base source ++ base destination)⟩ := by |
| let mid := Reduction.MachineTransfer.tapesAt source scratch base [] (base source).reverse |
| have first := Reduction.MachineTransfer.transferAt_fromTapes source scratch sourceScratch |
| id false firstLabel (some secondLabel) target atFirst base ambient register |
| change (advance (TM2.step target))^[(base source).length + 1] |
| (some ⟨some firstLabel, (ambient, register), base⟩) = _ at first |
| simp only [List.map_id, scratchEmpty, List.append_nil] at first |
| change (advance (TM2.step target))^[(base source).length + 1] |
| (some ⟨some firstLabel, (ambient, register), base⟩) = |
| some ⟨some secondLabel, (ambient, none), mid⟩ at first |
| have hscratch : mid scratch = (base source).reverse := by |
| simp [mid] |
| have hdestination : mid destination = base destination := by |
| simp [mid, Reduction.MachineTransfer.tapesAt, Ne.symm sourceDestination, |
| destinationScratch] |
| have second := Reduction.MachineTransfer.transferAt_fromTapes scratch destination |
| (Ne.symm destinationScratch) id false secondLabel exit target atSecond mid ambient none |
| change (advance (TM2.step target))^[(mid scratch).length + 1] |
| (some ⟨some secondLabel, (ambient, none), mid⟩) = _ at second |
| rw [hscratch, hdestination] at second |
| simp only [List.length_reverse, List.reverse_reverse, List.map_id] at second |
| have restored : Reduction.MachineTransfer.tapesAt scratch destination mid [] |
| (base source ++ base destination) = |
| Reduction.MachineTransfer.tapesAt source destination base [] |
| (base source ++ base destination) := by |
| funext k |
| by_cases hs : k = source |
| · subst k |
| simp [Reduction.MachineTransfer.tapesAt, mid, sourceDestination, sourceScratch] |
| · by_cases hd : k = destination |
| · subst k |
| simp [Reduction.MachineTransfer.tapesAt] |
| · by_cases ht : k = scratch |
| · subst k |
| simp [Reduction.MachineTransfer.tapesAt, Ne.symm sourceScratch, |
| Ne.symm destinationScratch, scratchEmpty] |
| · simp [Reduction.MachineTransfer.tapesAt, mid, hs, hd, ht] |
| rw [restored] at second |
| have both := appendTrace _ first second |
| simpa only [show ((base source).length + 1) + ((base source).length + 1) = |
| 2 * ((base source).length + 1) by omega] using both |
|
|
| theorem cancelStep_zero (current root reversedRecords output scratch : List Bool) |
| (g : Nat) (ambient : σ) (register : Option Bool) : |
| TM2.step program |
| ⟨some .cancel, (ambient, register), |
| memory current (encodeWord 0) root reversedRecords output (encodeWord g) scratch⟩ = |
| some ⟨some .records, (ambient, none), |
| memory current [] root reversedRecords output (encodeWord g) scratch⟩ := by |
| change some (TM2.stepAux cancelLoop _ _) = _ |
| simp [cancelLoop, TM2.stepAux, memory, encodeWord] |
|
|
| theorem cancelStep_succ (current root reversedRecords output scratch : List Bool) |
| (f g : Nat) (ambient : σ) (register : Option Bool) : |
| TM2.step program |
| ⟨some .cancel, (ambient, register), |
| memory current (encodeWord (f + 1)) root reversedRecords output |
| (encodeWord (g + 1)) scratch⟩ = |
| some ⟨some .cancel, (ambient, none), |
| memory current (encodeWord f) root reversedRecords output (encodeWord g) scratch⟩ := by |
| change some (TM2.stepAux cancelLoop _ _) = _ |
| simp [cancelLoop, TM2.stepAux, memory, encodeWord, List.replicate_succ] |
|
|
| theorem cancelTrace (current root reversedRecords output scratch : List Bool) |
| (f g : Nat) (ambient : σ) (register : Option Bool) : |
| (advance (TM2.step program))^[f + 1] |
| (some ⟨some .cancel, (ambient, register), |
| memory current (encodeWord f) root reversedRecords output |
| (encodeWord (f + g)) scratch⟩) = |
| some ⟨some .records, (ambient, none), |
| memory current [] root reversedRecords output (encodeWord g) scratch⟩ := by |
| induction f generalizing register with |
| | zero => |
| simpa only [Nat.zero_add, Function.iterate_one, advance_some] using |
| cancelStep_zero current root reversedRecords output scratch g ambient register |
| | succ f ih => |
| rw [Function.iterate_succ_apply] |
| simp only [Nat.succ_add] |
| change (advance (TM2.step program))^[f + 1] |
| (TM2.step program |
| ⟨some .cancel, (ambient, register), |
| memory current (encodeWord (f + 1)) root reversedRecords output |
| (encodeWord ((f + g) + 1)) scratch⟩) = _ |
| rw [cancelStep_succ] |
| exact ih none |
|
|
| def initialTapes (n f root : Nat) (records : List Bool) : Tape → List Bool := |
| memory (encodeWord n) (encodeWord f) (encodeWord root) records.reverse [] [] [] |
|
|
| def finalTapes (n f root : Nat) (records : List Bool) : Tape → List Bool := |
| memory [] [] [] [] (encodeWords [n, n - f, root] ++ records) [] [] |
|
|
| def totalTime (n f root recordLength : Nat) : Nat := |
| 2 * (n + 2) + (f + 1) + (recordLength + 1) + |
| 2 * (root + 2) + 2 * (n - f + 2) + 2 * (n + 2) |
|
|
| theorem finishTrace (n f root : Nat) (records : List Bool) (hf : f ≤ n) |
| (ambient : σ) (register : Option Bool) : |
| (advance (TM2.step program))^[totalTime n f root records.length] |
| (some ⟨some .copyOut, (ambient, register), initialTapes n f root records⟩) = |
| some ⟨none, (ambient, none), finalTapes n f root records⟩ := by |
| have copy := MachineCopy.copyTrace Tape.current Tape.gateCount Tape.scratch |
| (by decide) (by decide) (by decide) false Label.copyOut Label.copyBack |
| (some Label.cancel) program rfl rfl (initialTapes n f root records) rfl ambient register |
| simp only [initialTapes, memory, encodeWord_length, List.append_nil, update_gateCount] at copy |
| have cancel := cancelTrace (encodeWord n) (encodeWord root) records.reverse [] [] |
| f (n - f) ambient none |
| rw [show f + (n - f) = n by omega] at cancel |
| have reverse := Reduction.MachineTransfer.transferAt_fromTapes Tape.reversedRecords |
| Tape.output (by decide) id false Label.records (some Label.rootOut) program rfl |
| (memory (encodeWord n) [] (encodeWord root) records.reverse [] (encodeWord (n - f)) []) |
| ambient none |
| change (advance (TM2.step program))^[_] |
| (some ⟨some .records, (ambient, none), _⟩) = _ at reverse |
| simp only [memory, List.length_reverse, List.reverse_reverse, List.map_id, |
| List.append_nil, Reduction.MachineTransfer.tapesAt, update_reversedRecords, |
| update_output] at reverse |
| have rootPhase := prependTrace Tape.root Tape.output Tape.scratch |
| (by decide) (by decide) (by decide) Label.rootOut Label.rootBack (some Label.countOut) |
| program rfl rfl |
| (memory (encodeWord n) [] (encodeWord root) [] records (encodeWord (n - f)) []) |
| rfl ambient none |
| simp only [memory, encodeWord_length, Reduction.MachineTransfer.tapesAt, |
| update_root, update_output] at rootPhase |
| have countPhase := prependTrace Tape.gateCount Tape.output Tape.scratch |
| (by decide) (by decide) (by decide) Label.countOut Label.countBack (some Label.currentOut) |
| program rfl rfl |
| (memory (encodeWord n) [] [] [] (encodeWord root ++ records) (encodeWord (n - f)) []) |
| rfl ambient none |
| simp only [memory, encodeWord_length, Reduction.MachineTransfer.tapesAt, |
| update_gateCount, update_output] at countPhase |
| have currentPhase := prependTrace Tape.current Tape.output Tape.scratch |
| (by decide) (by decide) (by decide) Label.currentOut Label.currentBack none |
| program rfl rfl |
| (memory (encodeWord n) [] [] [] |
| (encodeWord (n - f) ++ (encodeWord root ++ records)) [] []) rfl ambient none |
| simp only [memory, encodeWord_length, Reduction.MachineTransfer.tapesAt, |
| update_current, update_output] at currentPhase |
| have all := appendTrace _ (appendTrace _ (appendTrace _ |
| (appendTrace _ (appendTrace _ copy cancel) reverse) rootPhase) countPhase) currentPhase |
| simpa only [totalTime, initialTapes, finalTapes, encodeWords, |
| List.append_nil, List.append_assoc, Nat.add_assoc] using all |
|
|
| theorem finalTapes_output (n f root : Nat) (records : List Bool) : |
| finalTapes n f root records .output = encodeWords [n, n - f, root] ++ records := rfl |
|
|
| theorem finalTapes_clean (n f root : Nat) (records : List Bool) (tape : Tape) |
| (h : tape ≠ .output) : finalTapes n f root records tape = [] := by |
| cases tape <;> simp_all [finalTapes, memory] |
|
|
| theorem totalTime_eq (n f root recordLength : Nat) : |
| totalTime n f root recordLength = 4 * n + f + 2 * root + 2 * (n - f) + recordLength + 18 := by |
| unfold totalTime |
| ring |
|
|
| theorem totalTime_le (n f root recordLength : Nat) (hf : f ≤ n) (hr : root < n) : |
| totalTime n f root recordLength ≤ 9 * n + recordLength + 18 := by |
| rw [totalTime_eq] |
| have hg := Nat.sub_le n f |
| omega |
|
|
| theorem circuit_finalTapes (C : Circuit) : |
| finalTapes C.wires C.inputs C.output.val (recordsBits C.records) = |
| memory [] [] [] [] (circuitBits C) [] [] := by |
| have hcount : C.wires - C.inputs = C.gates.length := by |
| simp [Circuit.wires] |
| simp only [finalTapes, hcount, circuitBits, circuitWords, encodeWords_append, |
| recordsBits] |
|
|
| theorem circuitTrace (C : Circuit) (ambient : σ) (register : Option Bool) : |
| (advance (TM2.step program))^[ |
| totalTime C.wires C.inputs C.output.val (recordsBits C.records).length] |
| (some ⟨some .copyOut, (ambient, register), |
| initialTapes C.wires C.inputs C.output.val (recordsBits C.records)⟩) = |
| some ⟨none, (ambient, none), memory [] [] [] [] (circuitBits C) [] []⟩ := by |
| rw [← circuit_finalTapes] |
| exact finishTrace C.wires C.inputs C.output.val (recordsBits C.records) |
| (Nat.le_add_right _ _) ambient register |
|
|
| def circuitInTime (C : Circuit) (ambient : σ) (register : Option Bool) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some .copyOut, (ambient, register), |
| initialTapes C.wires C.inputs C.output.val (recordsBits C.records)⟩ |
| (some ⟨none, (ambient, none), memory [] [] [] [] (circuitBits C) [] []⟩) |
| (9 * C.wires + (recordsBits C.records).length + 18) where |
| steps := totalTime C.wires C.inputs C.output.val (recordsBits C.records).length |
| evals_in_steps := circuitTrace C ambient register |
| steps_le_m := totalTime_le _ _ _ _ (Nat.le_add_right _ _) C.output.isLt |
|
|
| def placedCircuitInTime {K Λ : Type} [DecidableEq K] |
| (tape : Tape → K) (view : K → Option Tape) |
| (left : ∀ t, view (tape t) = some t) |
| (right : ∀ k t, view k = some t → tape t = k) |
| (labels : Label → Λ) (exit : Option Λ) (extra : K → List Bool) |
| (target : Λ → TM2.Stmt (fun _ : K => Bool) Λ (State σ)) |
| (code : ∀ l, target (labels l) = Placement.statement tape labels exit (program l)) |
| (C : Circuit) (ambient : σ) (register : Option Bool) : |
| StateTransition.EvalsToInTime (TM2.step target) |
| (Placement.configuration view labels exit extra |
| ⟨some .copyOut, (ambient, register), |
| initialTapes C.wires C.inputs C.output.val (recordsBits C.records)⟩) |
| (some (Placement.configuration view labels exit extra |
| ⟨none, (ambient, none), memory [] [] [] [] (circuitBits C) [] []⟩)) |
| (9 * C.wires + (recordsBits C.records).length + 18) := |
| liftExecutionInTime (TM2.step program) (TM2.step target) |
| (Placement.configuration view labels exit extra) |
| (Placement.step_simulation tape view left right labels exit extra program target code) |
| (circuitInTime C ambient register) |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.CircuitFinish |
|
|
| end OAI |
|
|
