| import OAI.Analysis.PeriodicLattice.ElementaryFunctions |
| import OAI.MathematicalPhysics.RapidForcing.RatOperations |
| import OAI.MathematicalPhysics.RapidForcing.RecursiveComputable |
|
|
| namespace OAI |
|
|
| namespace PeriodicLattice.CertifiedReal |
|
|
| open Encodable Filter |
| open scoped Topology |
| local instance effectiveLogRatPrimcodable : Primcodable ℚ := RecursiveArithmetic.ratPrimcodable |
|
|
| section |
| variable {A : Type*} [Primcodable A] |
|
|
| def logLower (z : ℕ) : ℚ := (decode z.unpair.1).getD 0 |
| def logUpper (z : ℕ) : ℚ := (decode z.unpair.2.unpair.1).getD 0 |
| def logAccuracy (z : ℕ) : ℕ := z.unpair.2.unpair.2 |
|
|
| @[fun_prop] theorem logLower_computable : Computable logLower := by |
| unfold logLower |
| fun_prop |
| @[fun_prop] theorem logUpper_computable : Computable logUpper := by |
| unfold logUpper |
| fun_prop |
| @[fun_prop] theorem logAccuracy_computable : Computable logAccuracy := by |
| unfold logAccuracy |
| fun_prop |
|
|
| abbrev logTest (q : A × ℕ → ℚ) (e : ℚ × ℕ → ℚ) (an : A × ℕ) (z : ℕ) : Prop := |
| logUpper z - logLower z ≤ 2*qerror an.2 ∧ |
| e (logLower z, logAccuracy z) + 2*qerror (logAccuracy z) < q (an.1, logAccuracy z) ∧ |
| q (an.1, logAccuracy z) + 2*qerror (logAccuracy z) < e (logUpper z, logAccuracy z) |
| |
| instance logTest_decidable (q : A × ℕ → ℚ) (e : ℚ × ℕ → ℚ) (an : A × ℕ) (z : ℕ) : |
| Decidable (logTest q e an z) := inferInstanceAs (Decidable (_ ∧ _ ∧ _)) |
| |
| theorem logTest_computable {q : A × ℕ → ℚ} {e : ℚ × ℕ → ℚ} |
| (hq : Computable q) (he : Computable e) : |
| Computable (fun p : (A × ℕ) × ℕ => decide (logTest q e p.1 p.2)) := by |
| unfold logTest |
| simp only [Bool.decide_and] |
| apply Primrec.and.to_comp.comp |
| · exact RecursiveArithmetic.ratLE.decide.to_comp.comp (by fun_prop) (by fun_prop) |
| · apply Primrec.and.to_comp.comp |
| · exact RecursiveArithmetic.ratLT.decide.to_comp.comp (by fun_prop) (by fun_prop) |
| · exact RecursiveArithmetic.ratLT.decide.to_comp.comp (by fun_prop) (by fun_prop) |
| |
| omit [Primcodable A] in |
| theorem logTest_exists {f : A → ℝ} (q : A × ℕ → ℚ) (e : ℚ × ℕ → ℚ) |
| (eq : ∀ a n, |f a - (q (a,n) : ℝ)| ≤ error n) |
| (ee : ∀ (a : ℚ) n, |Real.exp (a : ℝ) - (e (a,n) : ℝ)| ≤ error n) |
| (hpos : ∀ a, 0 < f a) (an : A × ℕ) : ∃ z, logTest q e an z := by |
| obtain ⟨l, hl, hl'⟩ := exists_rat_btwn |
| (show Real.log (f an.1) - error an.2 < Real.log (f an.1) by linarith [error_pos an.2]) |
| obtain ⟨u, hu, hu'⟩ := exists_rat_btwn |
| (show Real.log (f an.1) < Real.log (f an.1) + error an.2 by linarith [error_pos an.2]) |
| have hlExp : Real.exp (l : ℝ) < f an.1 := by |
| rw [← Real.exp_log (hpos an.1)] |
| exact Real.exp_lt_exp.mpr hl' |
| have huExp : f an.1 < Real.exp (u : ℝ) := by |
| rw [← Real.exp_log (hpos an.1)] |
| exact Real.exp_lt_exp.mpr hu |
| have tq := Effective.approximants_tendsto eq an.1 |
| have tl := Effective.approximants_tendsto ee l |
| have tu := Effective.approximants_tendsto ee u |
| have tl' := (tl.add (error_tendsto.const_mul 2)).eventually_lt tq |
| (by simpa using hlExp) |
| have tu' := (tq.add (error_tendsto.const_mul 2)).eventually_lt tu |
| (by simpa using huExp) |
| obtain ⟨s, hs, hs'⟩ := (tl'.and tu').exists |
| refine ⟨Nat.pair (encode l) (Nat.pair (encode u) s), ?_⟩ |
| have hw : u-l ≤ 2*qerror an.2 := by |
| have : (u : ℝ)-(l : ℝ) ≤ 2*error an.2 := by linarith |
| exact_mod_cast (show (u : ℝ)-(l : ℝ) ≤ 2*(qerror an.2 : ℝ) by simpa using this) |
| have hsl : e (l,s)+2*qerror s < q (an.1,s) := by |
| exact_mod_cast (show (e (l,s) : ℝ)+2*(qerror s : ℝ) < (q (an.1,s) : ℝ) by simpa using hs) |
| have hsu : q (an.1,s)+2*qerror s < e (u,s) := by |
| exact_mod_cast (show (q (an.1,s) : ℝ)+2*(qerror s : ℝ) < (e (u,s) : ℝ) by simpa using hs') |
| simpa only [logTest, logLower, logUpper, logAccuracy, Nat.unpair_pair, encodek, Option.getD_some] |
| using And.intro hw (And.intro hsl hsu) |
| |
| omit [Primcodable A] in |
| theorem logTest_sound {f : A → ℝ} (q : A × ℕ → ℚ) (e : ℚ × ℕ → ℚ) |
| (eq : ∀ a n, |f a - (q (a,n) : ℝ)| ≤ error n) |
| (ee : ∀ (a : ℚ) n, |Real.exp (a : ℝ) - (e (a,n) : ℝ)| ≤ error n) |
| (hpos : ∀ a, 0 < f a) (a : A) (n z : ℕ) (hs : logTest q e (a,n) z) : |
| |Real.log (f a) - (((logLower z+logUpper z)/2 : ℚ) : ℝ)| ≤ error n := by |
| obtain ⟨hw, hl, hu⟩ := hs |
| have el := ee (logLower z) (logAccuracy z) |
| have eu := ee (logUpper z) (logAccuracy z) |
| have ef := eq a (logAccuracy z) |
| have hlr : (e (logLower z,logAccuracy z) : ℝ)+2*error (logAccuracy z) < q (a,logAccuracy z) := by |
| simpa only [cast_qerror] using (show (e (logLower z,logAccuracy z) : ℝ)+2*(qerror (logAccuracy z) : ℝ) < |
| (q (a,logAccuracy z) : ℝ) by exact_mod_cast hl) |
| have hur : (q (a,logAccuracy z) : ℝ)+2*error (logAccuracy z) < e (logUpper z,logAccuracy z) := by |
| simpa only [cast_qerror] using (show (q (a,logAccuracy z) : ℝ)+2*(qerror (logAccuracy z) : ℝ) < |
| (e (logUpper z,logAccuracy z) : ℝ) by exact_mod_cast hu) |
| have hlo : Real.exp (logLower z : ℝ) < f a := by |
| have h1 := (abs_le.mp el).2 |
| have h2 := (abs_le.mp ef).1 |
| linarith |
| have hhi : f a < Real.exp (logUpper z : ℝ) := by |
| have h1 := (abs_le.mp eu).1 |
| have h2 := (abs_le.mp ef).2 |
| linarith |
| have hloglo : (logLower z : ℝ) < Real.log (f a) := by |
| rw [← Real.exp_log (hpos a)] at hlo |
| exact Real.exp_lt_exp.mp hlo |
| have hloghi : Real.log (f a) < (logUpper z : ℝ) := by |
| rw [← Real.exp_log (hpos a)] at hhi |
| exact Real.exp_lt_exp.mp hhi |
| have hwidth : (logUpper z : ℝ)-(logLower z : ℝ) ≤ 2*error n := by |
| simpa only [cast_qerror] using |
| (show (logUpper z : ℝ)-(logLower z : ℝ) ≤ 2*(qerror n : ℝ) by exact_mod_cast hw) |
| change |Real.log (f a) - (((logLower z+logUpper z)/2 : ℚ) : ℝ)| ≤ error n |
| push_cast |
| exact abs_le.mpr ⟨by linarith, by linarith⟩ |
| |
| theorem Effective.log {f : A → ℝ} (hf : Effective f) (hpos : ∀ a, 0 < f a) : |
| Effective (fun a => Real.log (f a)) := by |
| obtain ⟨q, hq, eq⟩ := hf |
| obtain ⟨e, he, ee⟩ := (rational (Computable.id : Computable (id : ℚ → ℚ))).exp |
| change ∀ (a : ℚ) (n : ℕ), |Real.exp (a : ℝ) - (e (a,n) : ℝ)| ≤ error n at ee |
| have hex := logTest_exists q e eq ee hpos |
| let pick (an : A × ℕ) := Nat.find (hex an) |
| have hpick : Computable pick := computable_find (logTest_computable hq he) hex |
| refine ⟨fun an => (logLower (pick an)+logUpper (pick an))/2, by fun_prop, ?_⟩ |
| intro a n |
| exact logTest_sound q e eq ee hpos a n (pick (a,n)) (Nat.find_spec (hex (a,n))) |
| |
| end |
| end PeriodicLattice.CertifiedReal |
| |
| end OAI |
| |
