File size: 7,546 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 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 | import OAI.Probability.SATComputability.EffectiveLog
import OAI.MathematicalPhysics.RapidForcing.ComputableProfiles
namespace OAI
namespace FixedClauseThreshold.Computability.FiniteArithmetic
open Filter RapidForcing.EffectiveProfile RapidForcing.EffectiveArithmetic
open PeriodicLattice.CertifiedReal
open scoped Topology
local instance arithmeticEnclosuresRatPrimcodable : Primcodable ℚ := PeriodicLattice.RecursiveArithmetic.ratPrimcodable
@[fun_prop] theorem rat_max_computable : Computable (fun p : ℚ × ℚ => max p.1 p.2) := by
simpa only [max_def] using
(show Computable (fun p : ℚ × ℚ => if p.1 ≤ p.2 then p.2 else p.1) by fun_prop)
private theorem exp_effective : Effective (fun q : ℚ => Real.exp (q : ℝ)) :=
(rational (Computable.id : Computable (id : ℚ → ℚ))).exp
private theorem log_effective : Effective (fun q : ℚ => Real.log (max 1 (q : ℝ))) := by
have he : Effective (fun q : ℚ => ((max 1 q : ℚ) : ℝ)) :=
rational (show Computable (fun q : ℚ => max 1 q) by fun_prop)
simpa only [Rat.cast_max, Rat.cast_one] using he.log
(fun q => lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) (by exact_mod_cast le_max_left (1 : ℚ) q))
noncomputable def expApprox : ℚ × ℕ → ℚ := Classical.choose exp_effective
noncomputable def logApprox : ℚ × ℕ → ℚ := Classical.choose log_effective
@[fun_prop] theorem expApprox_computable : Computable expApprox := (Classical.choose_spec exp_effective).1
@[fun_prop] theorem logApprox_computable : Computable logApprox := (Classical.choose_spec log_effective).1
theorem expApprox_error (q : ℚ) (n : ℕ) :
|Real.exp (q : ℝ) - (expApprox (q,n) : ℝ)| ≤ error n :=
(Classical.choose_spec exp_effective).2 q n
theorem logApprox_error (q : ℚ) (n : ℕ) :
|Real.log (max 1 (q : ℝ)) - (logApprox (q,n) : ℝ)| ≤ error n :=
(Classical.choose_spec log_effective).2 q n
noncomputable def interval (l u : ℚ) : Ball := ⟨(l+u)/2, (u-l)/2⟩
@[fun_prop] theorem interval_computable : Computable (fun p : ℚ × ℚ => interval p.1 p.2) := by
unfold interval
fun_prop
theorem interval_covers {l u : ℚ} {x : ℝ} (hl : (l : ℝ) ≤ x) (hu : x ≤ (u : ℝ)) :
(interval l u).Covers x := by
unfold interval Ball.Covers
push_cast
exact abs_le.mpr ⟨by linarith, by linarith⟩
theorem interval_encloses {l u : ℕ → ℚ} {x : ℝ}
(hl : ∀ n, (l n : ℝ) ≤ x) (hu : ∀ n, x ≤ (u n : ℝ))
(htl : Tendsto (fun n => (l n : ℝ)) atTop (nhds x))
(htu : Tendsto (fun n => (u n : ℝ)) atTop (nhds x)) :
Encloses (fun n => interval (l n) (u n)) x := by
refine ⟨fun n => interval_covers (hl n) (hu n), ?_⟩
simpa only [interval, Rat.cast_div, Rat.cast_sub, Rat.cast_ofNat, sub_self, zero_div]
using (htu.sub htl).div_const 2
theorem approximate_tendsto {f : ℚ → ℝ} {a : ℚ × ℕ → ℚ}
(ha : ∀ q n, |f q - (a (q,n) : ℝ)| ≤ error n)
{q : ℕ → ℚ} {x : ℝ} (hq : Tendsto (fun n => f (q n)) atTop (nhds x)) :
Tendsto (fun n => (a (q n,n) : ℝ)) atTop (nhds x) := by
have hz : Tendsto (fun n => (a (q n,n) : ℝ)-f (q n)) atTop (nhds 0) := by
apply squeeze_zero_norm (fun n => ?_) error_tendsto
simpa only [Real.norm_eq_abs, abs_sub_comm] using ha (q n) n
simpa only [sub_add_cancel, zero_add] using hz.add hq
noncomputable def expBall (b : Ball) (n : ℕ) : Ball :=
interval (expApprox (b.center-b.radius,n)-qerror n)
(expApprox (b.center+b.radius,n)+qerror n)
noncomputable def logBall (b : Ball) (n : ℕ) : Ball :=
interval (logApprox (b.center-b.radius,n)-qerror n)
(logApprox (b.center+b.radius,n)+qerror n)
@[fun_prop] theorem expBall_computable : Computable (fun p : Ball × ℕ => expBall p.1 p.2) := by
unfold expBall
fun_prop
@[fun_prop] theorem logBall_computable : Computable (fun p : Ball × ℕ => logBall p.1 p.2) := by
unfold logBall
fun_prop
theorem expBall_covers {b : Ball} {x : ℝ} (hb : b.Covers x) (n : ℕ) :
(expBall b n).Covers (Real.exp x) := by
have he := abs_le.mp hb
have hl := (abs_le.mp (expApprox_error (b.center-b.radius) n)).1
have hu := (abs_le.mp (expApprox_error (b.center+b.radius) n)).2
apply interval_covers
· push_cast
have := Real.exp_le_exp.mpr (show (b.center : ℝ)-b.radius ≤ x by linarith)
simp only [Rat.cast_sub, cast_qerror] at hl ⊢
linarith
· push_cast
have := Real.exp_le_exp.mpr (show x ≤ (b.center : ℝ)+b.radius by linarith)
simp only [Rat.cast_add, cast_qerror] at hu ⊢
linarith
theorem logBall_covers {b : Ball} {x : ℝ} (hb : b.Covers x) (n : ℕ) :
(logBall b n).Covers (Real.log (max 1 x)) := by
have he := abs_le.mp hb
have hl := (abs_le.mp (logApprox_error (b.center-b.radius) n)).1
have hu := (abs_le.mp (logApprox_error (b.center+b.radius) n)).2
have hp (y : ℝ) : 0 < max 1 y := lt_of_lt_of_le (by norm_num) (le_max_left _ _)
apply interval_covers
· push_cast
have := Real.log_le_log (hp ((b.center : ℝ)-b.radius))
(max_le_max_left 1 (show (b.center : ℝ)-b.radius ≤ x by linarith))
simp only [Rat.cast_sub, cast_qerror] at hl ⊢
linarith
· push_cast
have := Real.log_le_log (hp x)
(max_le_max_left 1 (show x ≤ (b.center : ℝ)+b.radius by linarith))
simp only [Rat.cast_add, cast_qerror] at hu ⊢
linarith
theorem Encloses.exp {b : ℕ → Ball} {x : ℝ} (hb : Encloses b x) :
Encloses (fun n => expBall (b n) n) (Real.exp x) := by
have hbl : Tendsto (fun n => (((b n).center-(b n).radius : ℚ) : ℝ)) atTop (nhds x) := by
simpa only [Rat.cast_sub, sub_zero] using hb.centers.sub hb.2
have hbu : Tendsto (fun n => (((b n).center+(b n).radius : ℚ) : ℝ)) atTop (nhds x) := by
simpa only [Rat.cast_add, add_zero] using hb.centers.add hb.2
have hl := approximate_tendsto expApprox_error
(q := fun n => (b n).center-(b n).radius) (Real.continuous_exp.tendsto x |>.comp hbl)
have hu := approximate_tendsto expApprox_error
(q := fun n => (b n).center+(b n).radius) (Real.continuous_exp.tendsto x |>.comp hbu)
refine ⟨fun n => expBall_covers (hb.1 n) n, ?_⟩
have hlim := ((hu.add error_tendsto).sub (hl.sub error_tendsto)).div_const 2
simpa only [expBall, interval, Rat.cast_div, Rat.cast_sub, Rat.cast_add,
Rat.cast_ofNat, cast_qerror, add_zero, sub_zero, sub_self, zero_div] using hlim
theorem Encloses.log {b : ℕ → Ball} {x : ℝ} (hb : Encloses b x) :
Encloses (fun n => logBall (b n) n) (Real.log (max 1 x)) := by
have hp : max (1 : ℝ) x ≠ 0 := ne_of_gt (lt_of_lt_of_le (by norm_num) (le_max_left _ _))
have hbl : Tendsto (fun n => (((b n).center-(b n).radius : ℚ) : ℝ)) atTop (nhds x) := by
simpa only [Rat.cast_sub, sub_zero] using hb.centers.sub hb.2
have hbu : Tendsto (fun n => (((b n).center+(b n).radius : ℚ) : ℝ)) atTop (nhds x) := by
simpa only [Rat.cast_add, add_zero] using hb.centers.add hb.2
have hl := approximate_tendsto logApprox_error
(q := fun n => (b n).center-(b n).radius) ((tendsto_const_nhds.max hbl).log hp)
have hu := approximate_tendsto logApprox_error
(q := fun n => (b n).center+(b n).radius) ((tendsto_const_nhds.max hbu).log hp)
refine ⟨fun n => logBall_covers (hb.1 n) n, ?_⟩
have hlim := ((hu.add error_tendsto).sub (hl.sub error_tendsto)).div_const 2
simpa only [logBall, interval, Rat.cast_div, Rat.cast_sub, Rat.cast_add,
Rat.cast_ofNat, cast_qerror, add_zero, sub_zero, sub_self, zero_div] using hlim
end FixedClauseThreshold.Computability.FiniteArithmetic
end OAI
|