| import Mathlib |
| import OAI.MathematicalPhysics.SheetFlows.RationalBalls |
|
|
| namespace OAI |
|
|
| /-! SheetFlows computing. -/ |
|
|
| section |
| open Encodable |
| namespace Solenoidal.Computing |
|
|
| theorem gcd_findGreatest (a b : ℕ) : |
| Nat.findGreatest (fun d => d ∣ a ∧ d ∣ b) (a+b) = Nat.gcd a b := by |
| by_cases h : a+b=0 |
| · have ha : a=0 := by omega |
| have hb : b=0 := by omega |
| simp [ha,hb] |
| have hg : 0 < Nat.gcd a b := by |
| rcases Nat.eq_zero_or_pos a with rfl | ha |
| · simpa using (show 0 < b by omega) |
| · exact Nat.gcd_pos_of_pos_left b ha |
| apply le_antisymm |
| · have hh := Nat.findGreatest_spec (P := fun d => d ∣ a ∧ d ∣ b) |
| (show 1 ≤ a+b by omega) (show 1 ∣ a ∧ 1 ∣ b from ⟨one_dvd _,one_dvd _⟩) |
| exact Nat.le_of_dvd hg (Nat.dvd_gcd hh.1 hh.2) |
| · apply Nat.le_findGreatest |
| · rcases Nat.eq_zero_or_pos a with rfl | ha |
| · simp |
| · exact (Nat.gcd_le_left b ha).trans (Nat.le_add_right a b) |
| · exact ⟨Nat.gcd_dvd_left _ _,Nat.gcd_dvd_right _ _⟩ |
|
|
| theorem nat_dvd : PrimrecRel ((· ∣ ·) : ℕ → ℕ → Prop) := |
| (Primrec.eq.comp (Primrec.nat_mod.comp .snd .fst) (.const 0)).of_eq |
| (fun _ => Nat.dvd_iff_mod_eq_zero.symm) |
|
|
| theorem nat_gcd : Primrec₂ Nat.gcd := by |
| refine (Primrec.nat_findGreatest Primrec.nat_add |
| (((nat_dvd.comp .snd (Primrec.fst.comp .fst)).and |
| (nat_dvd.comp .snd (Primrec.snd.comp .fst))).primrecRel)).of_eq ?_ |
| intro p |
| exact gcd_findGreatest p.1 p.2 |
|
|
| @[simp] theorem encode_int_ofNat (n : ℕ) : encode (Int.ofNat n) = 2*n := rfl |
| @[simp] theorem encode_int_negSucc (n : ℕ) : encode (Int.negSucc n) = 2*n+1 := rfl |
|
|
| theorem int_ofNat : Primrec Int.ofNat := |
| Primrec.encode_iff.mp (Primrec.nat_mul.comp (.const 2) .id) |
|
|
| theorem int_negSucc : Primrec Int.negSucc := |
| Primrec.encode_iff.mp (Primrec.nat_add.comp (Primrec.nat_mul.comp (.const 2) .id) (.const 1)) |
|
|
| def intToSum : ℤ → ℕ ⊕ ℕ := fun z => Int.casesOn z Sum.inl Sum.inr |
|
|
| theorem intToSum_pr : Primrec intToSum := |
| Primrec.encode_iff.mp (Primrec.encode.of_eq (by intro z; cases z <;> rfl)) |
|
|
| theorem int_cases {α β : Type*} [Primcodable α] [Primcodable β] |
| {f : α → ℤ} {g h : α → ℕ → β} (hf : Primrec f) (hg : Primrec₂ g) (hh : Primrec₂ h) : |
| Primrec (fun a => Int.casesOn (motive := fun _ => β) (f a) (g a) (h a)) := |
| (Primrec.sumCasesOn (intToSum_pr.comp hf) hg hh).of_eq |
| (fun a => by cases f a <;> rfl) |
|
|
| theorem int_natAbs : Primrec Int.natAbs := |
| (int_cases .id .right (Primrec.succ.comp₂ .right)).of_eq |
| (fun z => by cases z <;> rfl) |
|
|
| theorem int_neg : Primrec ((- ·) : ℤ → ℤ) := by |
| have h : Primrec (fun z : ℤ => Int.casesOn (motive := fun _ => ℤ) z |
| (fun n => Nat.casesOn n (0 : ℤ) Int.negSucc) (fun n => Int.ofNat (n+1))) := by |
| exact int_cases .id |
| (Primrec.nat_casesOn .snd (.const 0) (int_negSucc.comp .snd).to₂) |
| (int_ofNat.comp (Primrec.succ.comp .snd)) |
| exact h.of_eq (fun z => by cases z with |
| | ofNat n => cases n <;> rfl |
| | negSucc n => rfl) |
|
|
| theorem int_subNatNat : Primrec₂ Int.subNatNat := by |
| refine (Primrec.ite Primrec.nat_le |
| (Primrec.nat_casesOn (Primrec.nat_sub.comp .snd .fst) (.const 0) |
| (int_negSucc.comp .snd).to₂) |
| (int_ofNat.comp (Primrec.nat_sub.comp .fst .snd))).of_eq ?_ |
| intro p |
| simp only [Int.subNatNat] |
| split <;> rename_i h |
| · split <;> simp_all |
| · split <;> simp_all; omega |
|
|
| theorem int_add : Primrec₂ ((·+·) : ℤ → ℤ → ℤ) := by |
| let f : ℤ×ℤ → ℤ := fun p => Int.casesOn p.1 |
| (fun n => Int.casesOn p.2 (fun m => Int.ofNat (n+m)) |
| (fun m => Int.subNatNat n (m+1))) |
| (fun n => Int.casesOn p.2 (fun m => Int.subNatNat m (n+1)) |
| (fun m => Int.negSucc (n+m+1))) |
| have h : Primrec f := by |
| apply int_cases .fst |
| · apply int_cases (Primrec.snd.comp .fst) |
| · exact int_ofNat.comp (Primrec.nat_add.comp (Primrec.snd.comp .fst) .snd) |
| · exact int_subNatNat.comp (Primrec.snd.comp .fst) (Primrec.succ.comp .snd) |
| · apply int_cases (Primrec.snd.comp .fst) |
| · exact int_subNatNat.comp .snd (Primrec.succ.comp (Primrec.snd.comp .fst)) |
| · exact int_negSucc.comp (Primrec.succ.comp |
| (Primrec.nat_add.comp (Primrec.snd.comp .fst) .snd)) |
| exact h.of_eq (fun ⟨a,b⟩ => by cases a <;> cases b <;> rfl) |
|
|
| theorem int_mul : Primrec₂ ((·*·) : ℤ → ℤ → ℤ) := by |
| let f : ℤ×ℤ → ℤ := fun p => Int.casesOn p.1 |
| (fun n => Int.casesOn p.2 (fun m => Int.ofNat (n*m)) |
| (fun m => -(Int.ofNat (n*(m+1))))) |
| (fun n => Int.casesOn p.2 (fun m => -(Int.ofNat ((n+1)*m))) |
| (fun m => Int.ofNat ((n+1)*(m+1)))) |
| have h : Primrec f := by |
| apply int_cases .fst |
| · apply int_cases (Primrec.snd.comp .fst) |
| · exact int_ofNat.comp (Primrec.nat_mul.comp (Primrec.snd.comp .fst) .snd) |
| · exact int_neg.comp (int_ofNat.comp (Primrec.nat_mul.comp |
| (Primrec.snd.comp .fst) (Primrec.succ.comp .snd))) |
| · apply int_cases (Primrec.snd.comp .fst) |
| · exact int_neg.comp (int_ofNat.comp (Primrec.nat_mul.comp |
| (Primrec.succ.comp (Primrec.snd.comp .fst)) .snd)) |
| · exact int_ofNat.comp (Primrec.nat_mul.comp |
| (Primrec.succ.comp (Primrec.snd.comp .fst)) (Primrec.succ.comp .snd)) |
| exact h.of_eq (fun ⟨a,b⟩ => by cases a <;> cases b <;> rfl) |
|
|
| theorem int_edivNat : Primrec₂ (fun (z : ℤ) (n : ℕ) => z / (n:ℤ)) := by |
| let f : ℤ×ℕ → ℤ := fun p => Int.casesOn p.1 |
| (fun m => Int.ofNat (m / p.2)) |
| (fun m => Nat.casesOn p.2 0 (fun n => Int.negSucc (m / (n+1)))) |
| have h : Primrec f := by |
| apply int_cases .fst |
| · exact int_ofNat.comp (Primrec.nat_div.comp .snd (Primrec.snd.comp .fst)) |
| · exact Primrec.nat_casesOn (Primrec.snd.comp .fst) (.const 0) |
| (int_negSucc.comp (Primrec.nat_div.comp (Primrec.snd.comp .fst) |
| (Primrec.succ.comp .snd))).to₂ |
| exact h.of_eq (fun ⟨a,b⟩ => by cases a <;> cases b <;> rfl) |
|
|
| theorem int_nonneg : PrimrecPred (fun z : ℤ => 0 ≤ z) := by |
| refine ⟨inferInstance, ?_⟩ |
| refine (int_cases .id (Primrec₂.const true) (Primrec₂.const false)).of_eq ?_ |
| intro z |
| cases z with |
| | ofNat n => change true = decide (0 ≤ (n:ℤ)); simp |
| | negSucc n => rfl |
|
|
| theorem int_le : PrimrecRel ((· ≤ ·) : ℤ → ℤ → Prop) := |
| (int_nonneg.comp (int_add.comp .snd (int_neg.comp .fst))).of_eq |
| (fun p => by simp [← sub_eq_add_neg]) |
|
|
| theorem int_lt : PrimrecRel ((· < ·) : ℤ → ℤ → Prop) := |
| ((int_le.comp .snd .fst).not).of_eq (fun _ => not_le) |
|
|
| def ratValid (p : ℤ×ℕ) : Prop := 0 < p.2 ∧ p.1.natAbs.Coprime p.2 |
|
|
| instance : DecidablePred ratValid := fun p => inferInstanceAs |
| (Decidable (0 < p.2 ∧ p.1.natAbs.Coprime p.2)) |
|
|
| theorem ratValid_pr : PrimrecPred ratValid := |
| (Primrec.nat_lt.comp (.const 0) .snd).and |
| ((Primrec.eq.comp (nat_gcd.comp (int_natAbs.comp .fst) .snd) (.const 1)).of_eq |
| (fun _ => Iff.rfl)) |
|
|
| instance ratPairPrimcodable : Primcodable {p : ℤ×ℕ |
| Primcodable.subtype ratValid_pr |
|
|
| def ratEquiv : ℚ ≃ {p : ℤ×ℕ |
| toFun q := ⟨(q.num,q.den),q.den_pos,q.reduced⟩ |
| invFun p := ⟨p.1.1,p.1.2,ne_of_gt p.2.1,p.2.2⟩ |
| left_inv _ := rfl |
| right_inv _ := rfl |
|
|
| instance ratPrimcodable : Primcodable ℚ := Primcodable.ofEquiv _ ratEquiv |
|
|
| theorem rat_encoding (q : ℚ) : |
| @encode ℚ ratPrimcodable.toEncodable q = @encode ℚ Rat.instEncodable q := rfl |
|
|
| theorem rat_num : Primrec Rat.num := |
| Primrec.fst.comp (Primrec.subtype_val.comp (Primrec.of_equiv (e := ratEquiv))) |
|
|
| theorem rat_den : Primrec Rat.den := |
| Primrec.snd.comp (Primrec.subtype_val.comp (Primrec.of_equiv (e := ratEquiv))) |
|
|
| theorem rat_mk_iff {α : Type*} [Primcodable α] {f : α → ℚ} : |
| Primrec f ↔ Primrec (fun a => (f a).num) ∧ Primrec (fun a => (f a).den) := by |
| refine ⟨fun h => ⟨rat_num.comp h,rat_den.comp h⟩, fun h => ?_⟩ |
| exact (Primrec.of_equiv_iff ratEquiv).mp |
| ((Primrec.subtype_val_iff).mp (h.1.pair h.2)) |
|
|
| theorem rat_mk : Primrec₂ mkRat := by |
| apply rat_mk_iff.mpr |
| constructor |
| · exact (Primrec.ite (Primrec.eq.comp .snd (.const 0)) (.const 0) |
| (int_edivNat.comp .fst (nat_gcd.comp .snd (int_natAbs.comp .fst)))).of_eq |
| (fun p => (Rat.num_mkRat p.1 p.2).symm) |
| · exact (Primrec.ite (Primrec.eq.comp .snd (.const 0)) (.const 1) |
| (Primrec.nat_div.comp .snd (nat_gcd.comp .snd (int_natAbs.comp .fst)))).of_eq |
| (fun p => (Rat.den_mkRat p.1 p.2).symm) |
|
|
| theorem rat_int : Primrec (fun z : ℤ => (z:ℚ)) := |
| rat_mk_iff.mpr ⟨.id,.const 1⟩ |
|
|
| theorem rat_nat : Primrec (fun n : ℕ => (n:ℚ)) := rat_int.comp int_ofNat |
|
|
| theorem rat_neg : Primrec (fun q : ℚ => -q) := |
| rat_mk_iff.mpr ⟨int_neg.comp rat_num,rat_den⟩ |
|
|
| theorem rat_add : Primrec₂ ((·+·) : ℚ → ℚ → ℚ) := |
| (rat_mk.comp (int_add.comp |
| (int_mul.comp (rat_num.comp .fst) (int_ofNat.comp (rat_den.comp .snd))) |
| (int_mul.comp (rat_num.comp .snd) (int_ofNat.comp (rat_den.comp .fst)))) |
| (Primrec.nat_mul.comp (rat_den.comp .fst) (rat_den.comp .snd))).of_eq |
| (fun p => (Rat.add_def' p.1 p.2).symm) |
| |
| theorem rat_sub : Primrec₂ ((·-·) : ℚ → ℚ → ℚ) := |
| (rat_add.comp .fst (rat_neg.comp .snd)).of_eq (fun _ => (sub_eq_add_neg ..).symm) |
| |
| theorem rat_mul : Primrec₂ ((·*·) : ℚ → ℚ → ℚ) := |
| (rat_mk.comp (int_mul.comp (rat_num.comp .fst) (rat_num.comp .snd)) |
| (Primrec.nat_mul.comp (rat_den.comp .fst) (rat_den.comp .snd))).of_eq |
| (fun p => by conv_rhs => rw [← Rat.mkRat_self p.1, ← Rat.mkRat_self p.2] |
| exact (Rat.mkRat_mul_mkRat ..).symm) |
| |
| theorem rat_le : PrimrecRel ((·≤·) : ℚ → ℚ → Prop) := |
| (int_le.comp |
| (int_mul.comp (rat_num.comp .fst) (int_ofNat.comp (rat_den.comp .snd))) |
| (int_mul.comp (rat_num.comp .snd) (int_ofNat.comp (rat_den.comp .fst)))).of_eq |
| (fun p => (Rat.le_iff (a := p.1) (b := p.2)).symm) |
| |
| theorem rat_lt : PrimrecRel ((·<·) : ℚ → ℚ → Prop) := |
| ((rat_le.comp .snd .fst).not).of_eq (fun _ => not_le) |
| |
| theorem rat_abs : Primrec (fun q : ℚ => |q|) := |
| (Primrec.ite (rat_le.comp (.const 0) .id) .id rat_neg).of_eq |
| (fun q => by by_cases h : 0 ≤ q |
| · simp [h,abs_of_nonneg h] |
| · simp [h,abs_of_neg (lt_of_not_ge h)]) |
| |
| theorem rat_inv : Primrec (fun q : ℚ => q⁻¹) := by |
| have h : Primrec (fun q : ℚ => |
| if q.num < 0 then mkRat (-(q.den:ℤ)) q.num.natAbs |
| else mkRat (q.den:ℤ) q.num.natAbs) := |
| Primrec.ite (int_lt.comp rat_num (.const 0)) |
| (rat_mk.comp (int_neg.comp (int_ofNat.comp rat_den)) (int_natAbs.comp rat_num)) |
| (rat_mk.comp (int_ofNat.comp rat_den) (int_natAbs.comp rat_num)) |
| refine h.of_eq ?_ |
| intro q |
| rw [Rat.inv_def] |
| cases q.num with |
| | ofNat numerator => simp [Rat.divInt] |
| | negSucc numerator => simp [Rat.divInt,Rat.normalize_eq_mkRat] |
| |
| theorem rat_div : Primrec₂ ((·/·) : ℚ → ℚ → ℚ) := |
| (rat_mul.comp .fst (rat_inv.comp .snd)).of_eq (fun _ => (div_eq_mul_inv ..).symm) |
| |
| theorem rat_max : Primrec₂ ((max) : ℚ → ℚ → ℚ) := |
| (Primrec.ite rat_le .snd .fst).of_eq (fun _ => rfl) |
| |
| theorem rat_pow : Primrec₂ ((·^·) : ℚ → ℕ → ℚ) := by |
| exact (Primrec.nat_rec (.const 1) |
| (rat_mul.comp (Primrec.snd.comp .snd) .fst).to₂).of_eq |
| (fun q n => by induction n with |
| | zero => simp |
| | succ n ih => simp_all [pow_succ]) |
| |
| theorem nat_factorial : Primrec Nat.factorial := by |
| have h : Primrec (fun n : ℕ => Nat.rec (motive := fun _ => ℕ) 1 (fun m r => (m+1)*r) n) := |
| Primrec.nat_rec₁ 1 |
| (Primrec.nat_mul.comp (Primrec.succ.comp .fst) .snd) |
| exact h.of_eq (fun n => by induction n with |
| | zero => rfl |
| | succ n ih => simp [Nat.factorial_succ,ih]) |
| |
| theorem rat_floor : Primrec (fun q : ℚ => ⌊q⌋) := |
| (int_edivNat.comp rat_num rat_den).of_eq (fun q => by |
| change q.num / (q.den:ℤ) = q.floor |
| exact (Rat.floor_def q).symm) |
| |
| end Solenoidal.Computing |
| end |
| |
| section |
| open Encodable |
| open scoped BigOperators |
| namespace Solenoidal.Computing |
| |
| theorem ball_point : Primrec QBall.point := Primrec.id.pair (.const 0) |
| theorem ball_add : Primrec₂ QBall.add := |
| (rat_add.comp (Primrec.fst.comp .fst) (Primrec.fst.comp .snd)).pair |
| (rat_add.comp (Primrec.snd.comp .fst) (Primrec.snd.comp .snd)) |
| theorem ball_neg : Primrec QBall.neg := (rat_neg.comp .fst).pair .snd |
| |
| theorem ball_mul : Primrec₂ QBall.mul := |
| (rat_mul.comp (Primrec.fst.comp .fst) (Primrec.fst.comp .snd)).pair |
| (rat_add.comp (rat_add.comp |
| (rat_mul.comp (rat_abs.comp (Primrec.fst.comp .fst)) (Primrec.snd.comp .snd)) |
| (rat_mul.comp (rat_abs.comp (Primrec.fst.comp .snd)) (Primrec.snd.comp .fst))) |
| (rat_mul.comp (Primrec.snd.comp .fst) (Primrec.snd.comp .snd))) |
| |
| theorem ball_pow : Primrec₂ QBall.pow := |
| (Primrec.nat_rec (.const (QBall.point 1)) |
| (ball_mul.comp (Primrec.snd.comp .snd) .fst).to₂).of_eq |
| (fun a n => by induction n with |
| | zero => rfl |
| | succ n ih => simp [QBall.pow,ih]) |
| |
| theorem rat_sum_range {α : Type*} [Primcodable α] {g : α → ℕ → ℚ} |
| (hg : Primrec₂ g) : Primrec₂ (fun a n => ∑ i ∈ Finset.range n, g a i) := |
| (Primrec.nat_rec (.const 0) |
| (rat_add.comp (Primrec.snd.comp .snd) |
| (hg.comp .fst (Primrec.fst.comp .snd))).to₂).of_eq |
| (fun a n => by induction n with |
| | zero => simp |
| | succ n ih => simp [Finset.sum_range_succ,ih]) |
| |
| theorem ball_taylor : Primrec₂ QBall.taylor := |
| rat_sum_range (rat_div.comp rat_pow (rat_nat.comp (nat_factorial.comp .snd))) |
| |
| theorem ball_smallExp : Primrec₂ QBall.smallExp := |
| (ball_taylor.comp .fst (Primrec.succ.comp .snd)).pair |
| (rat_mul.comp (.const 2) (rat_pow.comp (.const (1/2)) (Primrec.succ.comp .snd))) |
| |
| theorem ball_expScale : Primrec QBall.expScale := |
| Primrec.nat_mul.comp (.const 2) (Primrec.succ.comp (int_natAbs.comp rat_num)) |
| |
| theorem ball_expApprox : Primrec₂ QBall.expApprox := |
| ball_pow.comp (ball_smallExp.comp |
| (rat_div.comp .fst (rat_nat.comp (ball_expScale.comp .fst))) .snd) |
| (ball_expScale.comp .fst) |
| |
| theorem ball_clampInv : Primrec QBall.clampInv := |
| (rat_inv.comp (rat_max.comp (.const (1/32)) .fst)).pair |
| (rat_mul.comp (.const 512) .snd) |
| |
| theorem ball_flatApprox : Primrec (fun p : ℕ × ℚ × ℕ => QBall.flatApprox p.1 p.2.1 p.2.2) := |
| Primrec.ite (rat_le.comp (Primrec.fst.comp .snd) (.const 0)) (.const (QBall.point 0)) |
| (ball_mul.comp (ball_point.comp (rat_pow.comp (rat_inv.comp (Primrec.fst.comp .snd)) .fst)) |
| (ball_expApprox.comp (rat_neg.comp (rat_inv.comp (Primrec.fst.comp .snd))) |
| (Primrec.snd.comp .snd))) |
| |
| theorem ball_reciprocalApprox : Primrec₂ QBall.reciprocalApprox := |
| ball_clampInv.comp (ball_add.comp |
| (ball_flatApprox.comp ((Primrec.const 0).pair (Primrec.fst.pair .snd))) |
| (ball_flatApprox.comp ((Primrec.const 0).pair |
| ((rat_sub.comp (.const 1) .fst).pair .snd)))) |
| |
| end Solenoidal.Computing |
| end |
| |
| end OAI |
| |
