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 []) 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 []) 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 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