Download data/lean/OAI/Probability/SATComputability/EffectiveLog.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 6.64 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/SATComputability/EffectiveLog.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/SATComputability/EffectiveLog.lean
-
curl -L -o EffectiveLog.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/SATComputability/EffectiveLog.lean
6.64 kB
| 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 | |