| import OAI.Computability.RationalHitting.OutputAdapter |
|
|
| namespace OAI |
|
|
| namespace RationalHitting.TMTime.Link |
| open Turing |
| variable {Γ Λ Δ : Type*} [Inhabited Γ] [Inhabited Λ] [Inhabited Δ] |
| local instance sumInhabited : Inhabited (Sum Λ Δ) := ⟨Sum.inl default⟩ |
|
|
| def left (a : TM0.Cfg Γ Λ) : TM0.Cfg Γ (Sum Λ Δ) := ⟨Sum.inl a.q,a.Tape⟩ |
| def right (a : TM0.Cfg Γ Δ) : TM0.Cfg Γ (Sum Λ Δ) := ⟨Sum.inr a.q,a.Tape⟩ |
|
|
| def machine (F : TM0.Machine Γ Λ) (G : TM0.Machine Γ Δ) : TM0.Machine Γ (Sum Λ Δ) |
| | .inl q,a => match F q a with |
| | none => some (.inr default,.write a) |
| | some (r,s) => some (.inl r,s) |
| | .inr q,a => (G q a).map (fun (r,s) => (.inr r,s)) |
|
|
| lemma step_left (F : TM0.Machine Γ Λ) (G : TM0.Machine Γ Δ) |
| {a b : TM0.Cfg Γ Λ} (h : TM0.step F a=some b) : |
| TM0.step (machine F G) (left a)=some (left b) := by |
| rcases a with ⟨q,T⟩ |
| simp only [TM0.step] at h |
| cases he : F q T.head with |
| | none => simp [he] at h |
| | some qr => |
| rcases qr with ⟨r,s⟩ |
| simp only [he,Option.map_some,Option.some.injEq] at h |
| subst b |
| cases s <;> simp [TM0.step,machine,left,he] |
| |
| lemma switch (F : TM0.Machine Γ Λ) (G : TM0.Machine Γ Δ) |
| {a : TM0.Cfg Γ Λ} (h : TM0.step F a=none) : |
| TM0.step (machine F G) (left a)=some (right (⟨default,a.Tape⟩ : TM0.Cfg Γ Δ)) := by |
| have he : F a.q a.Tape.head=none := Option.map_eq_none_iff.mp h |
| simp [TM0.step,machine,left,right,he] |
|
|
| lemma step_right (F : TM0.Machine Γ Λ) (G : TM0.Machine Γ Δ) (a : TM0.Cfg Γ Δ) : |
| TM0.step (machine F G) (right a)=(TM0.step G a).map right := by |
| rcases a with ⟨q,T⟩ |
| simp only [TM0.step,machine,right,Option.map_map] |
| congr 1 |
|
|
| lemma run_left (F : TM0.Machine Γ Λ) (G : TM0.Machine Γ Δ) |
| (t : ℕ) {a b : TM0.Cfg Γ Λ} (h : exec (TM0.step F) t a=some b) : |
| exec (TM0.step (machine F G)) t (left a)=some (left b) := by |
| induction t generalizing a with |
| | zero => simpa only [exec_zero,Option.some.injEq] using congrArg (fun x => left (Δ:=Δ) x) (Option.some.inj h) |
| | succ t ih => |
| obtain ⟨c,hc,hr⟩ := Option.bind_eq_some_iff.mp h |
| simp only [exec,step_left F G hc,Option.bind_some] |
| exact ih hr |
|
|
| lemma run_right (F : TM0.Machine Γ Λ) (G : TM0.Machine Γ Δ) |
| (t : ℕ) (a : TM0.Cfg Γ Δ) : |
| exec (TM0.step (machine F G)) t (right a)=(exec (TM0.step G) t a).map right := by |
| induction t generalizing a with |
| | zero => rfl |
| | succ t ih => |
| simp only [exec,step_right] |
| cases TM0.step G a <;> simp [ih] |
| |
| /-- Splice two halting finite transducers with exactly one glue step. The |
| intermediate output is the literal tape required by the second input. -/ |
| theorem finite_sequence [Fintype Λ] [Fintype Δ] |
| (F : TM0.Machine Γ Λ) (G : TM0.Machine Γ Δ) : |
| ∃ (m : ℕ) (H : TM0.Machine Γ (Fin (m+1))), |
| ∀ (w v : List Γ) (t u : ℕ) (a : TM0.Cfg Γ Λ) (b : TM0.Cfg Γ Δ), |
| exec (TM0.step F) t (TM0.init w)=some a → TM0.step F a=none → |
| a.Tape=Tape.mk₁ v → exec (TM0.step G) u (TM0.init v)=some b → TM0.step G b=none → |
| ∃ c, exec (TM0.step H) (t+1+u) (TM0.init w)=some c ∧ TM0.step H c=none ∧ c.Tape=b.Tape := by |
| classical |
| let S : Finset (Sum Λ Δ) := Finset.univ |
| have hs : TM0.Supports (machine F G) (S : Set (Sum Λ Δ)) := by |
| constructor |
| · simp [S] |
| · intro q hq a r s hr |
| simp [S] |
| obtain ⟨m,H,hH⟩ := FiniteStates.finite_machine (machine F G) S hs |
| refine ⟨m,H,?_⟩ |
| intro w v t u a b ha hh ht hb hh' |
| have h1 : exec (TM0.step (machine F G)) t (TM0.init w)=some (left a) := run_left F G t ha |
| have h2 : exec (TM0.step (machine F G)) 1 (left a)=some (right (TM0.init v)) := by |
| simp only [exec,switch F G hh,Option.bind_some,TM0.init,ht] |
| have h3 : exec (TM0.step (machine F G)) u (right (TM0.init v))=some (right b) := by |
| rw [run_right,hb,Option.map_some] |
| have hr := exec_trans (exec_trans h1 h2) h3 |
| exact hH w (t+1+u) (right b) hr (by rw [step_right,hh',Option.map_none]) |
|
|
| end RationalHitting.TMTime.Link |
|
|
| namespace RationalHitting.TMTime.BinaryLift |
| open Turing |
| abbrev A := Fin 4 |
| def bit (b : Bool) : A := if b then 1 else 0 |
| def bitMap : PointedMap Bool A := ⟨bit,rfl⟩ |
| @[simp] lemma bit_read (b : Bool) : (bit b==1)=b := by cases b <;> decide |
| variable {Λ : Type*} [Inhabited Λ] |
| def stmt : TM0.Stmt Bool → TM0.Stmt A |
| | .move d => .move d |
| | .write b => .write (bit b) |
| def machine (F : TM0.Machine Bool Λ) : TM0.Machine A Λ := |
| fun q a => (F q (a==1)).map (fun (r,s) => (r,stmt s)) |
| def cfg (a : TM0.Cfg Bool Λ) : TM0.Cfg A Λ := ⟨a.q,a.Tape.map bitMap⟩ |
| lemma step (F : TM0.Machine Bool Λ) (a : TM0.Cfg Bool Λ) : |
| TM0.step (machine F) (cfg a)=(TM0.step F a).map cfg := by |
| rcases a with ⟨q,T⟩ |
| simp only [cfg,machine,TM0.step,Tape.map_fst,bitMap,bit_read,Option.map_map] |
| congr 1 |
| funext ⟨r,s⟩ |
| cases s <;> simp only [Function.comp_apply,stmt,cfg,Tape.map_move,Tape.map_write,bitMap] |
| lemma run (F : TM0.Machine Bool Λ) (t : ℕ) (a : TM0.Cfg Bool Λ) : |
| exec (TM0.step (machine F)) t (cfg a)=(exec (TM0.step F) t a).map cfg := by |
| induction t generalizing a with |
| | zero => rfl |
| | succ t ih => |
| simp only [exec,step] |
| cases TM0.step F a <;> simp [ih] |
| |
| lemma run_init (F : TM0.Machine Bool Λ) (w : List Bool) (t : ℕ) (a : TM0.Cfg Bool Λ) |
| (hr : exec (TM0.step F) t (TM0.init w)=some a) (hh : TM0.step F a=none) : |
| exec (TM0.step (machine F)) t (TM0.init (w.map bit))=some (cfg a) ∧ |
| TM0.step (machine F) (cfg a)=none := by |
| have hi : cfg (Λ:=Λ) (TM0.init w)=TM0.init (w.map bit) := by |
| simp only [cfg,TM0.init,Tape.map_mk₁,bitMap] |
| constructor |
| · rw [←hi,run,hr,Option.map_some] |
| · rw [step,hh,Option.map_none] |
| end RationalHitting.TMTime.BinaryLift |
|
|
| namespace RationalHitting.TMTime.Alphabet |
| open Turing |
| lemma tape_init {Γ : Type*} [Inhabited Γ] {b : ℕ} |
| (enc : Γ → List.Vector Bool b) (h0 : enc default=List.Vector.replicate b false) (w : List Γ) : |
| TM1to1.trTape h0 (Tape.mk₁ w)=Tape.mk₁ (w.flatMap (fun a => (enc a).toList)) := by |
| exact congrArg TM1.Cfg.Tape (compiled_init (Λ:=Unit) (σ:=Unit) enc h0 w) |
| end RationalHitting.TMTime.Alphabet |
|
|
| namespace RationalHitting.StackLanguage.Compiler |
| open Turing RationalHitting.TMTime |
| variable {K : Type} [DecidableEq K] [Fintype K] |
|
|
| /-- End-to-end, finite-state, Fin4 one-tape compilation. Input and output are |
| literal 1/2 digit strings, NOT different encodings hidden by an interface. The |
| stack program is a single fixed finite syntax tree. Final scratch must be empty; |
| the designated output stack has reversed output order, as explicitly stated. -/ |
| theorem raw_compilation (p : Program K) (ki ko : K) : |
| ∃ (m : ℕ) (G : TM0.Machine (Fin 4) (Fin (m+1))) (C : ℕ), 0<C ∧ |
| ∀ (w xs : List Bool) (t : ℕ), w≠[] → |
| Eval p (Function.update (fun _ => []) ki w) |
| (Function.update (fun _ => []) ko xs.reverse) t → |
| ∃ u≤C*(w.length+t+xs.length+3)^2, ∃ a, |
| exec (TM0.step G) u (TM0.init (w.map InputAdapter.raw))=some a ∧ |
| TM0.step G a=none ∧ a.Tape=Tape.mk₁ (xs.map OutputAdapter.raw) := by |
| classical |
| obtain ⟨b,enc,dec,h0,hd,m₁,F,B,hB,hF⟩ := binary_compilation p |
| obtain ⟨m₀,I,A,hA,hI⟩ := InputAdapter.raw_stack_input ki b enc |
| obtain ⟨m₂,O,D,hD,hO⟩ := OutputAdapter.raw_stack_output ko enc dec h0 hd |
| obtain ⟨m₃,J,hJ⟩ := Link.finite_sequence I (BinaryLift.machine F) |
| obtain ⟨m₄,H,hH⟩ := Link.finite_sequence J O |
| refine ⟨m₄,H,A+B+D+2,by omega,?_⟩ |
| intro w xs t hw he |
| obtain ⟨i,hi,a,ha,hha,hta⟩ := hI w hw |
| obtain ⟨j,hj,c,hc,hhc,e,htr,htc⟩ := hF ki w (Function.update (fun _ => []) ko xs.reverse) t he |
| obtain ⟨hlift,hhlift⟩ := BinaryLift.run_init F _ j c hc hhc |
| have hcle : c.Tape=Tape.mk₁ ((TM2to1.trInit ko xs.reverse).flatMap (fun z => (enc z).toList)) := by |
| rw [htc,StackTape.clean ko xs.reverse htr,Alphabet.tape_init] |
| have hcl : (BinaryLift.cfg c).Tape=Tape.mk₁ |
| (((TM2to1.trInit ko xs.reverse).flatMap (fun z => (enc z).toList)).map InputAdapter.bit) := by |
| simp only [BinaryLift.cfg,hcle,Tape.map_mk₁] |
| rfl |
| obtain ⟨a₃,ha₃,hh₃,ht₃⟩ := hJ (w.map InputAdapter.raw) |
| (((TM2to1.trInit ki w).flatMap (fun z => (enc z).toList)).map InputAdapter.bit) |
| i j a (BinaryLift.cfg c) ha hha hta (by rw [show InputAdapter.bit = BinaryLift.bit from rfl]; exact hlift) hhlift |
| have hxt : a₃.Tape=Tape.mk₁ |
| (((TM2to1.trInit ko xs.reverse).flatMap (fun z => (enc z).toList)).map InputAdapter.bit) := ht₃.trans hcl |
| obtain ⟨k,hk,a₂,ha₂,hh₂,ht₂⟩ := hO xs |
| obtain ⟨a₄,ha₄,hh₄,ht₄⟩ := hH (w.map InputAdapter.raw) |
| (((TM2to1.trInit ko xs.reverse).flatMap (fun z => (enc z).toList)).map InputAdapter.bit) |
| (i+1+j) k a₃ a₂ ha₃ hh₃ hxt ha₂ hh₂ |
| refine ⟨i+1+j+1+k,?_,a₄,ha₄,hh₄,ht₄.trans ht₂⟩ |
| let R := w.length+t+xs.length+3 |
| have hi' : i≤A*R^2 := hi.trans (Nat.mul_le_mul_left A (Nat.pow_le_pow_left (by omega : w.length+1≤R) 2)) |
| have hj' : j≤B*R^2 := hj.trans (Nat.mul_le_mul_left B (Nat.pow_le_pow_left (by omega : w.length+t+3≤R) 2)) |
| have hk' : k≤D*R^2 := hk.trans (Nat.mul_le_mul_left D (Nat.pow_le_pow_left (by omega : xs.length+1≤R) 2)) |
| have hR : 1≤R^2 := one_le_pow₀ (by dsimp [R]; omega) |
| change i+1+j+1+k≤(A+B+D+2)*R^2 |
| nlinarith only [hi',hj',hk',hR] |
| |
| end RationalHitting.StackLanguage.Compiler |
| |
| |
| namespace RationalHitting.ExecutableGenerator |
| open Turing StackLanguage TMTime |
| |
| /-- A fixed finite stack program with literal unary input and exact |
| canonical output, bounded by a fixed polynomial in the input length. -/ |
| |
| def unaryWord (n s : ℕ) : List Bool := |
| List.replicate n true ++ [false] ++ List.replicate s true |
|
|
| def StackImplementation : Prop := |
| ∃ (r : ℕ) (p : Program (Fin (r+1))) (ki ko : Fin (r+1)) (C k : ℕ), |
| 0<C ∧ 0<k ∧ ∀ n s : ℕ, 1 ≤ n → 1 ≤ s → |
| ∃ t≤C*(n+s+1)^k, |
| Eval p (Function.update (fun _ => []) ki (unaryWord n s)) |
| (Function.update (fun _ => []) ko (encoded n s).reverse) t |
|
|
| lemma run_eq_exec {m : ℕ} (G : Machine m) (t : ℕ) (a : Config m) : |
| run G t a = exec (TM0.step G) t a := by |
| induction t generalizing a with |
| | zero => rfl |
| | succ t ih => simp only [run,exec,ih] |
|
|
| lemma unaryWord_raw (n s : ℕ) : (unaryWord n s).map TMTime.InputAdapter.raw = unaryInput n s := by |
| simp [unaryWord,unaryInput,TMTime.InputAdapter.raw] |
|
|
| lemma encoded_raw (n s : ℕ) : (encoded n s).map TMTime.OutputAdapter.raw = |
| (encodeOutput (list n s)).map tapeBit := rfl |
|
|
| lemma compilation_sum_bound (x t y R C A : ℕ) (hx : x≤R) |
| (ht : t≤C*R) (hy : y≤A*R) (hR : 1≤R) : x+t+y+3≤(C+A+4)*R := by |
| nlinarith only [hx, ht, hy, hR] |
|
|
| lemma compilation_square_bound (D C A x E : ℕ) : |
| D*((C+A+4)*x^E)^2 = D*(C+A+4)^2*x^(2*E) := by |
| rw [Nat.mul_pow, ←pow_mul, Nat.mul_comm E 2, Nat.mul_assoc] |
|
|
| /-- The raw compiler preserves literal input/output and gives a fixed |
| finite alphabet and state space with a polynomial transition bound. -/ |
|
|
| theorem implementation_of_stack (h : StackImplementation) : Implementation := by |
| obtain ⟨r,p,ki,ko,C,k,hC,hk,hp⟩ := h |
| obtain ⟨m,G,D,hD,hG⟩ := Compiler.raw_compilation p ki ko |
| let A := PolynomialBounds.outputConstant |
| let E := k+104 |
| refine ⟨m,G,D*(C+A+4)^2,2*E,by positivity,by dsimp [E]; omega,?_⟩ |
| intro n s hn hs |
| obtain ⟨t,ht,he⟩ := hp n s hn hs |
| have hw : unaryWord n s≠[] := by |
| intro heq |
| have hh := congrArg List.length heq |
| simp [unaryWord] at hh |
| obtain ⟨u,hu,a,ha,hhalt,hout⟩ := hG (unaryWord n s) (encoded n s) t hw he |
| have hlen : (unaryWord n s).length=n+s+1 := by simp [unaryWord]; omega |
| have hsize : (encoded n s).length≤A*(n+s+1)^104 := (exact_output n s hn hs).2.1 |
| have hm : 1≤n+s+1 := by omega |
| have hmE : n+s+1≤(n+s+1)^E := by |
| exact (le_refl (n+s+1)).trans (by |
| have hh := Nat.pow_le_pow_right hm (by dsimp [E]; omega : 1≤E) |
| simpa using hh) |
| have ht' : t≤C*(n+s+1)^E := ht.trans (Nat.mul_le_mul_left C |
| (Nat.pow_le_pow_right hm (by dsimp [E]; omega))) |
| have ho' : (encoded n s).length≤A*(n+s+1)^E := hsize.trans (Nat.mul_le_mul_left A |
| (Nat.pow_le_pow_right hm (by dsimp [E]; omega))) |
| have h1 : 1≤(n+s+1)^E := one_le_pow₀ hm |
| have htotal : (unaryWord n s).length+t+(encoded n s).length+3 ≤ |
| (C+A+4)*(n+s+1)^E := by |
| rw [hlen] |
| exact compilation_sum_bound _ _ _ _ _ _ hmE ht' ho' h1 |
| refine ⟨u, hu.trans (le_trans (Nat.mul_le_mul_left D (Nat.pow_le_pow_left htotal 2)) |
| (le_of_eq (compilation_square_bound D C A (n+s+1) E))), a, ?_, hhalt, ?_⟩ |
| · rw [run_eq_exec,←unaryWord_raw] |
| exact ha |
| · rw [hout, encoded_raw] |
| exact Turing.Tape.mk'_right₀ _ _ |
|
|
| end RationalHitting.ExecutableGenerator |
|
|
| end OAI |
|
|
