File size: 6,640 Bytes
a2ee19a | 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 | 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
|