File size: 3,665 Bytes
e5a97c6 | 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 | import Mathlib
import OAI.Combinatorics.MatchingCount.Arithmetic.BinaryAddition
import OAI.Combinatorics.MatchingCount.Tapes.StackWords
import OAI.Combinatorics.MatchingCount.Tapes.FixedEncoding
namespace OAI
namespace MatchingFPRAS.PostAddition
open Turing StackAddition
local instance initialCarry : Inhabited Bool := ⟨false⟩
abbrev Alphabet := TM2to1.Γ' (Fin 3) (fun _=>Bool)
noncomputable def machine : RandomMachine :=
StackWords.compiled (FixedEncoding.enc Alphabet) (FixedEncoding.dec Alphabet)
program Finset.univ finite_support
noncomputable def overhead : ℕ :=
StackWords.cost (FixedEncoding.enc Alphabet) (FixedEncoding.dec Alphabet)
program Finset.univ
noncomputable def input (A B : List Bool) : List Symbol :=
StackWords.encoded (FixedEncoding.enc Alphabet) (stackData A B []) (A.length+B.length)
noncomputable def output (A B : List Bool) : List Symbol :=
StackWords.encoded (FixedEncoding.enc Alphabet)
(stackData [] [] (addDigits false A B).reverse) (A.length+B.length+1)
noncomputable def steps (A B : List Bool) : ℕ :=
overhead*((A.length+B.length+1)*(1+6*(A.length+B.length+3*(A.length+B.length+1)+1)))+2
theorem computes (A B : List Bool) (t : ℕ) (ht : steps A B≤t) (bits : Fin t → Bool) :
(run machine (input A B) bits).state=none ∧
(run machine (input A B) bits).tape.right₀=ListBlank.mk (output A B) := by
obtain ⟨n,hn,hr⟩:=run_addition A B [] false default
have h₀ : StackCost.StackBound (stackData A B []) (A.length+B.length) := by
intro i
fin_cases i <;> simp [stackData]
have he : MachineCost.run (TM2.step program) n
⟨some (default : Bool),(default : Store),stackData A B []⟩=
cfg none [] [] (addDigits false A B).reverse default := by
change MachineCost.run (TM2.step program) n (cfg (some false) A B [] default)=_
simpa only [List.append_nil] using hr
have hh : (MachineCost.run (TM2.step program) n
⟨some (default : Bool),(default : Store),stackData A B []⟩).l=none := by rw [he]; rfl
have ho : StackCost.StackBound (MachineCost.run (TM2.step program) n
⟨some (default : Bool),(default : Store),stackData A B []⟩).stk (A.length+B.length+1) := by
rw [he]
intro i
have hl:=addDigits_length A B false
fin_cases i <;> simp [cfg,stackData]
omega
have htime : StackWords.cost (FixedEncoding.enc Alphabet) (FixedEncoding.dec Alphabet)
program Finset.univ*(n*(1+2*3*(A.length+B.length+n*3+1)))+2≤t := by
apply le_trans _ ht
unfold steps overhead
apply Nat.add_le_add_right
apply Nat.mul_le_mul_left
apply Nat.mul_le_mul hn
omega
have hc:=StackWords.compiled_execution (FixedEncoding.enc Alphabet)
(FixedEncoding.dec Alphabet) (FixedEncoding.blank Alphabet) (FixedEncoding.left_inverse Alphabet)
program Finset.univ finite_support 3 accesses_bound
(stackData A B []) (A.length+B.length) h₀ n (A.length+B.length+1) hh ho t htime bits
change (run machine (input A B) bits).state=none ∧
(run machine (input A B) bits).tape.right₀=ListBlank.mk
(StackWords.encoded (FixedEncoding.enc Alphabet)
(MachineCost.run (TM2.step program) n
⟨some (default : Bool),(default : Store),stackData A B []⟩).stk
(A.length+B.length+1)) at hc
rw [he] at hc
exact hc
lemma result_value (m n : ℕ) :
value ((addDigits false m.bits n.bits).reverse.reverse)=m+n := by
simpa only [List.reverse_reverse] using addition_numerals m n
lemma time_quadratic (A B : List Bool) :
steps A B=overhead*(24*(A.length+B.length)^2+49*(A.length+B.length)+25)+2 := by
unfold steps
ring
end MatchingFPRAS.PostAddition
end OAI
|