| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Arithmetic.BinaryAddition |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.StackCompare |
| open Turing MachineCost StackAddition |
|
|
| def updateOrder (c : Ordering) (a b : Bool) : Ordering := |
| if a=b then c else if a then .gt else .lt |
|
|
| def compareDigits (c : Ordering) (A B : List Bool) : Ordering := |
| match A,B with |
| | [],[] => c |
| | a::A,[] => compareDigits (updateOrder c a false) A [] |
| | [],b::B => compareDigits (updateOrder c false b) [] B |
| | a::A,b::B => compareDigits (updateOrder c a b) A B |
| termination_by A.length+B.length |
|
|
| def result (c : Ordering) (m n : ℕ) : Ordering := if m=n then c else compare m n |
| lemma result_digits (c : Ordering) (a b : Bool) (m n : ℕ) : |
| result (updateOrder c a b) m n=result c (a.toNat+2*m) (b.toNat+2*n) := by |
| rcases lt_trichotomy m n with h|h|h |
| · have hb : a.toNat+2*m < b.toNat+2*n := by |
| cases a <;> cases b <;> simp only [Bool.toNat_true,Bool.toNat_false] <;> omega |
| simp [result,ne_of_lt h,ne_of_lt hb,compare_lt_iff_lt.mpr h,compare_lt_iff_lt.mpr hb] |
| · subst n |
| cases a <;> cases b <;> cases c <;> |
| simp [result,updateOrder,eq_comm] |
| all_goals first |
| | exact (compare_lt_iff_lt.mpr (by omega)).symm |
| | exact (compare_gt_iff_gt.mpr (by omega)).symm |
| · have hb : b.toNat+2*n < a.toNat+2*m := by |
| cases a <;> cases b <;> simp only [Bool.toNat_true,Bool.toNat_false] <;> omega |
| simp [result,ne_of_gt h,ne_of_gt hb,compare_gt_iff_gt.mpr h,compare_gt_iff_gt.mpr hb] |
| lemma compareDigits_result (A B : List Bool) (c : Ordering) : |
| compareDigits c A B=result c (value A) (value B) := by |
| induction A generalizing B c with |
| | nil => |
| induction B generalizing c with |
| | nil => simp [compareDigits,result,value] |
| | cons b B ih => |
| rw [compareDigits,ih] |
| simpa only [value,Bool.toNat_false,Nat.zero_add,Nat.mul_zero] using result_digits c false b 0 (value B) |
| | cons a A ih => |
| cases B with |
| | nil => |
| rw [compareDigits,ih] |
| simpa only [value,Bool.toNat_false,Nat.zero_add,Nat.mul_zero,Nat.add_zero] using result_digits c a false (value A) 0 |
| | cons b B => |
| rw [compareDigits,ih] |
| exact result_digits c a b (value A) (value B) |
| lemma compares_values (A B : List Bool) : |
| compareDigits .eq A B=compare (value A) (value B) := by |
| rw [compareDigits_result] |
| unfold result |
| split_ifs with h |
| · simp [h] |
| · rfl |
| def flags (c : Ordering) : List Bool := [decide (c=.lt),decide (c=.gt)] |
| def program (c : Ordering) : TM2.Stmt (fun _ : Fin 3=>Bool) Ordering 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) |
| (.push 2 (fun _=>decide (c=.gt)) (.push 2 (fun _=>decide (c=.lt)) |
| (.load (fun _=>default) .halt))) |
| (.goto (fun v=>updateOrder c (v.1.getD false) (v.2.getD false))))) |
| def cfg (c : Option Ordering) (A B L : List Bool) (v : Store) : |
| TM2.Cfg (fun _ : Fin 3=>Bool) Ordering Store := ⟨c,v,stackData A B L⟩ |
| lemma step_empty (c : Ordering) (L : List Bool) (v : Store) : |
| advance (TM2.step program) (cfg (some c) [] [] L v)= |
| cfg none [] [] (flags c++L) default := by |
| cases c <;> simp [advance,TM2.step,program,TM2.stepAux,cfg,flags, |
| update_zero,update_one,update_two] |
| lemma step_digits (c : Ordering) (A B L : List Bool) (v : Store) |
| (h : A≠[] ∨ B≠[]) : |
| advance (TM2.step program) (cfg (some c) A B L v)= |
| cfg (some (updateOrder c (A.headD false) (B.headD false))) A.tail B.tail 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,List.headD] |
| lemma compareDigits_step (c : Ordering) (A B : List Bool) (h : A ≠ [] ∨ B ≠ []) : |
| compareDigits c A B= |
| compareDigits (updateOrder c (A.headD false) (B.headD false)) A.tail B.tail := by |
| cases A <;> cases B <;> simp_all [compareDigits,List.headD] |
| theorem run_comparison (A B L : List Bool) (c : Ordering) (v : Store) : |
| ∃ t ≤ A.length+B.length+1, |
| MachineCost.run (TM2.step program) t (cfg (some c) A B L v)= |
| cfg none [] [] (flags (compareDigits c A B)++L) default := by |
| have aux : ∀ n (A B : List Bool), A.length+B.length=n → |
| ∀ (c : Ordering) (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 [] [] (flags (compareDigits c A B)++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⟩ |
| refine ⟨1,by simp,?_⟩ |
| simpa only [MachineCost.run,compareDigits] using 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 |
| (updateOrder 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,compareDigits_step c A B hne] |
| exact aux _ A B rfl c L v |
| lemma accesses_bound (c : Ordering) : StackCost.accesses (program c) ≤ 4 := by |
| cases c <;> decide |
| lemma finite_support : TM2.Supports program Finset.univ := by |
| simp [TM2.Supports,program,TM2.SupportsStmt] |
| lemma numerical_comparison (m n : ℕ) : compareDigits .eq m.bits n.bits=compare m n := by |
| simp only [compares_values,value_bits] |
| end MatchingFPRAS.StackCompare |
|
|
| end OAI |
|
|
