File size: 6,318 Bytes
ea76aac | 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 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 | 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
|