openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Machines /BinaryPairMachine.lean
| import OAI.Computability.UniqueGames.Machines.MachineLemmas | |
| import OAI.Computability.UniqueGames.Reduction.MachineTransfer | |
| namespace OAI | |
| namespace PerfectCompleteness.BinaryPairMachine | |
| open Turing | |
| open UniqueGamesTheorem.Foundations.Complexity | |
| open MachineComposition | |
| open UniqueGamesTheorem.Reduction.MachineTransfer | |
| abbrev Tape := Fin 3 | |
| abbrev Label := Fin 5 | |
| abbrev State := Unit × Option Bool | |
| abbrev Alphabet (_ : Tape) := Bool | |
| def stop (label : Label) : TM2.Stmt Alphabet Label State := | |
| .load (fun _ => ((), none)) (.goto fun _ => label) | |
| def count : TM2.Stmt Alphabet Label State := | |
| .pop 0 (fun state head => (state.1, head)) | |
| (.branch (fun state => state.2.isNone) | |
| (stop 4) | |
| (.branch (fun state => state.2.getD false) | |
| (.push 1 (fun _ => true) (.goto fun _ => 0)) | |
| (stop 1))) | |
| def copy : TM2.Stmt Alphabet Label State := | |
| .pop 1 (fun state head => (state.1, head)) | |
| (.branch (fun state => state.2.isSome) | |
| (.pop 0 (fun state head => (state.1, head)) | |
| (.branch (fun state => state.2.isSome) | |
| (.push 2 (fun state => state.2.getD false) (.goto fun _ => 1)) | |
| (stop 4))) | |
| (stop 2)) | |
| def program (label : Label) : TM2.Stmt Alphabet Label State := | |
| if label = 0 then count | |
| else if label = 1 then copy | |
| else if label = 2 then loopAt 2 1 id false 2 (some 3) | |
| else .halt | |
| abbrev machine : FinTM2 where | |
| K := Tape | |
| k₀ := 0 | |
| k₁ := 1 | |
| Γ := Alphabet | |
| Λ := Label | |
| main := 0 | |
| σ := State | |
| initialState := ((), none) | |
| m := program | |
| def tapes (input counter saved : List Bool) : Tape → List Bool := | |
| fun k => if k = 0 then input else if k = 1 then counter else saved | |
| def cfg (label : Option Label) (input counter saved : List Bool) | |
| (register : Option Bool := none) : machine.Cfg := | |
| ⟨label, ((), register), tapes input counter saved⟩ | |
| @[simp] private theorem tapes_zero (input counter saved : List Bool) : | |
| tapes input counter saved 0 = input := rfl | |
| @[simp] private theorem tapes_one (input counter saved : List Bool) : | |
| tapes input counter saved 1 = counter := rfl | |
| @[simp] private theorem tapes_two (input counter saved : List Bool) : | |
| tapes input counter saved 2 = saved := rfl | |
| private theorem update_zero (input counter saved replacement : List Bool) : | |
| Function.update (tapes input counter saved) 0 replacement = | |
| tapes replacement counter saved := by | |
| funext k | |
| fin_cases k <;> simp [tapes] | |
| private theorem update_one (input counter saved replacement : List Bool) : | |
| Function.update (tapes input counter saved) 1 replacement = | |
| tapes input replacement saved := by | |
| funext k | |
| fin_cases k <;> simp [tapes] | |
| private theorem update_two (input counter saved replacement : List Bool) : | |
| Function.update (tapes input counter saved) 2 replacement = | |
| tapes input counter replacement := by | |
| funext k | |
| fin_cases k <;> simp [tapes] | |
| theorem countStep_true (input counter saved : List Bool) (register : Option Bool) : | |
| machine.step (cfg (some 0) (true :: input) counter saved register) = | |
| some (cfg (some 0) input (true :: counter) saved (some true)) := by | |
| change some (TM2.stepAux (program 0) _ _) = _ | |
| simp [program, count, cfg, TM2.stepAux, update_zero, update_one] | |
| rfl | |
| theorem countStep_false (input counter saved : List Bool) (register : Option Bool) : | |
| machine.step (cfg (some 0) (false :: input) counter saved register) = | |
| some (cfg (some 1) input counter saved) := by | |
| change some (TM2.stepAux (program 0) _ _) = _ | |
| simp [program, count, stop, cfg, TM2.stepAux, update_zero] | |
| rfl | |
| theorem countTrace (n : Nat) (input counter saved : List Bool) (register : Option Bool) : | |
| (advance machine.step)^[n + 1] | |
| (some (cfg (some 0) (encodeWord n ++ input) counter saved register)) = | |
| some (cfg (some 1) input (List.replicate n true ++ counter) saved) := by | |
| induction n generalizing counter register with | |
| | zero => | |
| simpa only [Nat.zero_add, Function.iterate_one, advance_some, encodeWord, | |
| List.replicate_zero, List.nil_append, List.singleton_append] using | |
| countStep_false input counter saved register | |
| | succ n ih => | |
| rw [show encodeWord (n + 1) ++ input = true :: (encodeWord n ++ input) by | |
| simp only [encodeWord, List.replicate_succ, List.cons_append]] | |
| rw [Function.iterate_succ_apply] | |
| simp only [advance_some] | |
| rw [countStep_true] | |
| rw [ih] | |
| rw [List.replicate_succ'] | |
| simp only [List.append_assoc, List.singleton_append] | |
| theorem copyStep_empty (input saved : List Bool) (register : Option Bool) : | |
| machine.step (cfg (some 1) input [] saved register) = | |
| some (cfg (some 2) input [] saved) := by | |
| change some (TM2.stepAux (program 1) _ _) = _ | |
| simp [program, copy, stop, cfg, TM2.stepAux, update_one] | |
| rfl | |
| theorem copyStep_cons (bit : Bool) (input counter saved : List Bool) | |
| (register : Option Bool) : | |
| machine.step (cfg (some 1) (bit :: input) (true :: counter) saved register) = | |
| some (cfg (some 1) input counter (bit :: saved) (some bit)) := by | |
| change some (TM2.stepAux (program 1) _ _) = _ | |
| simp [program, copy, cfg, TM2.stepAux, update_zero, update_one, update_two] | |
| rfl | |
| theorem copyTrace (input suffix saved : List Bool) (register : Option Bool) : | |
| (advance machine.step)^[input.length + 1] | |
| (some (cfg (some 1) (input ++ suffix) (List.replicate input.length true) saved register)) = | |
| some (cfg (some 2) suffix [] (input.reverse ++ saved)) := by | |
| induction input generalizing saved register with | |
| | nil => | |
| simpa only [List.length_nil, Nat.zero_add, Function.iterate_one, advance_some, | |
| List.nil_append, List.replicate_zero, List.reverse_nil] using | |
| copyStep_empty suffix saved register | |
| | cons bit input ih => | |
| rw [List.length_cons, Function.iterate_succ_apply] | |
| simp only [List.cons_append, List.replicate_succ, advance_some] | |
| rw [copyStep_cons, ih] | |
| simp only [List.reverse_cons, List.append_assoc, List.singleton_append] | |
| theorem restoreTrace (input witness : List Bool) (register : Option Bool) : | |
| (advance machine.step)^[input.length + 1] | |
| (some (cfg (some 2) witness [] input.reverse register)) = | |
| some (cfg (some 3) witness input []) := by | |
| change (nextAt (Γ := Alphabet) (1 : Tape) program)^[input.length + 1] | |
| (some ⟨some (2 : Label), ((), register), tapes witness [] input.reverse⟩) = | |
| some ⟨some (3 : Label), ((), none), tapes witness input []⟩ | |
| have h := transferAt_steps (Γ := Alphabet) (σ := Unit) (2 : Tape) 1 (by decide) | |
| id false (2 : Label) (some 3) program (by simp [program]) | |
| (tapes witness [] []) input.reverse [] () register | |
| simpa only [tapesAt, update_two, update_one, List.length_reverse, List.reverse_reverse, | |
| List.map_id_fun, id_eq, List.append_nil] using h | |
| theorem initList_eq (input : List Bool) : | |
| initList machine input = cfg (some 0) input [] [] := by | |
| unfold initList cfg | |
| congr 1 | |
| funext k | |
| fin_cases k <;> simp [tapes, machine] | |
| private theorem joinTrace {X : Type*} {f : X → X} {a b c : X} {n m : Nat} | |
| (first : f^[n] a = b) (second : f^[m] b = c) : f^[n + m] a = c := by | |
| rw [Nat.add_comm, Function.iterate_add_apply, first, second] | |
| theorem pairTrace (input witness : List Bool) : | |
| (advance machine.step)^[3 * input.length + 3] | |
| (some (initList machine (CookLevin.pairBits (input, witness)))) = | |
| some (cfg (some 3) witness input []) := by | |
| have first := countTrace input.length (input ++ witness) [] [] none | |
| simp only [List.append_nil] at first | |
| have second := copyTrace input witness [] none | |
| simp only [List.append_nil] at second | |
| have third := restoreTrace input witness none | |
| have full := joinTrace (joinTrace first second) third | |
| have htime : (input.length + 1 + (input.length + 1)) + (input.length + 1) = | |
| 3 * input.length + 3 := by omega | |
| rw [htime] at full | |
| simpa only [initList_eq, CookLevin.pairBits, List.append_assoc] using full | |
| def pairInTime (input witness : List Bool) : | |
| StateTransition.EvalsToInTime machine.step | |
| (initList machine (CookLevin.pairBits (input, witness))) | |
| (some (cfg (some 3) witness input [])) (3 * input.length + 3) where | |
| steps := 3 * input.length + 3 | |
| evals_in_steps := pairTrace input witness | |
| steps_le_m := Nat.le_refl _ | |
| theorem haltStep (input witness : List Bool) : | |
| machine.step (cfg (some 3) witness input []) = some (cfg none witness input []) := by | |
| change some (TM2.stepAux (program 3) _ _) = _ | |
| simp [program, cfg, TM2.stepAux] | |
| rfl | |
| def pairHaltInTime (input witness : List Bool) : | |
| StateTransition.EvalsToInTime machine.step | |
| (initList machine (CookLevin.pairBits (input, witness))) | |
| (some (cfg none witness input [])) (3 * input.length + 4) where | |
| steps := 3 * input.length + 4 | |
| evals_in_steps := by | |
| change (advance machine.step)^[3 * input.length + 4] | |
| (some (initList machine (CookLevin.pairBits (input, witness)))) = _ | |
| rw [show 3 * input.length + 4 = (3 * input.length + 3) + 1 by omega, | |
| Function.iterate_succ_apply', pairTrace, advance_some, haltStep] | |
| steps_le_m := Nat.le_refl _ | |
| theorem pairSteps_le_pairedLength (input witness : List Bool) : | |
| 3 * input.length + 4 ≤ 3 * (CookLevin.pairBits (input, witness)).length + 4 := by | |
| rw [CookLevin.pairBits_length] | |
| dsimp only | |
| omega | |
| theorem machine_finiteAlphabet (k : machine.K) : Finite (machine.Γ k) := by | |
| change Finite Bool | |
| infer_instance | |
| end PerfectCompleteness.BinaryPairMachine | |
| end OAI | |