| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Complexity.StackCompilerCost |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.StackAddition |
| open Turing MachineCost |
|
|
| abbrev Stacks := Fin 3 → List Bool |
| abbrev Store := Option Bool × Option Bool |
| def value : List Bool → ℕ |
| | [] => 0 |
| | b::bs => b.toNat+2*value bs |
| def digit (c a b : Bool) : Bool := xor (xor c a) b |
| def carry (c a b : Bool) : Bool := (c && a) || (c && b) || (a && b) |
| lemma digit_identity (c a b : Bool) : |
| (digit c a b).toNat+2*(carry c a b).toNat=c.toNat+a.toNat+b.toNat := by |
| cases c <;> cases a <;> cases b <;> rfl |
|
|
| def addDigits (c : Bool) (A B : List Bool) : List Bool := |
| match A,B with |
| | [],[] => if c then [true] else [] |
| | a::A,[] => digit c a false::addDigits (carry c a false) A [] |
| | [],b::B => digit c false b::addDigits (carry c false b) [] B |
| | a::A,b::B => digit c a b::addDigits (carry c a b) A B |
| termination_by A.length+B.length |
|
|
| lemma addDigits_value (A B : List Bool) (c : Bool) : |
| value (addDigits c A B)=value A+value B+c.toNat := by |
| induction A generalizing B c with |
| | nil => |
| induction B generalizing c with |
| | nil => cases c <;> simp [addDigits,value] |
| | cons b B ih => |
| rw [addDigits] |
| simp only [value] |
| rw [ih] |
| have h:=digit_identity c false b |
| simp only [Bool.toNat_false,Nat.add_zero] at h |
| simp only [value] |
| omega |
| | cons a A ih => |
| cases B with |
| | nil => |
| rw [addDigits] |
| simp only [value] |
| rw [ih] |
| have h:=digit_identity c a false |
| simp only [Bool.toNat_false,Nat.add_zero] at h |
| simp only [value] |
| omega |
| | cons b B => |
| rw [addDigits] |
| simp only [value] |
| rw [ih] |
| have h:=digit_identity c a b |
| omega |
| lemma addDigits_length (A B : List Bool) (c : Bool) : |
| (addDigits c A B).length ≤ max A.length B.length+1 := by |
| induction A generalizing B c with |
| | nil => |
| induction B generalizing c with |
| | nil => cases c <;> simp [addDigits] |
| | cons b B ih => |
| rw [addDigits,List.length_cons] |
| have h:=ih (carry c false b) |
| simp only [List.length_nil,Nat.zero_max,List.length_cons] at h ⊢ |
| omega |
| | cons a A ih => |
| cases B with |
| | nil => |
| rw [addDigits,List.length_cons] |
| have h:=ih [] (carry c a false) |
| simp only [List.length_nil,Nat.max_zero,List.length_cons] at h ⊢ |
| omega |
| | cons b B => |
| rw [addDigits,List.length_cons] |
| have h:=ih B (carry c a b) |
| simp only [List.length_cons] |
| omega |
|
|
| def program (c : Bool) : TM2.Stmt (fun _ : Fin 3=>Bool) Bool Store := |
| .pop 0 (fun v a=>(a,v.2)) (.pop 1 (fun v b=>(v.1,b)) |
| (.branch (fun v=>v.1.isNone && v.2.isNone) |
| (.branch (fun _=>c) (.push 2 (fun _=>true) (.load (fun _=>default) .halt)) |
| (.load (fun _=>default) .halt)) |
| (.push 2 (fun v=>digit c (v.1.getD false) (v.2.getD false)) |
| (.goto (fun v=>carry c (v.1.getD false) (v.2.getD false)))))) |
| def stackData (A B L : List Bool) : Stacks := ![A,B,L] |
| @[simp] lemma stackData_zero (A B L : List Bool) : stackData A B L 0=A := rfl |
| @[simp] lemma stackData_one (A B L : List Bool) : stackData A B L 1=B := rfl |
| @[simp] lemma stackData_two (A B L : List Bool) : stackData A B L 2=L := rfl |
| def cfg (c : Option Bool) (A B L : List Bool) (v : Store) : |
| TM2.Cfg (fun _ : Fin 3=>Bool) Bool Store := ⟨c,v,stackData A B L⟩ |
| lemma update_zero (A B L X : List Bool) : |
| Function.update (stackData A B L) 0 X=stackData X B L := by |
| funext i |
| fin_cases i <;> simp [stackData] |
| lemma update_one (A B L X : List Bool) : |
| Function.update (stackData A B L) 1 X=stackData A X L := by |
| funext i |
| fin_cases i <;> simp [stackData] |
| lemma update_two (A B L X : List Bool) : |
| Function.update (stackData A B L) 2 X=stackData A B X := by |
| funext i |
| fin_cases i <;> simp [stackData] |
| lemma step_empty (c : Bool) (L : List Bool) (v : Store) : |
| advance (TM2.step program) (cfg (some c) [] [] L v)= |
| cfg none [] [] ((addDigits c [] []).reverse++L) default := by |
| cases c <;> simp [advance,TM2.step,program,TM2.stepAux,cfg, |
| update_zero,update_one,update_two,addDigits] |
| lemma step_digits (c : Bool) (A B L : List Bool) (v : Store) |
| (h : A≠[] ∨ B≠[]) : |
| advance (TM2.step program) (cfg (some c) A B L v)= |
| cfg (some (carry c (A.headD false) (B.headD false))) A.tail B.tail |
| (digit c (A.headD false) (B.headD false)::L) (A.head?,B.head?) := by |
| cases A <;> cases B <;> simp_all [advance,TM2.step,program,TM2.stepAux,cfg, |
| update_zero,update_one,update_two] |
| lemma addDigits_step (c : Bool) (A B : List Bool) (h : A ≠ [] ∨ B ≠ []) : |
| addDigits c A B=digit c (A.headD false) (B.headD false):: |
| addDigits (carry c (A.headD false) (B.headD false)) A.tail B.tail := by |
| cases A <;> cases B <;> simp_all [addDigits] |
|
|
| theorem run_addition (A B L : List Bool) (c : Bool) (v : Store) : |
| ∃ t ≤ A.length+B.length+1, |
| MachineCost.run (TM2.step program) t (cfg (some c) A B L v)= |
| cfg none [] [] ((addDigits c A B).reverse++L) default := by |
| have aux : ∀ n (A B : List Bool), A.length+B.length=n → |
| ∀ (c : Bool) (L : List Bool) (v : Store), |
| ∃ t ≤ A.length+B.length+1, |
| MachineCost.run (TM2.step program) t (cfg (some c) A B L v)= |
| cfg none [] [] ((addDigits c A B).reverse++L) default := by |
| intro n |
| induction n using Nat.strong_induction_on with |
| | h n ih => |
| intro A B hn c L v |
| by_cases he : A=[] ∧ B=[] |
| · rcases he with ⟨rfl,rfl⟩ |
| exact ⟨1,by simp,step_empty c L v⟩ |
| · have hne : A≠[] ∨ B≠[] := by tauto |
| have hlt : A.tail.length+B.tail.length<n := by |
| cases A <;> cases B <;> simp_all |
| all_goals omega |
| obtain ⟨t,ht,hr⟩:=ih _ hlt A.tail B.tail rfl |
| (carry c (A.headD false) (B.headD false)) |
| (digit c (A.headD false) (B.headD false)::L) (A.head?,B.head?) |
| refine ⟨t+1,by omega,?_⟩ |
| rw [MachineCost.run,step_digits c A B L v hne,hr,addDigits_step c A B hne] |
| simp only [List.reverse_cons,List.append_assoc,List.singleton_append] |
| exact aux _ A B rfl c L v |
| lemma accesses_bound (c : Bool) : StackCost.accesses (program c) ≤ 3 := by |
| cases c <;> decide |
| lemma finite_support : TM2.Supports program Finset.univ := by |
| simp [TM2.Supports,program,TM2.SupportsStmt] |
| lemma value_bits (n : ℕ) : value n.bits=n := by |
| induction n using Nat.binaryRec' with |
| | zero => rfl |
| | bit b n h ih => |
| rw [Nat.bits_append_bit n b h] |
| simp only [value,ih] |
| cases b <;> simp [Nat.bit,Bool.toNat] |
| omega |
|
|
| lemma addition_numerals (m n : ℕ) : value (addDigits false m.bits n.bits)=m+n := by |
| simp only [addDigits_value,value_bits,Bool.toNat_false,Nat.add_zero] |
| end MatchingFPRAS.StackAddition |
|
|
| end OAI |
|
|
