| 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 |
|
|
