openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Machines /CanonicalDictionaryAppendMachine.lean
| import OAI.Computability.PerfectCompleteness.Machines.BinaryNameCompare | |
| namespace OAI | |
| namespace PerfectCompleteness.CanonicalDictionaryAppendMachine | |
| open Turing | |
| open UniqueGamesTheorem.Foundations.Complexity | |
| open MachineComposition | |
| open UniqueGamesTheorem.Reduction.MachineTransfer | |
| variable {K Λ A : Type} [DecidableEq K] | |
| abbrev Alphabet (_ : K) := Bool | |
| abbrev State (A : Type) := BinaryNameCompare.State A | |
| abbrev clean (ambient : A) : State A := BinaryNameCompare.clean ambient | |
| def payload (bits : List Bool) : List Bool := bits.flatMap fun bit => [true, bit] | |
| theorem payload_frame (bits : List Bool) : | |
| payload bits ++ [false] = BinaryNameMachine.frame bits := by | |
| induction bits with | |
| | nil => rfl | |
| | cons bit bits ih => | |
| simpa [payload, BinaryNameMachine.frame] using congrArg (fun tail => true :: bit :: tail) ih | |
| def finish (destination : K) (exit : Option Λ) : | |
| TM2.Stmt (Alphabet (K := K)) Λ (State A) := | |
| .load (fun state => clean state.1.1) (exitAt destination exit) | |
| def emitLoop (source destination : K) (again : Λ) (exit : Option Λ) : | |
| TM2.Stmt (Alphabet (K := K)) Λ (State A) := | |
| .pop source (fun state head => (state.1, head)) | |
| (.branch (fun state => state.2.isSome) | |
| (.push destination (fun state => state.2.getD false) | |
| (.push destination (fun _ => true) (finish destination (some again)))) | |
| (.push destination (fun _ => false) (finish destination exit))) | |
| private theorem update_source (source destination : K) (distinct : source ≠ destination) | |
| (base : K → List Bool) (input output replacement : List Bool) : | |
| Function.update (tapesAt source destination base input output) source replacement = | |
| tapesAt source destination base replacement output := by | |
| funext k | |
| by_cases hs : k = source | |
| · subst k; simp [tapesAt, distinct] | |
| · by_cases hd : k = destination | |
| · subst k; simp [tapesAt, Ne.symm distinct] | |
| · simp [tapesAt, hs, hd] | |
| private theorem update_destination (source destination : K) | |
| (base : K → List Bool) (input output replacement : List Bool) : | |
| Function.update (tapesAt source destination base input output) destination replacement = | |
| tapesAt source destination base input replacement := by | |
| simp [tapesAt] | |
| theorem emitStep_empty (source destination : K) (distinct : source ≠ destination) | |
| (again : Λ) (exit : Option Λ) | |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State A)) | |
| (atLoop : program again = emitLoop source destination again exit) | |
| (base : K → List Bool) (output : List Bool) (ambient : A) : | |
| TM2.step program | |
| ⟨some again, clean ambient, tapesAt source destination base [] output⟩ = | |
| some ⟨exit, clean ambient, tapesAt source destination base [] (false :: output)⟩ := by | |
| change some (TM2.stepAux (program again) _ _) = _ | |
| rw [atLoop] | |
| cases exit <;> | |
| simp [emitLoop, finish, exitAt, TM2.stepAux, clean, BinaryNameCompare.clean, | |
| distinct, update_source, update_destination] | |
| theorem emitStep_cons (source destination : K) (distinct : source ≠ destination) | |
| (again : Λ) (exit : Option Λ) | |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State A)) | |
| (atLoop : program again = emitLoop source destination again exit) | |
| (base : K → List Bool) (bit : Bool) (input output : List Bool) (ambient : A) : | |
| TM2.step program | |
| ⟨some again, clean ambient, tapesAt source destination base (bit :: input) output⟩ = | |
| some ⟨some again, clean ambient, | |
| tapesAt source destination base input (true :: bit :: output)⟩ := by | |
| change some (TM2.stepAux (program again) _ _) = _ | |
| rw [atLoop] | |
| simp [emitLoop, finish, exitAt, TM2.stepAux, clean, BinaryNameCompare.clean, | |
| distinct, update_source, update_destination] | |
| theorem emitTrace (source destination : K) (distinct : source ≠ destination) | |
| (again : Λ) (exit : Option Λ) | |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State A)) | |
| (atLoop : program again = emitLoop source destination again exit) | |
| (base : K → List Bool) (input output : List Bool) (ambient : A) : | |
| (advance (TM2.step program))^[input.length + 1] | |
| (some ⟨some again, clean ambient, tapesAt source destination base input output⟩) = | |
| some ⟨exit, clean ambient, | |
| tapesAt source destination base [] (false :: (payload input.reverse ++ output))⟩ := by | |
| induction input generalizing output with | |
| | nil => | |
| simpa only [List.length_nil, Nat.zero_add, Function.iterate_one, advance_some, | |
| List.reverse_nil, payload, List.flatMap_nil, List.nil_append] using | |
| emitStep_empty source destination distinct again exit program atLoop base output ambient | |
| | cons bit input ih => | |
| rw [List.length_cons, Function.iterate_succ_apply] | |
| simp only [advance_some] | |
| rw [emitStep_cons source destination distinct again exit program atLoop, ih] | |
| simp only [List.reverse_cons, payload, List.flatMap_append, List.flatMap_cons, | |
| List.flatMap_nil, List.append_nil, List.append_assoc, List.cons_append, | |
| List.nil_append] | |
| inductive Label | |
| | copyOut | copyBack | save | seed | emit | restore | |
| deriving DecidableEq | |
| protected abbrev Label.enumList : List Label := [.copyOut, .copyBack, .save, .seed, .emit, | |
| .restore] | |
| 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 | |
| def instruction (tape : Fin 5 → K) (labels : Label → Λ) (exit : Option Λ) : | |
| Label → TM2.Stmt (Alphabet (K := K)) Λ (State A) | |
| | .copyOut => loopAt (tape 0) (tape 3) id false | |
| (labels .copyOut) (some (labels .copyBack)) | |
| | .copyBack => MachineCopy.forkLoop (tape 3) (tape 0) (tape 2) false | |
| (labels .copyBack) (some (labels .save)) | |
| | .save => loopAt (tape 1) (tape 4) id false | |
| (labels .save) (some (labels .seed)) | |
| | .seed => .push (tape 1) (fun _ => false) (.goto fun _ => labels .emit) | |
| | .emit => emitLoop (tape 2) (tape 1) (labels .emit) (some (labels .restore)) | |
| | .restore => loopAt (tape 4) (tape 1) id false (labels .restore) exit | |
| def steps (keyLength dictionaryLength : Nat) : Nat := | |
| 3 * keyLength + 2 * dictionaryLength + 6 | |
| 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 appendTrace (tape : Fin 5 → K) (distinct : Function.Injective tape) | |
| (labels : Label → Λ) (exit : Option Λ) | |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State A)) | |
| (atLabels : ∀ l, program (labels l) = instruction tape labels exit l) | |
| (base : K → List Bool) (bits dictionary : List Bool) | |
| (keyWord : base (tape 0) = bits.reverse) | |
| (dictionaryWord : base (tape 1) = dictionary) | |
| (copyEmpty : base (tape 2) = []) (scratchEmpty : base (tape 3) = []) | |
| (savedEmpty : base (tape 4) = []) (ambient : A) : | |
| (advance (TM2.step program))^[steps bits.length dictionary.length] | |
| (some ⟨some (labels .copyOut), clean ambient, base⟩) = | |
| some ⟨exit, clean ambient, | |
| Function.update base (tape 1) (dictionary ++ (false :: BinaryNameMachine.frame bits))⟩ := by | |
| have hd (i j : Fin 5) (hne : i ≠ j) : tape i ≠ tape j := fun h => hne (distinct h) | |
| let copyBase := Function.update base (tape 2) bits.reverse | |
| let savedBase := tapesAt (tape 1) (tape 4) copyBase [] dictionary.reverse | |
| let seedBase := Function.update savedBase (tape 1) [false] | |
| let emittedBase := tapesAt (tape 2) (tape 1) seedBase [] | |
| (false :: BinaryNameMachine.frame bits) | |
| have copyRun : (advance (TM2.step program))^[2 * (bits.length + 1)] | |
| (some ⟨some (labels .copyOut), clean ambient, base⟩) = | |
| some ⟨some (labels .save), clean ambient, copyBase⟩ := by | |
| have h := MachineCopy.copyTrace (tape 0) (tape 2) (tape 3) | |
| (hd 0 2 (by decide)) (hd 0 3 (by decide)) (hd 2 3 (by decide)) false | |
| (labels .copyOut) (labels .copyBack) (some (labels .save)) program | |
| (atLabels .copyOut) (atLabels .copyBack) base scratchEmpty | |
| (ambient, false, none) none | |
| simpa only [keyWord, copyEmpty, List.append_nil, List.length_reverse, | |
| clean, BinaryNameCompare.clean, copyBase] using h | |
| have copyDictionary : copyBase (tape 1) = dictionary := by | |
| simpa [copyBase, hd 1 2 (by decide)] using dictionaryWord | |
| have copySaved : copyBase (tape 4) = [] := by | |
| simpa [copyBase, hd 4 2 (by decide)] using savedEmpty | |
| have saveRun : (advance (TM2.step program))^[dictionary.length + 1] | |
| (some ⟨some (labels .save), clean ambient, copyBase⟩) = | |
| some ⟨some (labels .seed), clean ambient, savedBase⟩ := by | |
| have h := transferAt_fromTapes (Γ := Alphabet) (σ := A × Bool × Option Bool) | |
| (tape 1) (tape 4) (hd 1 4 (by decide)) id false (labels .save) | |
| (some (labels .seed)) program (atLabels .save) copyBase (ambient, false, none) none | |
| change (advance (TM2.step program))^[(copyBase (tape 1)).length + 1] | |
| (some ⟨some (labels .save), clean ambient, copyBase⟩) = | |
| some ⟨some (labels .seed), clean ambient, tapesAt (tape 1) (tape 4) copyBase [] | |
| ((copyBase (tape 1)).reverse.map id ++ copyBase (tape 4))⟩ at h | |
| simpa only [copyDictionary, copySaved, List.map_id, | |
| List.append_nil, clean, BinaryNameCompare.clean, savedBase] using h | |
| have seedRun : (advance (TM2.step program))^[1] | |
| (some ⟨some (labels .seed), clean ambient, savedBase⟩) = | |
| some ⟨some (labels .emit), clean ambient, seedBase⟩ := by | |
| simp only [Function.iterate_one, advance_some] | |
| change some (TM2.stepAux (program (labels .seed)) _ _) = _ | |
| rw [atLabels .seed] | |
| simp [instruction, TM2.stepAux, savedBase, tapesAt, seedBase, hd 1 4 (by decide)] | |
| have seedKey : seedBase (tape 2) = bits.reverse := by | |
| simp [seedBase, savedBase, tapesAt, copyBase, hd 2 1 (by decide), hd 2 4 (by decide)] | |
| have seedDictionary : seedBase (tape 1) = [false] := by simp [seedBase] | |
| have emitRun : (advance (TM2.step program))^[bits.length + 1] | |
| (some ⟨some (labels .emit), clean ambient, seedBase⟩) = | |
| some ⟨some (labels .restore), clean ambient, emittedBase⟩ := by | |
| have h := emitTrace (tape 2) (tape 1) (hd 2 1 (by decide)) | |
| (labels .emit) (some (labels .restore)) program (atLabels .emit) seedBase | |
| (seedBase (tape 2)) (seedBase (tape 1)) ambient | |
| rw [tapesAt_self] at h | |
| simpa only [seedKey, seedDictionary, List.length_reverse, List.reverse_reverse, | |
| payload_frame, emittedBase] using h | |
| have emittedSaved : emittedBase (tape 4) = dictionary.reverse := by | |
| simp [emittedBase, seedBase, savedBase, tapesAt, | |
| hd 4 1 (by decide), hd 4 2 (by decide)] | |
| have emittedDictionary : emittedBase (tape 1) = | |
| false :: BinaryNameMachine.frame bits := by simp [emittedBase] | |
| have restored : tapesAt (tape 4) (tape 1) emittedBase [] | |
| (dictionary ++ (false :: BinaryNameMachine.frame bits)) = | |
| Function.update base (tape 1) (dictionary ++ (false :: BinaryNameMachine.frame bits)) := by | |
| funext k | |
| by_cases h1 : k = tape 1 | |
| · subst k; simp [tapesAt] | |
| · by_cases h2 : k = tape 2 | |
| · subst k | |
| simp [tapesAt, emittedBase, hd 2 1 (by decide), hd 2 4 (by decide), copyEmpty] | |
| · by_cases h4 : k = tape 4 | |
| · subst k | |
| simp [tapesAt, hd 4 1 (by decide), savedEmpty] | |
| · simp [tapesAt, emittedBase, seedBase, savedBase, copyBase, h1, h2, h4] | |
| have restoreRun : (advance (TM2.step program))^[dictionary.length + 1] | |
| (some ⟨some (labels .restore), clean ambient, emittedBase⟩) = | |
| some ⟨exit, clean ambient, | |
| Function.update base (tape 1) (dictionary ++ (false :: BinaryNameMachine.frame bits))⟩ := by | |
| have h := transferAt_fromTapes (Γ := Alphabet) (σ := A × Bool × Option Bool) | |
| (tape 4) (tape 1) (hd 4 1 (by decide)) id false (labels .restore) exit | |
| program (atLabels .restore) emittedBase (ambient, false, none) none | |
| change (advance (TM2.step program))^[(emittedBase (tape 4)).length + 1] | |
| (some ⟨some (labels .restore), clean ambient, emittedBase⟩) = | |
| some ⟨exit, clean ambient, tapesAt (tape 4) (tape 1) emittedBase [] | |
| ((emittedBase (tape 4)).reverse.map id ++ emittedBase (tape 1))⟩ at h | |
| simpa only [emittedSaved, emittedDictionary, List.length_reverse, | |
| List.reverse_reverse, List.map_id, restored, clean, BinaryNameCompare.clean] using h | |
| have h := joinTrace (joinTrace (joinTrace (joinTrace copyRun saveRun) seedRun) emitRun) restoreRun | |
| have time : (((2 * (bits.length + 1) + (dictionary.length + 1)) + 1) + | |
| (bits.length + 1)) + (dictionary.length + 1) = steps bits.length dictionary.length := by | |
| unfold steps | |
| omega | |
| rw [time] at h | |
| exact h | |
| def appendInTime (tape : Fin 5 → K) (distinct : Function.Injective tape) | |
| (labels : Label → Λ) (exit : Option Λ) | |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State A)) | |
| (atLabels : ∀ l, program (labels l) = instruction tape labels exit l) | |
| (base : K → List Bool) (bits dictionary : List Bool) | |
| (keyWord : base (tape 0) = bits.reverse) | |
| (dictionaryWord : base (tape 1) = dictionary) | |
| (copyEmpty : base (tape 2) = []) (scratchEmpty : base (tape 3) = []) | |
| (savedEmpty : base (tape 4) = []) (ambient : A) : | |
| StateTransition.EvalsToInTime (TM2.step program) | |
| ⟨some (labels .copyOut), clean ambient, base⟩ | |
| (some ⟨exit, clean ambient, | |
| Function.update base (tape 1) (dictionary ++ (false :: BinaryNameMachine.frame bits))⟩) | |
| (3 * bits.length + 2 * dictionary.length + 6) where | |
| steps := steps bits.length dictionary.length | |
| evals_in_steps := appendTrace tape distinct labels exit program atLabels base bits dictionary | |
| keyWord dictionaryWord copyEmpty scratchEmpty savedEmpty ambient | |
| steps_le_m := Nat.le_refl _ | |
| def machine : FinTM2 where | |
| K := Fin 5 | |
| k₀ := 0 | |
| k₁ := 1 | |
| Γ _ := Bool | |
| Λ := Label | |
| main := .copyOut | |
| σ := State Unit | |
| initialState := clean () | |
| m := instruction id id none | |
| theorem machine_finiteAlphabet (k : machine.K) : Finite (machine.Γ k) := by | |
| change Finite Bool | |
| infer_instance | |
| end PerfectCompleteness.CanonicalDictionaryAppendMachine | |
| end OAI | |