File size: 4,551 Bytes
37bcf52 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 | 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
|