| import OAI.Computability.MatchingCount.UnaryDivision |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace BinaryMatching.StackCode |
| open Polynomial |
|
|
| def intParts (z : ℤ) : Bool×ℕ := (decide (z<0),z.natAbs) |
| def fromParts (p : Bool×ℕ) : ℤ := if p.1 then -(p.2:ℤ) else p.2 |
| instance : Coding ℤ := ⟨fun z => encode (intParts z)⟩ |
| @[simp] lemma encode_int (z : ℤ) : encode z=encode (intParts z) := rfl |
| lemma fromParts_parts (z : ℤ) : fromParts (intParts z)=z := by |
| simp only [fromParts,intParts,decide_eq_true_eq] |
| split_ifs with h |
| · exact (Int.eq_neg_natAbs_of_nonpos (le_of_lt h)).symm |
| · exact Int.natAbs_of_nonneg (le_of_not_gt h) |
|
|
| lemma intParts_nat (n : ℕ) : intParts (n:ℤ)=(false,n) := by |
| have h : ¬ (n:ℤ)<0 := by omega |
| simp [intParts,h] |
| lemma intParts_fromParts (p : Bool×ℕ) : |
| intParts (fromParts p)=(p.1 && !(decide (p.2=0)),p.2) := by |
| rcases p with ⟨b,n⟩ |
| cases b with |
| | false => simp [fromParts,intParts_nat] |
| | true => |
| by_cases hn : n=0 |
| · subst n; simp [intParts,fromParts] |
| · simp [intParts,fromParts,Nat.pos_iff_ne_zero,hn] |
|
|
| namespace Poly |
| @[fun_prop] theorem intParts_poly : Poly intParts := by |
| exact ⟨(Routine.identity (encode : Bool×ℕ → List Bool)).reindex encode encode intParts intParts |
| (fun _ => rfl) (fun _ => rfl)⟩ |
|
|
| @[fun_prop] theorem natCastInt : Poly (Int.ofNat : ℕ → ℤ) := by |
| have h : Poly (fun n : ℕ => (false,n)) := by fun_prop |
| refine ⟨h.routine.reindex encode encode Int.ofNat id (fun _ => rfl) ?_⟩ |
| intro n |
| change encode (false,n)=encode (intParts (n:ℤ)) |
| rw [intParts_nat] |
|
|
| @[fun_prop] theorem natToInt : Poly (fun n : ℕ => (n:ℤ)) := natCastInt |
|
|
| @[fun_prop] theorem fromParts_poly : Poly fromParts := by |
| have h : Poly (fun p : Bool×ℕ => (p.1 && !(decide (p.2=0)),p.2)) := by |
| apply pair |
| · exact comp _ _ boolAnd (pair _ _ (by fun_prop) (comp _ _ boolNot (comp _ _ natZeroTest (by fun_prop)))) |
| · fun_prop |
| refine ⟨h.routine.reindex encode encode fromParts id (fun _ => rfl) ?_⟩ |
| intro p |
| simp only [id_eq,encode_int,intParts_fromParts] |
|
|
| @[fun_prop] theorem intNatAbs : Poly (Int.natAbs : ℤ → ℕ) := by |
| have h : Poly (fun z : ℤ => (intParts z).2) := second _ intParts_poly |
| exact h |
|
|
| @[fun_prop] theorem intSign : Poly (fun z : ℤ => decide (z<0)) := by |
| have h : Poly (fun z : ℤ => (intParts z).1) := first _ intParts_poly |
| exact h |
|
|
| @[fun_prop] theorem intNeg : Poly (fun z : ℤ => -z) := by |
| have h : Poly (fun z : ℤ => fromParts (!(intParts z).1,(intParts z).2)) := by fun_prop |
| exact h.congr (fun z => by cases z <;> simp [intParts,fromParts]) |
|
|
| def addParts (p : (Bool×ℕ)×(Bool×ℕ)) : ℤ := |
| if p.1.1 then |
| if p.2.1 then fromParts (true,p.1.2+p.2.2) |
| else if decide (p.2.2≤p.1.2) then fromParts (true,p.1.2-p.2.2) |
| else fromParts (false,p.2.2-p.1.2) |
| else if p.2.1 then |
| if decide (p.1.2≤p.2.2) then fromParts (true,p.2.2-p.1.2) |
| else fromParts (false,p.1.2-p.2.2) |
| else fromParts (false,p.1.2+p.2.2) |
|
|
| lemma addParts_eq (p q : Bool×ℕ) : addParts (p,q)=fromParts p+fromParts q := by |
| rcases p with ⟨b,n⟩; rcases q with ⟨c,m⟩ |
| cases b <;> cases c <;> simp only [addParts,fromParts,Bool.false_eq_true,ite_false,ite_true, |
| decide_eq_true_eq] |
| · omega |
| · split_ifs <;> omega |
| · split_ifs <;> omega |
| · omega |
|
|
| @[fun_prop] theorem intAdd : Poly (fun z : ℤ×ℤ => z.1+z.2) := by |
| have ha : Poly addParts := by unfold addParts; fun_prop |
| have h : Poly (fun z : ℤ×ℤ => addParts (intParts z.1,intParts z.2)) := by fun_prop |
| exact h.congr (fun z => by rw [addParts_eq,fromParts_parts,fromParts_parts]) |
|
|
| @[fun_prop] theorem intSub : Poly (fun z : ℤ×ℤ => z.1-z.2) := by |
| have h : Poly (fun z : ℤ×ℤ => z.1+ -z.2) := by fun_prop |
| exact h.congr (fun z => sub_eq_add_neg _ _) |
|
|
| @[fun_prop] theorem intMul : Poly (fun z : ℤ×ℤ => z.1*z.2) := by |
| have hm : Poly (fun p : (Bool×ℕ)×(Bool×ℕ) => fromParts |
| (if p.1.1 then !p.2.1 else p.2.1,p.1.2*p.2.2)) := by fun_prop |
| have hp : Poly (fun z : ℤ×ℤ => (intParts z.1,intParts z.2)) := |
| pair _ _ (comp _ Prod.fst intParts_poly (first _ identity)) |
| (comp _ Prod.snd intParts_poly (second _ identity)) |
| have h := comp _ _ hm hp |
| have he (p q : Bool×ℕ) : |
| fromParts (if p.1 then !q.1 else q.1,p.2*q.2)=fromParts p*fromParts q := by |
| rcases p with ⟨b,n⟩; rcases q with ⟨c,m⟩ |
| cases b <;> cases c <;> simp [fromParts] |
| exact h.congr (fun z => by dsimp only; rw [he,fromParts_parts,fromParts_parts]) |
|
|
| @[fun_prop] theorem intLE : Poly (fun z : ℤ×ℤ => decide (z.1≤z.2)) := by |
| have h : Poly (fun z : ℤ×ℤ => !(decide (z.2-z.1<0))) := by |
| exact comp _ _ boolNot (comp _ _ intSign (comp _ (fun z : ℤ×ℤ => (z.2,z.1)) intSub (by fun_prop))) |
| exact h.congr (fun z => by simp [←decide_not,sub_neg]) |
|
|
| @[fun_prop] theorem intLT : Poly (fun z : ℤ×ℤ => decide (z.1<z.2)) := by |
| have h : Poly (fun z : ℤ×ℤ => decide (z.1-z.2<0)) := comp _ _ intSign intSub |
| exact h.congr (fun z => by simp [sub_neg]) |
|
|
| @[fun_prop] theorem intEQ : Poly (fun z : ℤ×ℤ => decide (z.1=z.2)) := by |
| have h : Poly (fun z : ℤ×ℤ => decide ((z.1-z.2).natAbs=0)) := |
| comp _ _ natZeroTest (comp _ _ intNatAbs intSub) |
| exact h.congr (fun z => by simp [sub_eq_zero]) |
|
|
| @[fun_prop] theorem intMin : Poly (fun z : ℤ×ℤ => min z.1 z.2) := by |
| have h : Poly (fun z : ℤ×ℤ => if decide (z.1≤z.2) then z.1 else z.2) := by fun_prop |
| exact h.congr (fun z => by simp [min_def]) |
| @[fun_prop] theorem intMax : Poly (fun z : ℤ×ℤ => max z.1 z.2) := by |
| have h : Poly (fun z : ℤ×ℤ => if decide (z.1≤z.2) then z.2 else z.1) := by fun_prop |
| exact h.congr (fun z => by simp [max_def]) |
| @[fun_prop] theorem intToNat : Poly (Int.toNat : ℤ → ℕ) := by |
| have h : Poly (fun z : ℤ => if (intParts z).1 then 0 else (intParts z).2) := by fun_prop |
| exact h.congr (fun z => by cases z <;> simp [intParts]) |
| variable {α : Type} [Coding α] |
| @[fun_prop] theorem intLt_apply (f g : α → ℤ) (hf : Poly f) (hg : Poly g) : |
| Poly (fun a => decide (f a<g a)) := comp _ _ intLT (pair _ _ hf hg) |
| @[fun_prop] theorem intLe_apply (f g : α → ℤ) (hf : Poly f) (hg : Poly g) : |
| Poly (fun a => decide (f a≤g a)) := comp _ _ intLE (pair _ _ hf hg) |
| end Poly |
| end BinaryMatching.StackCode |
| end |
|
|
| end OAI |
|
|
