| import OAI.Computability.SpaceSimulation.Register.Fold |
|
|
| namespace OAI |
|
|
| /-! Arithmetic operators in the bit-space closure. Many are |
| intentionally very slow. -/ |
| namespace Fifths |
| namespace Comp |
| variable {X I : Type} {x : I → List X} {S a u v b c : I → ℕ} |
| open Bin |
|
|
| theorem add (h : Comp x S a b) (g : Comp x S a c) : |
| Comp x S a (fun i => b i + c i) := by |
| refine fold (fun i j => b i+j) g h ?_ ?_ |
| · let f : Through c → I := fun i => i.1.1 |
| exact (h.target.pull f).add ((g.target.pull f).mono fun i => i.2) |
| · intro e _ _ l |
| exact l.plus1 |
| theorem sub (h : Comp x S a b) (g : Comp x S a c) : |
| Comp x S a (fun i => b i - c i) := by |
| refine fold (fun i j => b i-j) g h ?_ ?_ |
| · let f : Through c → I := fun i => i.1.1 |
| exact (h.target.pull f).mono (fun i => Nat.sub_le _ _) |
| · intro e _ _ l |
| exact l.minus1.congr (fun i => by |
| show b i.1.1 - i.1.2 - 1 = _ |
| omega) |
|
|
| theorem mul (h : Comp x S a b) (g : Comp x S a c) : |
| Comp x S a (fun i => b i * c i) := by |
| refine fold (fun i j => b i*j) g ((Comp.constant h.source 0).congr (fun i => by simp)) ?_ ?_ |
| · let f : Through c → I := fun i => i.1.1 |
| exact (h.target.pull f).mul ((g.target.pull f).mono fun i => i.2) |
| · intro e p _ l |
| let f : Before c → I := fun i => i.1.1 |
| exact (l.add (p.trans (h.pull f))).congr (fun i => by simp [mul_add,f]) |
|
|
| theorem pow (h : Comp x S a b) (g : Comp x S a c) |
| (p : Fits S (fun i => b i ^ c i)) : Comp x S a (fun i => b i ^ c i) := by |
| refine fold (fun i j => b i^j) g ((Comp.constant h.source 1).congr (fun i => by simp)) ?_ ?_ |
| · let f : Through c → I := fun i => i.1.1 |
| refine ((p.pull f).add (Fits.const _ 1)).mono (fun i => ?_) |
| by_cases e : b (f i) = 0 |
| · change b (f i) ^ i.1.2 ≤ b (f i) ^ c (f i) + 1 |
| rw [e] |
| by_cases a : i.1.2 = 0 |
| · simp [a] |
| · simp [a] |
| · apply le_trans (Nat.pow_le_pow_right (Nat.pos_of_ne_zero e) i.2) |
| exact Nat.le_succ _ |
| · intro e r _ l |
| let f : Before c → I := fun i => i.1.1 |
| exact (l.mul (r.trans (h.pull f))).congr (fun i => by simp [pow_succ,f]) |
|
|
| -- Boolean tests and selections |
| variable {B C : I → Bool} |
|
|
| theorem flip (h : Comp x S a (fun i => (B i).toNat)) : |
| Comp x S a (fun i => (!B i).toNat) := |
| ((Comp.constant h.source 1).sub h).congr fun i => by cases B i <;> rfl |
|
|
| theorem both (h : Comp x S a (fun i => (B i).toNat)) |
| (g : Comp x S a (fun i => (C i).toNat)) : |
| Comp x S a (fun i => (B i && C i).toNat) := |
| (h.mul g).congr fun i => by cases B i <;> cases C i <;> rfl |
|
|
| theorem either (h : Comp x S a (fun i => (B i).toNat)) |
| (g : Comp x S a (fun i => (C i).toNat)) : |
| Comp x S a (fun i => (B i || C i).toNat) := |
| (flip (h.flip.both g.flip)).congr fun i => by cases B i <;> cases C i <;> rfl |
|
|
| theorem lt (h : Comp x S a b) (g : Comp x S a c) : |
| Comp x S a (fun i => (decide (b i < c i)).toNat) := by |
| refine (g.sub h).testnz.congr (fun i => ?_) |
| by_cases l : b i < c i |
| · simp [notZero,Nat.ne_of_gt (Nat.sub_pos_of_lt l),l] |
| · simp [notZero,Nat.sub_eq_zero_of_le (le_of_not_gt l),l] |
|
|
| theorem le (h : Comp x S a b) (g : Comp x S a c) : |
| Comp x S a (fun i => (decide (b i ≤ c i)).toNat) := by |
| refine flip (B := fun i => decide (c i < b i)) (g.lt h) |>.congr (fun i => ?_) |
| by_cases l : b i ≤ c i <;> simp [l] |
| omega |
|
|
| theorem eq (h : Comp x S a b) (g : Comp x S a c) : |
| Comp x S a (fun i => (decide (b i = c i)).toNat) := by |
| refine ((h.le g).both (g.le h)).congr (fun i => ?_) |
| rcases lt_trichotomy (b i) (c i) with l|l|l |
| · simp [l.le,l.ne,not_le_of_gt l] |
| · simp [l] |
| · simp [l.le,l.ne.symm,not_le_of_gt l] |
|
|
| theorem min (h : Comp x S a b) (g : Comp x S a c) : |
| Comp x S a (fun i => min (b i) (c i)) := |
| ((h.le g).iteB h g).congr fun i => by |
| by_cases l : b i ≤ c i |
| · simp [l] |
| · simp [l, min_eq_right (le_of_not_ge l)] |
| theorem max (h : Comp x S a b) (g : Comp x S a c) : |
| Comp x S a (fun i => max (b i) (c i)) := |
| ((h.le g).iteB g h).congr fun i => by |
| by_cases l : b i ≤ c i |
| · simp [l] |
| · simp [l,max_eq_left (le_of_not_ge l)] |
|
|
| private theorem div_step (j n : ℕ) : |
| (if notZero n && decide ((j/n+1)*n ≤ j+1) then |
| j/n+1 else j/n) = (j+1)/n := by |
| by_cases h : n = 0 |
| · subst n; simp [notZero] |
| have p := Nat.pos_of_ne_zero h |
| have hb : j < (j/n+1)*n := (Nat.div_lt_iff_lt_mul p).mp (Nat.lt_succ_self _) |
| by_cases l : (j/n+1)*n ≤ j+1 |
| · have e : (j/n+1)*n = j+1 := by omega |
| have v : n ∣ j+1 := ⟨j/n+1, by simpa [mul_comm] using e.symm⟩ |
| simp [notZero,h,l,Nat.succ_div,v] |
| · have a : (j+1)/n < j/n+1 := (Nat.div_lt_iff_lt_mul p).mpr (lt_of_not_ge l) |
| have g : j/n ≤ (j+1)/n := Nat.div_le_div_right (Nat.le_succ _) |
| simpa only [decide_eq_false l,Bool.and_false, Bool.false_eq_true, ite_false] using |
| Nat.le_antisymm g (by omega) |
|
|
| theorem div (h : Comp x S a b) (g : Comp x S a c) : |
| Comp x S a (fun i => b i / c i) := by |
| refine fold (fun i j => j / c i) h ((Comp.constant h.source 0).congr |
| (fun i => by simp)) ?_ ?_ |
| · let f : Through b → I := fun i => i.1.1 |
| exact (h.target.pull f).mono (fun i => le_trans (Nat.div_le_self _ _) i.2) |
| · intro e r k l |
| let f : Before b → I := fun i => i.1.1 |
| have q := r.trans (g.pull f) |
| have v := q.testnz.both ((l.plus1.mul q).le k.plus1) |
| exact (v.iteB l.plus1 l).congr (fun i => div_step _ _) |
|
|
| theorem mod (h : Comp x S a b) (g : Comp x S a c) : |
| Comp x S a (fun i => b i % c i) := by |
| apply (h.sub ((h.div g).mul g)).congr |
| intro i |
| have l := Nat.mod_add_div (b i) (c i) |
| rw [mul_comm] |
| omega |
|
|
| theorem size (h : Comp x S a b) : |
| Comp x S a (fun i => (b i).size) := by |
| let n := fun i => (b i).size |
| let w := fun i (j : ℕ) => Bin.pair j (b i / 2^j) |
| have e : Comp x S a (fun i => w i 0) := |
| ((Comp.constant h.source 0).pair h).congr (fun i => by simp [w]) |
| have p : Fits (fun i : Through n => S i.1.1) |
| (fun i => w i.1.1 i.1.2) := by |
| let f : Through n → I := fun i => i.1.1 |
| refine ((h.target.pull f).mono ?_).pair ((h.target.pull f).mono ?_) |
| · exact fun i => le_trans i.2 (Bin.size_le_self _) |
| · exact fun _ => Nat.div_le_self _ _ |
| have g : Comp x S (fun i => w i 0) (fun i => w i (n i)) := by |
| refine loop n w ?_ ?_ |
| · let f : Before n → Through n := fun i => ⟨i.1,i.2.le⟩ |
| have r : Comp (fun i : Before n => x i.1.1) (fun i => S i.1.1) |
| (fun i => w i.1.1 i.1.2) (fun i => w i.1.1 i.1.2) := |
| Comp.refl (p.pull f) |
| exact (r.left.plus1.pair (r.right.div (Comp.constant r.source 2))).congr |
| (fun i => by simp [w,pow_succ,Nat.div_div_eq_div_mul]) |
| · have r : Comp (fun i : Through n => x i.1.1) (fun i => S i.1.1) |
| (fun i => w i.1.1 i.1.2) (fun i => w i.1.1 i.1.2) := |
| Comp.refl p |
| apply r.right.testnz.congr |
| intro i |
| by_cases l : i.1.2 < n i.1.1 |
| · have a : 2^i.1.2 ≤ b i.1.1 := Nat.lt_size.mp l |
| simp [notZero,l,Nat.ne_of_gt (Nat.div_pos a (by positivity))] |
| · have a := Nat.size_le.mp (le_of_not_gt l) |
| simp [notZero,l,Nat.div_eq_of_lt a] |
| exact (e.trans g).left |
|
|
| end Comp |
| end Fifths |
|
|
| end OAI |
|
|
