| import OAI.Computability.RationalHitting.StackSimulation |
|
|
| namespace OAI |
|
|
| namespace RationalHitting.StackLanguage.Compiler |
| open Turing RationalHitting.TMTime |
| open scoped BigOperators |
| variable {K : Type} [DecidableEq K] |
|
|
| noncomputable def stackConstant (p : Program K) : ℕ := |
| 1 + ∑ l ∈ support p, (StackToOne.stackWeight (machine p l)+1) |
|
|
| lemma stackConstant_bound (p : Program K) (l : Labels K) (hl : l∈support p) : |
| StackToOne.stackWeight (machine p l)+1 ≤ stackConstant p := by |
| have hh : StackToOne.stackWeight (machine p l)+1 ≤ ∑ j ∈ support p, (StackToOne.stackWeight (machine p j)+1) := |
| Finset.single_le_sum (f:=fun j => StackToOne.stackWeight (machine p j)+1) (fun _ _ => Nat.zero_le _) hl |
| unfold stackConstant |
| omega |
|
|
| abbrev TapeAlphabet (K : Type) := TM2to1.Γ' K (fun _ => Bool) |
| abbrev TapeLabels (K : Type) := TM2to1.Λ' K (fun _ => Bool) (Labels K) (Option Bool) |
| noncomputable def tapeSupport (p : Program K) : Finset (TapeLabels K) := |
| TM2to1.trSupp (machine p) (support p) |
| noncomputable def tapeConstant (p : Program K) : ℕ := by |
| classical |
| exact 1+∑ l ∈ tapeSupport p, OneToZero.weight (TM2to1.tr (machine p) l) |
|
|
| lemma tapeConstant_bound (p : Program K) (l : TapeLabels K) (hl : l∈tapeSupport p) : |
| OneToZero.weight (TM2to1.tr (machine p) l) ≤ tapeConstant p := by |
| classical |
| have hh : OneToZero.weight (TM2to1.tr (machine p) l) ≤ ∑ j ∈ tapeSupport p, OneToZero.weight (TM2to1.tr (machine p) j) := |
| Finset.single_le_sum (f:=fun j => OneToZero.weight (TM2to1.tr (machine p) j)) (fun _ _ => Nat.zero_le _) hl |
| unfold tapeConstant |
| omega |
|
|
| lemma tapeSupported (p : Program K) : |
| TM1.Supports (TM2to1.tr (machine p)) (tapeSupport p) := |
| TM2to1.tr_supports (machine p) (machine_supported p) |
|
|
| /-- A single finite-state TM0, independent of the input word, with |
| quadratic cost in stack execution time plus input length. The output |
| is the encoded family of stacks. -/ |
| theorem finite_compilation (p : Program K) : |
| ∃ (m : ℕ) (G : TM0.Machine (TapeAlphabet K) (Fin (m+1))) (C : ℕ), 0<C ∧ |
| ∀ (k : K) (w : List Bool) (v : Store K) (t : ℕ), |
| Eval p (Function.update (fun _ => []) k w) v t → |
| ∃ u ≤ C*(w.length+t+3)^2, ∃ a, |
| exec (TM0.step G) u (TM0.init (TM2to1.trInit k w))=some a ∧ |
| TM0.step G a=none ∧ |
| ∃ b : TM1.Cfg (TapeAlphabet K) (TapeLabels K) (Option Bool), |
| TM2to1.TrCfg (⟨none,none,v⟩ : TM2.Cfg (fun _ : K => Bool) (Labels K) (Option Bool)) b ∧ |
| a.Tape=b.Tape := by |
| classical |
| let M := TM2to1.tr (machine p) |
| let S := TM1to0.trStmts M (tapeSupport p) |
| have hs : TM0.Supports (TM1to0.tr M) (S : Set (TM1to0.Λ' M)) := |
| TM1to0.tr_supports M (tapeSupported p) |
| obtain ⟨m,G,hG⟩ := FiniteStates.finite_machine (TM1to0.tr M) S hs |
| let A := stackConstant p |
| let B := tapeConstant p |
| have hA : 1≤A := by simp [A,stackConstant] |
| have hB : 1≤B := by simp [B,tapeConstant] |
| refine ⟨m,G,10*B*(A+1)^2,by positivity,?_⟩ |
| intro k w v t he |
| have hr := complete_run he |
| let a₂ : TM2.Cfg (fun _ : K => Bool) (Labels K) (Option Bool) := TM2.init k w |
| let b₂ : TM2.Cfg (fun _ : K => Bool) (Labels K) (Option Bool) := ⟨none,none,v⟩ |
| let a₁ : TM1.Cfg (TapeAlphabet K) (TapeLabels K) (Option Bool) := TM1.init (TM2to1.trInit k w) |
| have hr' : exec (TM2.step (machine p)) (t+2) a₂=some b₂ := hr |
| have hlen : ∀ j, (a₂.stk j).length ≤ w.length := by |
| intro j |
| simp only [a₂,TM2.init] |
| by_cases hj : j=k <;> simp [hj] |
| obtain ⟨u,b,hu,htr,hx⟩ := StackToOne.execution_time (machine p) (support p) |
| (machine_supported p) A (stackConstant_bound p) (t+2) a₂ b₂ a₁ w.length |
| (Finset.some_mem_insertNone.mpr (machine_supported p).1) hlen (TM2to1.trCfg_init (Γ:=fun _ : K => Bool) (Λ:=Labels K) (σ:=Option Bool) k w) hr' |
| have hhal : TM1.step M b=none := StackToOne.halts (machine p) b₂ b htr rfl |
| obtain ⟨u',hu',hx'⟩ := OneToZero.execution_time M (tapeSupport p) (tapeSupported p) |
| B (tapeConstant_bound p) u a₁ b |
| (Finset.some_mem_insertNone.mpr (tapeSupported p).1) hx |
| have hinit : TM1to0.trCfg M a₁=TM0.init (TM2to1.trInit k w) := rfl |
| rw [hinit] at hx' |
| obtain ⟨a,ha,hh,htape⟩ := hG (TM2to1.trInit k w) u' (TM1to0.trCfg M b) hx' |
| (OneToZero.halts M b hhal) |
| refine ⟨u',?_,a,ha,hh,b,htr,htape⟩ |
| have hx₁ : t+2≤w.length+t+3 := by omega |
| have hx₂ : w.length+A*(t+2)≤(A+1)*(w.length+t+3) := by nlinarith only [Nat.zero_le (A*w.length)] |
| have hx₃ : 2*(w.length+A*(t+2))+4≤4*(A+1)*(w.length+t+3) := by nlinarith only [hx₂,hA,Nat.zero_le w.length,Nat.zero_le t] |
| calc u' ≤ B*u := hu' |
| _ ≤ B*(A*(t+2)*(2*(w.length+A*(t+2))+4)) := Nat.mul_le_mul_left _ hu |
| _ ≤ B*(A*(w.length+t+3)*(4*(A+1)*(w.length+t+3))) := |
| Nat.mul_le_mul_left _ (Nat.mul_le_mul (Nat.mul_le_mul_left _ hx₁) hx₃) |
| _ ≤ 10*B*(A+1)^2*(w.length+t+3)^2 := by nlinarith [Nat.zero_le (B*(w.length+t+3)^2)] |
|
|
| end RationalHitting.StackLanguage.Compiler |
|
|
| namespace RationalHitting.TMTime.Alphabet |
| open Turing |
| open TM1 TM1to1 |
| variable {Γ Λ σ : Type*} [Inhabited Γ] |
| variable {n : ℕ} (enc : Γ → List.Vector Bool n) (dec : List.Vector Bool n → Γ) |
| variable (enc0 : enc default = List.Vector.replicate n false) |
| variable (encdec : ∀ a, dec (enc a) = a) |
|
|
| /-- Number of deferred writes along the longest branch. -/ |
| def writesWeight : TM1.Stmt Γ Λ σ → ℕ |
| | .move _ q | .load _ q => writesWeight q |
| | .write _ q => writesWeight q+1 |
| | .branch _ q r => max (writesWeight q) (writesWeight r) |
| | .goto _ | .halt => 0 |
|
|
| include encdec |
|
|
| /-- Alphabet coding adds at most one macrostep per deferred write. -/ |
| theorem continuation_time (M : Λ → TM1.Stmt Γ Λ σ) (q : TM1.Stmt Γ Λ σ) |
| (v : σ) (L R : ListBlank Γ) : |
| ∃ t ≤ writesWeight q, |
| exec (TM1.step (TM1to1.tr enc dec M)) t |
| (TM1.stepAux (TM1to1.trNormal dec q) v (TM1to1.trTape' enc0 L R)) = |
| some (TM1to1.trCfg enc enc0 (TM1.stepAux q v (Tape.mk' L R))) := by |
| induction q generalizing v L R with |
| | move d q ih => |
| cases d <;> |
| simp only [trNormal,stepAux_move,stepAux,Tape.move_left_mk',Tape.move_right_mk', |
| trTape'_move_left enc0,trTape'_move_right enc0,writesWeight] <;> apply ih |
| | write f q ih => |
| simp only [trNormal,stepAux_read dec enc0 encdec,stepAux] |
| obtain ⟨a,R,rfl⟩ := R.exists_cons |
| obtain ⟨t,ht,he⟩ := ih v L (R.cons (f a v)) |
| refine ⟨t+1,by simpa [writesWeight] using Nat.add_le_add_right ht 1,?_⟩ |
| rw [exec] |
| simp only [TM1.step,Option.bind_some,TM1to1.tr,Tape.mk'_head,ListBlank.head_cons, |
| stepAux_write,stepAux_move,trTape'_move_left enc0,ListBlank.head_cons, |
| ListBlank.tail_cons] |
| simpa only [Tape.write_mk',trTape_mk',ListBlank.cons_head_tail,ListBlank.tail_cons] using he |
| | load f q ih => |
| simp only [trNormal,stepAux_read dec enc0 encdec,stepAux,Tape.mk'_head,writesWeight] |
| apply ih |
| | branch p q r ihq ihr => |
| simp only [trNormal,stepAux_read dec enc0 encdec,stepAux,Tape.mk'_head] |
| cases h : p R.head v with |
| | false => |
| simp only [Bool.cond_false] |
| obtain ⟨t,ht,he⟩ := ihr v L R |
| exact ⟨t,ht.trans (Nat.le_max_right _ _),he⟩ |
| | true => |
| simp only [Bool.cond_true] |
| obtain ⟨t,ht,he⟩ := ihq v L R |
| exact ⟨t,ht.trans (Nat.le_max_left _ _),he⟩ |
| | goto f => |
| refine ⟨0,by simp [writesWeight],?_⟩ |
| simp only [exec,trNormal,stepAux_read dec enc0 encdec,stepAux,trCfg,trTape_mk',Option.map_some,Tape.mk'_head] |
| | halt => |
| refine ⟨0,by simp [writesWeight],?_⟩ |
| simp only [exec,trNormal,stepAux,trCfg,trTape_mk',Option.map_none] |
|
|
| /-- Linear macrostep time overhead for the finite-alphabet compiler. Physical |
| moves and reads are subsequently counted by the quantitative TM1->TM0 compiler. -/ |
| theorem execution_time [Inhabited Λ] (M : Λ → TM1.Stmt Γ Λ σ) (S : Finset Λ) |
| (hs : TM1.Supports M S) (C : ℕ) (hC : ∀ l ∈ S, writesWeight (M l)+1 ≤ C) |
| (t : ℕ) (a b : TM1.Cfg Γ Λ σ) (ha : a.l ∈ Finset.insertNone S) |
| (hr : exec (TM1.step M) t a = some b) : |
| ∃ u ≤ C*t, exec (TM1.step (TM1to1.tr enc dec M)) u |
| (TM1to1.trCfg enc enc0 a) = some (TM1to1.trCfg enc enc0 b) := by |
| induction t generalizing a with |
| | zero => |
| simp only [exec,Option.some.injEq] at hr |
| subst b |
| exact ⟨0,by omega,rfl⟩ |
| | succ t ih => |
| obtain ⟨l,v,T⟩ := a |
| cases l with |
| | none => simp [exec,TM1.step] at hr |
| | some l => |
| obtain ⟨L,R,rfl⟩ := T.exists_mk' |
| have hl : l ∈ S := Finset.some_mem_insertNone.mp ha |
| have hn : (TM1.stepAux (M l) v (Tape.mk' L R)).l ∈ Finset.insertNone S := |
| TM1.step_supports M hs (by rfl) ha |
| change exec (TM1.step M) t (TM1.stepAux (M l) v (Tape.mk' L R)) = some b at hr |
| obtain ⟨u,hu,he⟩ := ih _ hn hr |
| obtain ⟨w,hw,hwx⟩ := continuation_time enc dec enc0 encdec M (M l) v L R |
| have hx : exec (TM1.step (TM1to1.tr enc dec M)) (w+1) |
| (TM1to1.trCfg enc enc0 ⟨some l,v,Tape.mk' L R⟩) = |
| some (TM1to1.trCfg enc enc0 (TM1.stepAux (M l) v (Tape.mk' L R))) := by |
| simpa only [exec,TM1.step,trCfg,Option.map_some,Option.bind_some,tr,trTape_mk'] using hwx |
| refine ⟨(w+1)+u,?_,exec_trans hx he⟩ |
| have hb := hC l hl |
| nlinarith |
|
|
| omit encdec in |
| theorem halts.{v_1, v_2, v_3} {Γ : Type v_1} {Λ : Type v_2} {σ : Type v_3} |
| [Inhabited Γ] {n : ℕ} (enc : Γ → List.Vector Bool n) (dec : List.Vector Bool n → Γ) |
| (enc0 : enc default = List.Vector.replicate n false) (_encdec : ∀ (a : Γ), dec (enc a) = a) |
| (M : Λ → Turing.TM1.Stmt Γ Λ σ) (a : Turing.TM1.Cfg Γ Λ σ) (ha : Turing.TM1.step M a = none) : |
| Turing.TM1.step (Turing.TM1to1.tr enc dec M) (Turing.TM1to1.trCfg enc enc0 a) = none := by |
| rcases a with ⟨l,v,T⟩ |
| cases l <;> simp_all [TM1.step,trCfg] |
|
|
| end RationalHitting.TMTime.Alphabet |
|
|
| namespace RationalHitting.TMTime.Alphabet |
| open Turing |
| lemma compiled_init {Γ Λ σ : Type*} [Inhabited Γ] [Inhabited Λ] [Inhabited σ] |
| {b : ℕ} (enc : Γ → List.Vector Bool b) (h0 : enc default=List.Vector.replicate b false) |
| (w : List Γ) : |
| TM1to1.trCfg enc h0 (TM1.init w : TM1.Cfg Γ Λ σ)= |
| TM1.init (w.flatMap (fun a => (enc a).toList)) := by |
| simp [TM1to1.trCfg,TM1.init,Tape.mk₁,Tape.mk₂,TM1to1.trTape_mk',TM1to1.trTape'] |
| rfl |
| end RationalHitting.TMTime.Alphabet |
|
|
| namespace RationalHitting.StackLanguage.Compiler |
| open Turing RationalHitting.TMTime |
| open scoped BigOperators |
| variable {K : Type} [DecidableEq K] [Fintype K] |
|
|
| /- The alphabet is finite because the number of stacks is fixed. -/ |
| noncomputable instance finiteTapeAlphabet : Fintype (TapeAlphabet K) := by |
| unfold TapeAlphabet TM2to1.Γ' |
| infer_instance |
|
|
| /-- Polynomial-time compilation to a binary finite-state TM0, |
| preserving an explicit fixed block encoding. -/ |
|
|
| theorem binary_compilation (p : Program K) : |
| ∃ (b : ℕ) (enc : TapeAlphabet K → List.Vector Bool b) |
| (dec : List.Vector Bool b → TapeAlphabet K) |
| (h0 : enc default=List.Vector.replicate b false), |
| (∀ a,dec (enc a)=a) ∧ |
| ∃ (m : ℕ) (G : TM0.Machine Bool (Fin (m+1))) (C : ℕ), 0<C ∧ |
| ∀ (k : K) (w : List Bool) (v : Store K) (t : ℕ), |
| Eval p (Function.update (fun _ => []) k w) v t → |
| ∃ u ≤ C*(w.length+t+3)^2, ∃ a, |
| exec (TM0.step G) u (TM0.init ((TM2to1.trInit k w).flatMap (fun z => (enc z).toList)))=some a ∧ |
| TM0.step G a=none ∧ |
| ∃ c : TM1.Cfg (TapeAlphabet K) (TapeLabels K) (Option Bool), |
| TM2to1.TrCfg (⟨none,none,v⟩ : TM2.Cfg (fun _ : K => Bool) (Labels K) (Option Bool)) c ∧ |
| a.Tape=TM1to1.trTape h0 c.Tape := by |
| classical |
| obtain ⟨b,enc,dec,h0,hd⟩ := TM1to1.exists_enc_dec (Γ:=TapeAlphabet K) |
| let M := TM2to1.tr (machine p) |
| let F := tapeSupport p |
| have hF : TM1.Supports M F := tapeSupported p |
| let N := TM1to1.tr enc dec M |
| let H := TM1to1.trSupp M F |
| have hH : TM1.Supports N H := TM1to1.tr_supports enc dec M hF |
| let A := stackConstant p |
| let B := 1+∑ l ∈ F, (Alphabet.writesWeight (M l)+1) |
| let D := 1+∑ l ∈ H, OneToZero.weight (N l) |
| have hA : 1≤A := by simp [A,stackConstant] |
| have hB : 1≤B := by simp [B] |
| have hD : 1≤D := by simp [D] |
| have hbnd : ∀ l ∈ F, Alphabet.writesWeight (M l)+1≤B := by |
| intro l hl |
| have hh := Finset.single_le_sum (f:=fun j => Alphabet.writesWeight (M j)+1) |
| (fun _ _ => Nat.zero_le _) hl |
| exact hh.trans (Nat.le_add_left _ _) |
| have hdnd : ∀ l ∈ H, OneToZero.weight (N l)≤D := by |
| intro l hl |
| have hh := Finset.single_le_sum (f:=fun j => OneToZero.weight (N j)) |
| (fun _ _ => Nat.zero_le _) hl |
| exact hh.trans (Nat.le_add_left _ _) |
| let S := TM1to0.trStmts N H |
| have hs : TM0.Supports (TM1to0.tr N) (S : Set (TM1to0.Λ' N)) := TM1to0.tr_supports N hH |
| obtain ⟨m,G,hG⟩ := FiniteStates.finite_machine (TM1to0.tr N) S hs |
| refine ⟨b,enc,dec,h0,hd,m,G,10*D*B*(A+1)^2,by positivity,?_⟩ |
| intro k w v t he |
| let a₂ : TM2.Cfg (fun _ : K => Bool) (Labels K) (Option Bool) := TM2.init k w |
| let b₂ : TM2.Cfg (fun _ : K => Bool) (Labels K) (Option Bool) := ⟨none,none,v⟩ |
| let a₁ : TM1.Cfg (TapeAlphabet K) (TapeLabels K) (Option Bool) := TM1.init (TM2to1.trInit k w) |
| have hr : exec (TM2.step (machine p)) (t+2) a₂=some b₂ := complete_run he |
| have hlen : ∀ j, (a₂.stk j).length≤w.length := by |
| intro j |
| simp only [a₂,TM2.init] |
| by_cases hj : j=k <;> simp [hj] |
| obtain ⟨u,c,hu,htr,hx⟩ := StackToOne.execution_time (machine p) (support p) |
| (machine_supported p) A (stackConstant_bound p) (t+2) a₂ b₂ a₁ w.length |
| (Finset.some_mem_insertNone.mpr (machine_supported p).1) hlen |
| (TM2to1.trCfg_init (Γ:=fun _ : K => Bool) (Λ:=Labels K) (σ:=Option Bool) k w) hr |
| have hhal : TM1.step M c=none := StackToOne.halts (machine p) b₂ c htr rfl |
| obtain ⟨u',hu',hx'⟩ := Alphabet.execution_time enc dec h0 hd M F hF B hbnd u a₁ c |
| (Finset.some_mem_insertNone.mpr hF.1) hx |
| have hi : TM1to1.trCfg enc h0 a₁ = |
| TM1.init ((TM2to1.trInit k w).flatMap (fun z => (enc z).toList)) := |
| Alphabet.compiled_init enc h0 _ |
| rw [hi] at hx' |
| have hh' := Alphabet.halts enc dec h0 hd M c hhal |
| obtain ⟨u'',hu'',hx''⟩ := OneToZero.execution_time N H hH D hdnd u' |
| (TM1.init ((TM2to1.trInit k w).flatMap (fun z => (enc z).toList))) |
| (TM1to1.trCfg enc h0 c) (Finset.some_mem_insertNone.mpr hH.1) hx' |
| have hz : TM1to0.trCfg N (TM1.init ((TM2to1.trInit k w).flatMap (fun z => (enc z).toList)))= |
| TM0.init ((TM2to1.trInit k w).flatMap (fun z => (enc z).toList)) := rfl |
| rw [hz] at hx'' |
| obtain ⟨a,ha,hh,htape⟩ := hG _ u'' _ hx'' (OneToZero.halts N _ hh') |
| refine ⟨u'',?_,a,ha,hh,c,htr,htape⟩ |
| have hx₁ : t+2≤w.length+t+3 := by omega |
| have hx₂ : w.length+A*(t+2)≤(A+1)*(w.length+t+3) := by nlinarith only [Nat.zero_le (A*w.length)] |
| have hx₃ : 2*(w.length+A*(t+2))+4≤4*(A+1)*(w.length+t+3) := by nlinarith only [hx₂,hA,Nat.zero_le w.length,Nat.zero_le t] |
| calc u'' ≤ D*u' := hu'' |
| _ ≤ D*(B*u) := Nat.mul_le_mul_left _ hu' |
| _ ≤ D*(B*(A*(t+2)*(2*(w.length+A*(t+2))+4))) := Nat.mul_le_mul_left _ (Nat.mul_le_mul_left _ hu) |
| _ ≤ D*(B*(A*(w.length+t+3)*(4*(A+1)*(w.length+t+3)))) := |
| Nat.mul_le_mul_left _ (Nat.mul_le_mul_left _ (Nat.mul_le_mul (Nat.mul_le_mul_left _ hx₁) hx₃)) |
| _ ≤ 10*D*B*(A+1)^2*(w.length+t+3)^2 := by nlinarith [Nat.zero_le (D*B*(w.length+t+3)^2)] |
|
|
| end RationalHitting.StackLanguage.Compiler |
|
|
| namespace RationalHitting.TMTime.OneToZero |
| open Turing |
| open scoped BigOperators |
|
|
| lemma supports_univ {Γ Λ σ : Type*} [Fintype Λ] (q : TM1.Stmt Γ Λ σ) : |
| TM1.SupportsStmt Finset.univ q := by |
| induction q <;> simp_all [TM1.SupportsStmt] |
|
|
| /-- Every fixed finite-control TM1 has an ordinary finite-state TM0 compiling |
| all runs at a fixed linear cost and preserving the literal tape. -/ |
| theorem finite_compiler {Γ Λ σ : Type*} [Inhabited Γ] [Inhabited Λ] [Inhabited σ] |
| [Fintype Λ] [Fintype σ] (M : Λ → TM1.Stmt Γ Λ σ) : |
| ∃ (m : ℕ) (G : TM0.Machine Γ (Fin (m+1))) (C : ℕ), 0<C ∧ |
| ∀ (w : List Γ) (t : ℕ) (a : TM1.Cfg Γ Λ σ), |
| exec (TM1.step M) t (TM1.init w)=some a → TM1.step M a=none → |
| ∃ u≤C*t, ∃ b : TM0.Cfg Γ (Fin (m+1)), |
| exec (TM0.step G) u (TM0.init w)=some b ∧ TM0.step G b=none ∧ b.Tape=a.Tape := by |
| classical |
| let F : Finset Λ := Finset.univ |
| have hs : TM1.Supports M F := ⟨Finset.mem_univ _,fun q _ => supports_univ (M q)⟩ |
| let S := TM1to0.trStmts M F |
| have hs' : TM0.Supports (TM1to0.tr M) (S : Set (TM1to0.Λ' M)) := TM1to0.tr_supports M hs |
| obtain ⟨m,G,hG⟩ := FiniteStates.finite_machine (TM1to0.tr M) S hs' |
| let C := 1+∑ q∈F, weight (M q) |
| have hC : ∀ q∈F, weight (M q)≤C := by |
| intro q hq |
| exact (Finset.single_le_sum (f:=fun q => weight (M q)) (fun _ _ => Nat.zero_le _) hq).trans (Nat.le_add_left _ _) |
| refine ⟨m,G,C,by simp [C],?_⟩ |
| intro w t a hr hh |
| obtain ⟨u,hu,hx⟩ := execution_time M F hs C hC t (TM1.init w) a |
| (Finset.some_mem_insertNone.mpr hs.1) hr |
| have hi : TM1to0.trCfg M (TM1.init w)=TM0.init w := rfl |
| rw [hi] at hx |
| obtain ⟨b,hb,hhb,ht⟩ := hG w u _ hx (halts M a hh) |
| exact ⟨u,hu,b,hb,hhb,ht⟩ |
|
|
| end RationalHitting.TMTime.OneToZero |
|
|
| /-! Raw unary input adapter for the finite block-coded stack compiler. |
| The alphabet is exactly Fin 4. No list-processing oracle is an instruction. -/ |
|
|
| end OAI |
|
|
