| import OAI.MathematicalPhysics.RapidForcing.RatComputable |
| import OAI.MathematicalPhysics.RapidForcing.FormulaCoding |
| import OAI.MathematicalPhysics.RapidForcing.RatOperations |
|
|
| namespace OAI |
|
|
| section |
| open Encodable |
| open scoped BigOperators |
| namespace RapidForcing.EffectiveProfile |
| open EffectiveArithmetic |
|
|
| private def ballEquiv : Ball ≃ ℚ × ℚ := |
| ⟨fun b => (b.center, b.radius), fun p => ⟨p.1, p.2⟩, fun _ => rfl, fun _ => rfl⟩ |
| instance : Primcodable Ball := Primcodable.ofEquiv (ℚ × ℚ) ballEquiv |
| @[fun_prop] lemma primrec_ball_center : Primrec Ball.center := by |
| exact Primrec.fst.comp (Primrec.of_equiv (e := ballEquiv)) |
| @[fun_prop] lemma primrec_ball_radius : Primrec Ball.radius := by |
| exact Primrec.snd.comp (Primrec.of_equiv (e := ballEquiv)) |
| @[fun_prop] lemma primrec_ball_mk : Primrec (fun p : ℚ × ℚ => Ball.mk p.1 p.2) := by |
| apply Primrec.encode_iff.mp |
| exact (Primrec.encode : Primrec (@encode (ℚ × ℚ) _)) |
| @[fun_prop] lemma computable_ball_exact : Computable Ball.exact := by |
| unfold Ball.exact; fun_prop |
| @[fun_prop] lemma computable_ball_add : Computable (fun p : Ball × Ball => p.1.add p.2) := by |
| unfold Ball.add; fun_prop |
| @[fun_prop] lemma computable_ball_mul : Computable (fun p : Ball × Ball => p.1.mul p.2) := by |
| unfold Ball.mul; fun_prop |
| @[fun_prop] lemma computable_ball_denInv : Computable Ball.denInv := by |
| unfold Ball.denInv; fun_prop |
| @[fun_prop] lemma computable_ball_pow : Computable (fun p : Ball × ℕ => p.1.pow p.2) := by |
| have h := Computable.nat_rec (f := fun p : Ball × ℕ => p.2) |
| (g := fun _ => Ball.exact 1) (h := fun p r => r.2.mul p.1) |
| (by fun_prop) (by fun_prop) (by unfold Computable₂; fun_prop) |
| exact h.of_eq (fun p => by induction p.2 <;> simp [Ball.pow, *]) |
|
|
| @[fun_prop] lemma computable_glueDiff : Computable glueDiff := by |
| have h := computable_list_foldr (f := id) |
| (h := fun (_ : GluePoly) (a : (ℚ × ℕ) × GluePoly) => |
| (a.1.1, a.1.2 + 2) :: (-(a.1.2 : ℚ) * a.1.1, a.1.2 + 1) :: a.2) |
| (g := fun _ => ([] : GluePoly)) |
| (by fun_prop) (by fun_prop) (by unfold Computable₂; fun_prop) |
| exact h.of_eq (fun p => by induction p <;> simp_all [glueDiff]) |
|
|
| @[fun_prop] lemma computable_glueBound : Computable glueBound := by |
| have h := computable_list_foldr (f := id) |
| (h := fun (_ : GluePoly) (a : (ℚ × ℕ) × ℚ) => |a.1.1| * (a.1.2.factorial : ℚ) + a.2) |
| (g := fun _ => (0 : ℚ)) |
| (by fun_prop) (by fun_prop) (by unfold Computable₂; fun_prop) |
| exact h.of_eq (fun p => by induction p <;> simp_all [glueBound]) |
|
|
| lemma computable_sum_range {A S : Type} [Primcodable A] [Primcodable S] [AddCommMonoid S] |
| (hadd : Computable (fun p : S × S => p.1 + p.2)) |
| {n : A → ℕ} (hn : Computable n) {f : A → ℕ → S} (hf : Computable₂ f) : |
| Computable (fun a => ∑ j ∈ Finset.range (n a), f a j) := by |
| have h := Computable.nat_rec hn (Computable.const (0 : S)) |
| (h := fun a r => r.2 + f a r.1) |
| (hadd.comp ((Computable.snd.comp Computable.snd).pair (hf.comp Computable.fst (Computable.fst.comp Computable.snd)))).to₂ |
| apply h.of_eq |
| intro a |
| induction n a <;> simp [Finset.sum_range_succ, *] |
|
|
| @[fun_prop] lemma computable_expTerms : Computable (fun p : ℚ × ℕ => expTerms p.1 p.2) := by |
| unfold expTerms; fun_prop |
| private lemma computable_taylor_term : Computable (fun p : (ℚ × ℕ) × ℕ => |
| p.1.1 ^ p.2 / (p.2.factorial : ℚ)) := by fun_prop |
| private lemma computable_taylor_sum : Computable (fun p : ℚ × ℕ => |
| ∑ j ∈ Finset.range (expTerms p.1 p.2), p.1 ^ j / (j.factorial : ℚ)) := |
| computable_sum_range computable_rat_add computable_expTerms computable_taylor_term.to₂ |
| private lemma computable_taylor_error_fn : Computable (fun p : ℚ × ℕ => |
| |p.1| ^ p.2 / (p.2.factorial : ℚ) * 2) := by fun_prop |
| lemma computable_expBall : Computable (fun p : ℚ × ℕ => expBall p.1 p.2) := by |
| have herr : Computable (fun p : ℚ × ℕ => |
| (p.1, expTerms p.1 p.2)) := Computable.fst.pair computable_expTerms |
| have h := primrec_ball_mk.to_comp.comp |
| (computable_taylor_sum.pair (computable_taylor_error_fn.comp herr)) |
| exact h.of_eq (fun p => rfl) |
| @[fun_prop] lemma computable_monoBall : Computable (fun p : ℕ × ℚ × ℕ => monoBall p.1 p.2.1 p.2.2) := by |
| have harg : Computable (fun p : ℕ × ℚ × ℕ => (-(p.2.1)⁻¹, p.2.2)) := by fun_prop |
| have he := computable_expBall.comp harg |
| have hx : Computable (fun p : ℕ × ℚ × ℕ => Ball.exact (p.2.1⁻¹ ^ p.1)) := by fun_prop |
| have hm := computable_ball_mul.comp (hx.pair he) |
| have hi := computable_ite (p := fun p : ℕ × ℚ × ℕ => p.2.1 ≤ 0) |
| (by fun_prop) (Computable.const (Ball.exact 0)) hm |
| exact hi.of_eq (fun p => rfl) |
| @[fun_prop] lemma computable_glueBall : Computable (fun p : GluePoly × ℚ × ℕ => glueBall p.1 p.2.1 p.2.2) := by |
| have h := computable_list_foldr (f := fun p : GluePoly × ℚ × ℕ => p.1) |
| (h := fun p (a : (ℚ × ℕ) × Ball) => ((Ball.exact a.1.1).mul (monoBall a.1.2 p.2.1 p.2.2)).add a.2) |
| (g := fun _ => Ball.exact 0) |
| (by fun_prop) (by fun_prop) (by unfold Computable₂; fun_prop) |
| exact h.of_eq (fun p => by induction p.1 <;> simp [glueBall, *]) |
|
|
| @[fun_prop] lemma Expr.computable_bound : Computable Expr.bound := by |
| have h := Expr.computable_recOn (e := id) Computable.id |
| (c := fun _ q => |q|) (by unfold Computable₂; fun_prop) |
| (l := fun _ p => glueBound p) (by unfold Computable₂; fun_prop) |
| (r := fun _ p => glueBound p) (by unfold Computable₂; fun_prop) |
| (d := fun _ n => (16 : ℚ) ^ n) (by unfold Computable₂; fun_prop) |
| (a := fun _ p => p.2.2.1 + p.2.2.2) (by unfold Computable₂; fun_prop) |
| (m := fun _ p => p.2.2.1 * p.2.2.2) (by unfold Computable₂; fun_prop) |
| exact h.of_eq (fun e => by induction e <;> simp_all only [id_eq, bound]) |
|
|
| @[fun_prop] lemma Expr.computable_diff : Computable Expr.diff := by |
| have h := Expr.computable_recOn (e := id) Computable.id |
| (c := fun _ _ => Expr.const 0) (by unfold Computable₂; fun_prop) |
| (l := fun _ p => Expr.left (glueDiff p)) (by unfold Computable₂; fun_prop) |
| (r := fun _ p => Expr.mul (.const (-1)) (.right (glueDiff p))) (by unfold Computable₂; fun_prop) |
| (d := fun _ n => Expr.mul (.mul (.const (-(n : ℚ))) |
| (.add (.left (glueDiff [(1, 0)])) (.mul (.const (-1)) (.right (glueDiff [(1, 0)]))))) |
| (.invDen (n + 1))) (by unfold Computable₂; fun_prop) |
| (a := fun _ p => Expr.add p.2.2.1 p.2.2.2) (by unfold Computable₂; fun_prop) |
| (m := fun _ p => Expr.add (.mul p.2.2.1 p.2.1) (.mul p.1 p.2.2.2)) (by unfold Computable₂; fun_prop) |
| exact h.of_eq (fun e => by induction e <;> simp_all only [id_eq, diff]) |
|
|
| @[fun_prop] lemma Expr.computable_numeric : Computable (fun p : Expr × ℚ × ℕ => p.1.numeric p.2.1 p.2.2) := by |
| have h := Expr.computable_recOn (e := fun p : Expr × ℚ × ℕ => p.1) (by fun_prop) |
| (c := fun _ q => Ball.exact q) (by unfold Computable₂; fun_prop) |
| (l := fun a p => glueBall p a.2.1 a.2.2) (by unfold Computable₂; fun_prop) |
| (r := fun a p => glueBall p (1 - a.2.1) a.2.2) (by unfold Computable₂; fun_prop) |
| (d := fun a n => ((glueBall [(1, 0)] a.2.1 a.2.2).add |
| (glueBall [(1, 0)] (1 - a.2.1) a.2.2)).denInv.pow n) (by unfold Computable₂; fun_prop) |
| (a := fun _ p => p.2.2.1.add p.2.2.2) (by unfold Computable₂; fun_prop) |
| (m := fun _ p => p.2.2.1.mul p.2.2.2) (by unfold Computable₂; fun_prop) |
| exact h.of_eq (fun p => by induction p.1 <;> simp [numeric, *]) |
|
|
| lemma Expr.partrec_approx : Partrec (fun p : Expr × ℚ × ℚ => p.1.approx p.2.1 p.2.2) := by |
| apply Partrec.rfindOpt |
| unfold Computable₂ |
| fun_prop |
| end RapidForcing.EffectiveProfile |
|
|
| end |
|
|
| end OAI |
|
|
