openAI-math-dataset / lean /OAI /MathematicalPhysics /NavierStokes /ForcedComputation /Programs /FixedInterpreter.lean
| import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.TM0FiniteCoding | |
| import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.TuringInputEncoding | |
| import Mathlib.Computability.Halting | |
| namespace OAI | |
| /-! One fixed finite interpreter and a computable input encoding. Arbitrary | |
| partial-recursive programs enter as input data, not as varying machine tables. -/ | |
| namespace ForcedComputation.FiniteMachine | |
| open Turing Alternating | |
| theorem exists_universal_list_code : | |
| ∃ c : ToPartrec.Code, ∀ n : ℕ, | |
| (c.eval [n]).Dom ↔ ((Denumerable.ofNat Nat.Partrec.Code n).eval 0).Dom := by | |
| have hf : Partrec (fun n : ℕ => (Denumerable.ofNat Nat.Partrec.Code n).eval 0) := | |
| Nat.Partrec.Code.eval_part.comp (Computable.ofNat _) (Computable.const 0) | |
| obtain ⟨c, hc⟩ := ToPartrec.Code.exists_code (Nat.Partrec'.part_iff₁.mpr hf) | |
| refine ⟨c, fun n => ?_⟩ | |
| have h := congrArg Part.Dom (hc ⟨[n], rfl⟩) | |
| exact iff_of_eq h | |
| theorem fixed_list_TM0 (c : ToPartrec.Code) : | |
| ∃ g q : ℕ, ∃ M : TM0.Machine (Fin (g + 1)) (Fin (q + 1)), | |
| ∃ input : List ℕ → List (Fin (g + 1)), | |
| Computable input ∧ ∀ v, (TM0.eval M (input v)).Dom ↔ (c.eval v).Dom := by | |
| classical | |
| let : Inhabited PartrecToTM2.Λ' := | |
| ⟨PartrecToTM2.trNormal c PartrecToTM2.Cont'.halt⟩ | |
| let : Fintype PartrecToTM2.K' := | |
| ⟨{.main, .rev, .aux, .stack}, by intro k; cases k <;> simp⟩ | |
| let Γ : Type := TM2to1.Γ' PartrecToTM2.K' (fun _ => PartrecToTM2.Γ') | |
| let m₁ := TM2to1.tr PartrecToTM2.tr | |
| let m₀ := TM1to0.tr m₁ | |
| let S₁ := TM2to1.trSupp PartrecToTM2.tr | |
| (PartrecToTM2.codeSupp c PartrecToTM2.Cont'.halt) | |
| have hs₁ : TM1.Supports m₁ S₁ := | |
| TM2to1.tr_supports _ (PartrecToTM2.tr_supports c PartrecToTM2.Cont'.halt) | |
| have hs₀ := TM1to0.tr_supports m₁ hs₁ | |
| obtain ⟨g, q, N, e, he, hN⟩ := finite_supported_TM0 m₀ | |
| (TM1to0.trStmts m₁ S₁) hs₀ | |
| let : Primcodable PartrecToTM2.Γ' := | |
| Primcodable.ofEquiv (Fin (Fintype.card PartrecToTM2.Γ')) | |
| (Fintype.equivFin PartrecToTM2.Γ') | |
| let : Primcodable Γ := Primcodable.ofEquiv (Fin (g + 1)) e | |
| let input : List ℕ → List (Fin (g + 1)) := fun v => | |
| (TM2to1.trInit PartrecToTM2.K'.main (PartrecToTM2.trList v)).map e | |
| have hin : Computable input := by | |
| apply Primrec.to_comp | |
| exact Primrec.list_map | |
| ((trInit_primrec PartrecToTM2.K'.main).comp trList_primrec) | |
| ((Primrec.dom_finite (fun a : Γ => e a)).comp Primrec.snd).to₂ | |
| refine ⟨g, q, N, input, hin, fun v => ?_⟩ | |
| change (TM0.eval N ((TM2to1.trInit PartrecToTM2.K'.main | |
| (PartrecToTM2.trList v)).map e)).Dom ↔ _ | |
| apply (hN _).trans | |
| rw [TM1to0.tr_eval] | |
| apply (TM2to1.tr_eval_dom (M := PartrecToTM2.tr) | |
| PartrecToTM2.K'.main (PartrecToTM2.trList v)).trans | |
| have hi : (TM2.init PartrecToTM2.K'.main (PartrecToTM2.trList v) : | |
| TM2.Cfg (fun _ : PartrecToTM2.K' => PartrecToTM2.Γ') | |
| PartrecToTM2.Λ' (Option PartrecToTM2.Γ')) = PartrecToTM2.init c v := by | |
| unfold TM2.init PartrecToTM2.init | |
| congr 1 | |
| funext k | |
| cases k <;> rfl | |
| change (StateTransition.eval (TM2.step PartrecToTM2.tr) | |
| (TM2.init PartrecToTM2.K'.main (PartrecToTM2.trList v))).Dom ↔ _ | |
| rw [hi, PartrecToTM2.tr_eval] | |
| rfl | |
| theorem exists_fixed_universal_TM0 : | |
| ∃ g q : ℕ, ∃ M : TM0.Machine (Fin (g + 1)) (Fin (q + 1)), | |
| ∃ input : ℕ → List (Fin (g + 1)), | |
| Computable input ∧ ∀ n, (TM0.eval M (input n)).Dom ↔ | |
| ((Denumerable.ofNat Nat.Partrec.Code n).eval 0).Dom := by | |
| obtain ⟨c, hc⟩ := exists_universal_list_code | |
| obtain ⟨g, q, M, input, hi, hM⟩ := fixed_list_TM0 c | |
| refine ⟨g, q, M, fun n => input [n], hi.comp ?_, fun n => (hM [n]).trans (hc n)⟩ | |
| exact Computable.list_cons.comp Computable.id (Computable.const []) | |
| theorem exists_fixed_universal_machine : | |
| ∃ M : Machine, ∃ input : ℕ → List ℕ, | |
| Computable input ∧ ∀ n, | |
| ValidInput (M, input n) ∧ | |
| (Halts (M, input n) ↔ ((Denumerable.ofNat Nat.Partrec.Code n).eval 0).Dom) := by | |
| obtain ⟨g, q, M, input, hi, hM⟩ := exists_fixed_universal_TM0 | |
| have hv : Computable (fun w : List (Fin (g + 1)) => w.map Fin.val) := | |
| (Primrec.list_map Primrec.id | |
| ((Primrec.dom_finite Fin.val).comp Primrec.snd).to₂).to_comp | |
| refine ⟨compileTM0 M, fun n => (input n).map Fin.val, | |
| hv.comp hi, fun n => ⟨compileTM0Input_valid M (input n), ?_⟩⟩ | |
| exact (compileTM0_halts_iff M (input n)).trans (hM n) | |
| end ForcedComputation.FiniteMachine | |
| end OAI | |