Hugging Face's logo

Datasets:
roseking
/
openAI-math-dataset

Languages:
English
Chinese
Size:
100K<n<1M
Tags:
mathematics
mirror
lean
formal-proofs
License:
Dataset card Files
xet
 Community
openAI-math-dataset / lean /OAI /Probability /LogConcave /Complexity /KernelAnalyticNormalizedBudget.lean
roseking's picture
roseking
Add lean source and binary files (part 125)
dd14c26 verified
Raw History Blame Contribute Delete
21.1 kB
import Mathlib
import OAI.Probability.LogConcave.Numerics.TwoendsContinuous
import OAI.Probability.LogConcave.Complexity.KernelActionNormalizedBudget
namespace OAI
section
noncomputable section
namespace LogConcaveSampling
open Set MeasureTheory Quadrature
open scoped Classical BigOperators NNReal
def kernelAnalyticNormalizedBudget (n d : ℕ) (T h D : ℝ) : ℝ :=
32*(1+D^2+(∑i,|zeroHermiteWeight (probabilityNodes (n+1)) 0 i|)^2)*
(2*logMeshLength T*(Real.exp (Real.pi^2/4)*(TensorSum.terminalQ (n+1)).val.logCoefficient 0 2)*
(1+Real.log ((d:ℝ)+1))^((TensorSum.terminalQ (n+1)).val.logDegree 0)*2^(n+1)*h^n)^2
lemma kernelAnalyticNormalizedBudget_nonneg (n d : ℕ) (T h D : ℝ) :
0≤kernelAnalyticNormalizedBudget n d T h D := by
unfold kernelAnalyticNormalizedBudget
positivity
lemma kernelAnalyticBudget_normalized {d : ℕ} (F : Point d → ℝ) (x : Point d)
(lam : ℝ≥0) (r D : ℝ) {T h : ℝ} (hT0 : 0<T) (hT1 : T<1) (hh : 0≤h) (n : ℕ) :
kernelAnalyticBudget n d lam r T h D≤
(((lam:ℝ)*r^2)*circuitD F x)^2*kernelAnalyticNormalizedBudget n d T h D := by
have hp := terminalDerivativeBudget_polylog (n+1) d lam r
have ht := terminalDerivativeBudget_nonneg (n+1) d lam r
have hlen := (logMeshLength_pos hT0 hT1).le
have hd := circuitD_dimension F x
unfold kernelAnalyticBudget kernelAnalyticNormalizedBudget
calc
_ ≤ 32*(1+D^2+(∑i,|zeroHermiteWeight (probabilityNodes (n+1)) 0 i|)^2)*
(2*logMeshLength T*((lam:ℝ)*r^2*
(Real.exp (Real.pi^2/4)*(TensorSum.terminalQ (n+1)).val.logCoefficient 0 2)*
(1+Real.log ((d:ℝ)+1))^((TensorSum.terminalQ (n+1)).val.logDegree 0))*2^(n+1)*h^n)^2*
(circuitD F x)^2 := by gcongr
_ = _ := by ring
def velocityNormalizedBudget (d k n m N : ℕ) (lam Ap Ah Lp : ℝ≥0)
(r R T h ψ C J D : ℝ) : ℝ :=
2*(∑v,|terminalQuadratureWeight T h n v|)^2*
kernelActionNormalizedBudget d k (n+1) m N lam Ap Ah Lp r R h ψ C J+
2*kernelAnalyticNormalizedBudget n d T h D
lemma velocityNormalizedBudget_nonneg (d k n m N : ℕ) (lam Ap Ah Lp : ℝ≥0)
(r R T h ψ C J D : ℝ) (hR : 0≤R) :
0≤velocityNormalizedBudget d k n m N lam Ap Ah Lp r R T h ψ C J D := by
unfold velocityNormalizedBudget
positivity [kernelActionNormalizedBudget_nonneg d k (n+1) m N lam Ap Ah Lp r R h ψ C J hR,
kernelAnalyticNormalizedBudget_nonneg n d T h D]
theorem velocityRmsBudget_normalized {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0}
(hF : Primitive F lam) (x : Point d) (Ap Ah Lp : ℝ≥0) {r R T h ψ s C J D : ℝ}
(hr : 0<r) (hr1 : r≤1) (hR : 0<R) (hT0 : 0<T) (hT1 : T<1)
(hh : 0<h) (hψ : 0<ψ) (hs : 0<s) (hC : 0≤C) (hJ : 0≤J)
(hl : (lam:ℝ)*r^2≤1/2) (hL : (lam:ℝ)*r≤1) (k n m N : ℕ) :
(r*s)⁻¹^2*(2*((∑v,|terminalQuadratureWeight T h n v|)*
(∑v,|terminalQuadratureWeight T h n v| *
kernelActionRmsBudget F x lam Ap Ah Lp r R (probabilityNodeTime T h (n+1) v) h ψ C J k (n+1) m N))+
2*kernelAnalyticBudget n d lam r T h D)≤
(((lam:ℝ)*r/s)*circuitD F x)^2*
velocityNormalizedBudget d k n m N lam Ap Ah Lp r R T h ψ C J D := by
let Q := ∑v,|terminalQuadratureWeight T h n v|
let E := kernelActionNormalizedBudget d k (n+1) m N lam Ap Ah Lp r R h ψ C J
let B := (((lam:ℝ)*r^2)*circuitD F x)^2
have hq : 0≤Q := by dsimp [Q]; positivity
have hp (v : ProbabilityNode T h (n+1)) :
kernelActionRmsBudget F x lam Ap Ah Lp r R (probabilityNodeTime T h (n+1) v) h ψ C J k (n+1) m N≤B*E := by
have hv := probabilityNodeTime_mem hT0 hT1 hh (by omega : 0<n+1) v
exact kernelActionRmsBudget_normalized hF x Ap Ah Lp hr.le hr1 hR hh.le hψ hC hJ hl hL
hv.1 (hv.2.trans_lt hT1) k (n+1) m N
have hw := weighted_uniform_upper (fun v => |terminalQuadratureWeight T h n v|) _
(fun v => abs_nonneg _) hp
have ha := kernelAnalyticBudget_normalized F x lam r D hT0 hT1 hh.le n
have hb := mul_le_mul_of_nonneg_left
(add_le_add (mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_left hw hq) (by norm_num : (0:ℝ)≤2))
(mul_le_mul_of_nonneg_left ha (by norm_num : (0:ℝ)≤2)))
(sq_nonneg ((r*s)⁻¹))
apply hb.trans_eq
dsimp [Q,E,B,velocityNormalizedBudget]
field_simp
end LogConcaveSampling
end
end
section
noncomputable section
namespace LogConcaveSampling
open Set MeasureTheory Quadrature
open scoped Classical BigOperators NNReal
lemma square_root_two_budget {A B : ℝ} (hA : 0≤A) (hB : 0≤B) (q : ℝ) (N : ℕ) :
(2*Real.sqrt A+q^N*Real.sqrt B)^2≤8*A+2*q^(2*N)*B := by
have hsA := Real.sq_sqrt hA
have hsB := Real.sq_sqrt hB
have he : q^(2*N)*B=(q^N*Real.sqrt B)^2 := by
rw [show 2*N=N*2 by omega,pow_mul,mul_pow,hsB]
nlinarith [sq_nonneg (2*Real.sqrt A-q^N*Real.sqrt B)]
def centerStateQuadratureEnvelope (n : ℕ) (α R : ℝ) : ℝ :=
8*(singleCellBasisBudget n)^2*(α^2*(R⁻¹)^4)^(n+2)*centeringStateBudget (n+2)
def centerInitialEnvelope (α R : ℝ) : ℝ :=
2*(α^2*(R⁻¹)^4)*centeringStateBudget 1
def centerStateEnvelope (n N : ℕ) (α R q E : ℝ) : ℝ :=
8*(2*(centeringRowBudget n:ℝ)^2*α^2*E+2*centerStateQuadratureEnvelope n α R)+
2*q^(2*N)*centerInitialEnvelope α R
def centerMeanEnvelope (n : ℕ) (α R Z : ℝ) : ℝ :=
2*(centeringRowBudget n:ℝ)^2*(Real.pi^2/2)^2*α^2*Z+
8*(singleCellBasisBudget n)^2*α^2*(α^2*(R⁻¹)^4)^(n+1)*centeringMeanBudget (n+1)
lemma centerStateQuadratureEnvelope_nonneg (n : ℕ) (α R : ℝ) :
0≤centerStateQuadratureEnvelope n α R := by
unfold centerStateQuadratureEnvelope
positivity [centeringStateBudget_nonneg (n+2)]
lemma centerInitialEnvelope_nonneg (α R : ℝ) : 0≤centerInitialEnvelope α R := by
unfold centerInitialEnvelope
positivity [centeringStateBudget_nonneg 1]
lemma centerStateEnvelope_nonneg (n N : ℕ) (α R q E : ℝ) (hq : 0≤q) (hE : 0≤E) :
0≤centerStateEnvelope n N α R q E := by
unfold centerStateEnvelope
positivity [centerStateQuadratureEnvelope_nonneg n α R,centerInitialEnvelope_nonneg α R]
lemma centerMeanEnvelope_nonneg (n : ℕ) (α R Z : ℝ) (hZ : 0≤Z) :
0≤centerMeanEnvelope n α R Z := by
unfold centerMeanEnvelope
positivity [centeringMeanBudget_nonneg (n+1)]
lemma centeringStateQuadratureBudget_normalized {d : ℕ} (F : Point d → ℝ) (x : Point d)
(n : ℕ) (lam : ℝ≥0) (r R s : ℝ) :
centeringStateQuadratureBudget n d lam r R s≤
(circuitD F x)^2*centerStateQuadratureEnvelope n ((lam:ℝ)*r/s) R := by
have hd := circuitD_dimension F x
have hc := centeringStateBudget_nonneg (n+2)
unfold centeringStateQuadratureBudget centerStateQuadratureEnvelope
push_cast
nlinarith [mul_le_mul_of_nonneg_right hd
(show 0≤8*(singleCellBasisBudget n)^2*(((lam:ℝ)*r/s)^2*(R⁻¹)^4)^(n+2)*centeringStateBudget (n+2) by positivity)]
lemma centeringInitialBudget_normalized {d : ℕ} (F : Point d → ℝ) (x : Point d)
(lam : ℝ≥0) (r R s : ℝ) :
centeringInitialBudget d lam r R s≤
(circuitD F x)^2*centerInitialEnvelope ((lam:ℝ)*r/s) R := by
have hd := circuitD_dimension F x
have hc := centeringStateBudget_nonneg 1
unfold centeringInitialBudget centerInitialEnvelope
push_cast
nlinarith [mul_le_mul_of_nonneg_right hd
(show 0≤2*(((lam:ℝ)*r/s)^2*(R⁻¹)^4)*centeringStateBudget 1 by positivity)]
lemma centeringPicardBudget_normalized {d : ℕ} (F : Point d → ℝ) (x : Point d)
(n N : ℕ) (lam K : ℝ≥0) (r R s E : ℝ) (hE : 0≤E) :
centeringPicardBudget n N d lam K r R s ((((lam:ℝ)*r/s)*circuitD F x)^2*E)≤
(circuitD F x)^2*centerStateEnvelope n N ((lam:ℝ)*r/s) R (centeringRowBudget n*K:ℝ≥0) E := by
have hQ := centeringStateQuadratureBudget_normalized F x n lam r R s
have hI := centeringInitialBudget_normalized F x lam r R s
unfold centeringPicardBudget
apply (square_root_two_budget
(by positivity [centeringStateQuadratureBudget_nonneg n d lam r R s])
(by unfold centeringInitialBudget; positivity [centeringStateBudget_nonneg 1])
(centeringRowBudget n*K:ℝ≥0) N).trans
have hq : 0≤((centeringRowBudget n*K:ℝ≥0):ℝ)^(2*N) := by positivity
have hQ' := mul_le_mul_of_nonneg_left hQ (by norm_num : (0:ℝ)≤16)
have hI' := mul_le_mul_of_nonneg_left hI (show 0≤2*((centeringRowBudget n*K:ℝ≥0):ℝ)^(2*N) by positivity)
unfold centerStateEnvelope
nlinarith
lemma centeringMeanBudget_normalized {d : ℕ} (F : Point d → ℝ) (x : Point d)
(n : ℕ) (lam : ℝ≥0) (r R : ℝ) {s T Z : ℝ} (hs : 0<s) (hT0 : 0≤T) (hT1 : T≤1) (hZ : 0≤Z) :
2*(centeringRowBudget n:ℝ)^2*((Real.pi^2/2)*T*((lam:ℝ)*r))^2*((circuitD F x)^2*Z)+
2*centeringMeanQuadratureBudget n d lam r R s≤
(s*circuitD F x)^2*centerMeanEnvelope n ((lam:ℝ)*r/s) R Z := by
have hd := circuitD_dimension F x
have hc := centeringMeanBudget_nonneg (n+1)
have hT : T^2≤1 := by nlinarith
have he₁ := mul_le_mul_of_nonneg_left hT
(show 0≤2*(centeringRowBudget n:ℝ)^2*(Real.pi^2/2)^2*((lam:ℝ)*r)^2*(circuitD F x)^2*Z by positivity)
have he₂ := mul_le_mul_of_nonneg_right hd
(show 0≤8*(singleCellBasisBudget n)^2*((lam:ℝ)*r)^2*
(((lam:ℝ)*r/s)^2*(R⁻¹)^4)^(n+1)*centeringMeanBudget (n+1) by positivity)
have hid : (s*circuitD F x)^2*centerMeanEnvelope n ((lam:ℝ)*r/s) R Z=
2*(centeringRowBudget n:ℝ)^2*(Real.pi^2/2)^2*((lam:ℝ)*r)^2*(circuitD F x)^2*Z+
8*(singleCellBasisBudget n)^2*((lam:ℝ)*r)^2*
(((lam:ℝ)*r/s)^2*(R⁻¹)^4)^(n+1)*centeringMeanBudget (n+1)*(circuitD F x)^2 := by
unfold centerMeanEnvelope
field_simp
rw [hid]
unfold centeringMeanQuadratureBudget
nlinarith
end LogConcaveSampling
end
end
section
noncomputable section
namespace LogConcaveSampling
open Filter Asymptotics
open scoped Topology
def dimensionLog (d : ℕ) : ℝ := 1+Real.log ((d:ℝ)+1)
lemma dimensionLog_nonneg (d : ℕ) : 0≤dimensionLog d := by
have hh : 0≤Real.log ((d:ℝ)+1) := Real.log_nonneg (by linarith [Nat.cast_nonneg (α:=ℝ) d])
unfold dimensionLog
linarith
lemma dimensionLog_isBigO_log : dimensionLog =O[atTop] (fun d : ℕ => Real.log (d:ℝ)) := by
have ht : Tendsto (fun d : ℕ => (d:ℝ)) atTop atTop := tendsto_natCast_atTop_atTop
have hlog : ∀ᶠ d : ℕ in atTop,1≤Real.log (d:ℝ) :=
(Real.tendsto_log_atTop.comp ht).eventually_ge_atTop 1
apply IsBigO.of_bound 3
filter_upwards [eventually_ge_atTop (2:ℕ),hlog] with d hd hl
have hd0 : (0:ℝ)<d := by exact_mod_cast (by omega : 0<d)
have hd1 : (2:ℝ)≤d := by exact_mod_cast hd
have ht : Real.log ((d:ℝ)+1)≤2*Real.log (d:ℝ) := by
calc
_ ≤ Real.log ((d:ℝ)^2) := Real.log_le_log (by positivity) (by nlinarith)
_ = _ := by rw [Real.log_pow]; norm_num
rw [Real.norm_of_nonneg (dimensionLog_nonneg d),Real.norm_of_nonneg (by linarith : 0≤Real.log (d:ℝ))]
unfold dimensionLog
linarith
lemma dimensionLog_pow_isLittleO (k : ℕ) {s : ℝ} (hs : 0<s) :
(fun d : ℕ => dimensionLog d^k) =o[atTop] (fun d : ℕ => (d:ℝ)^s) := by
have hh := (isLittleO_log_rpow_rpow_atTop (k:ℝ) hs).comp_tendsto
(tendsto_natCast_atTop_atTop (R:=ℝ))
simp only [Real.rpow_natCast,Function.comp_def] at hh
exact (dimensionLog_isBigO_log.pow k).trans_isLittleO hh
theorem polylog_power_absorb (C : ℝ) (k : ℕ) {a b : ℝ} (hab : b<a) :
∀ᶠ d : ℕ in atTop, |C| *dimensionLog d^k*(d:ℝ)^(-a)≤(d:ℝ)^(-b) := by
have hh := ((dimensionLog_pow_isLittleO k (sub_pos.mpr hab)).const_mul_left |C|).mul_isBigO
(isBigO_refl (fun d : ℕ => (d:ℝ)^(-a)) atTop)
have he : (fun d : ℕ => (d:ℝ)^(a-b)*(d:ℝ)^(-a)) =ᶠ[atTop]
(fun d : ℕ => (d:ℝ)^(-b)) := by
filter_upwards [eventually_ge_atTop (1:ℕ)] with d hd
have hd0 : (0:ℝ)<d := by exact_mod_cast hd
rw [←Real.rpow_add hd0]
congr 1
ring
have hbnd := (hh.congr' Filter.EventuallyEq.rfl he).def (by norm_num : (0:ℝ)<1)
filter_upwards [hbnd] with d hd
simpa only [one_mul,Real.norm_of_nonneg (by positivity [dimensionLog_nonneg d] : 0≤|C| *dimensionLog d^k*(d:ℝ)^(-a)),
Real.norm_of_nonneg (by positivity : 0≤(d:ℝ)^(-b))] using hd
end LogConcaveSampling
end
end
section
noncomputable section
namespace LogConcaveSampling
open Filter Asymptotics
open scoped Topology
def LogPowerRate (f : ℕ → ℝ) (a : ℝ) : Prop :=
∃k : ℕ, f =O[atTop] (fun d => dimensionLog d^k*(d:ℝ)^(-a))
lemma dimensionLog_one_le (d : ℕ) : 1≤dimensionLog d := by
unfold dimensionLog
have h := Real.log_nonneg (by linarith [Nat.cast_nonneg (α:=ℝ) d] : 1≤(d:ℝ)+1)
linarith
namespace LogPowerRate
lemma congr {f g : ℕ → ℝ} {a : ℝ} (h : LogPowerRate f a) (he : f=ᶠ[atTop] g) : LogPowerRate g a := by
obtain ⟨k,hk⟩ := h
exact ⟨k,hk.congr' he Filter.EventuallyEq.rfl⟩
lemma mono {f : ℕ → ℝ} {a b : ℝ} (h : LogPowerRate f a) (hba : b≤a) : LogPowerRate f b := by
obtain ⟨k,hk⟩ := h
refine ⟨k,hk.trans (IsBigO.of_bound 1 ?_)⟩
filter_upwards [eventually_ge_atTop (1:ℕ)] with d hd
have hd1 : (1:ℝ)≤d := by exact_mod_cast hd
have hd0 : (0:ℝ)<d := lt_of_lt_of_le zero_lt_one hd1
simp only [one_mul,Real.norm_of_nonneg (by positivity [dimensionLog_nonneg d] :
0≤dimensionLog d^k*(d:ℝ)^(-a)), Real.norm_of_nonneg (by positivity [dimensionLog_nonneg d] :
0≤dimensionLog d^k*(d:ℝ)^(-b))]
exact mul_le_mul_of_nonneg_left (Real.rpow_le_rpow_of_exponent_le hd1 (by linarith)) (by positivity [dimensionLog_nonneg d])
lemma const (C : ℝ) : LogPowerRate (fun _ => C) 0 := by
refine ⟨0,?_⟩
simpa only [pow_zero,neg_zero,Real.rpow_zero,mul_one] using
(isBigO_const_const C (by norm_num : (1:ℝ)≠0) atTop : (fun _ : ℕ => C)=O[atTop] (fun _ => (1:ℝ)))
lemma power (a : ℝ) : LogPowerRate (fun d => (d:ℝ)^(-a)) a := by
refine ⟨0,?_⟩
simpa only [pow_zero,one_mul] using (isBigO_refl (fun d : ℕ => (d:ℝ)^(-a)) atTop)
lemma log : LogPowerRate dimensionLog 0 := by
refine ⟨1,?_⟩
simpa only [pow_one,neg_zero,Real.rpow_zero,mul_one] using (isBigO_refl dimensionLog atTop)
lemma mul {f g : ℕ → ℝ} {a b : ℝ} (hf : LogPowerRate f a) (hg : LogPowerRate g b) :
LogPowerRate (fun d => f d*g d) (a+b) := by
obtain ⟨k,hk⟩ := hf
obtain ⟨l,hl⟩ := hg
refine ⟨k+l,(hk.mul hl).congr' Filter.EventuallyEq.rfl ?_⟩
filter_upwards [eventually_ge_atTop (1:ℕ)] with d hd
have hd0 : (0:ℝ)<d := by exact_mod_cast hd
rw [pow_add,neg_add,Real.rpow_add hd0]
ring
lemma pow {f : ℕ → ℝ} {a : ℝ} (hf : LogPowerRate f a) (n : ℕ) :
LogPowerRate (fun d => f d^n) (n*a) := by
induction n with
| zero => simpa using const 1
| succ n ih =>
have h := ih.mul hf
simpa only [pow_succ,Nat.cast_add,Nat.cast_one,add_mul,one_mul] using h
lemma const_mul {f : ℕ → ℝ} {a : ℝ} (hf : LogPowerRate f a) (C : ℝ) :
LogPowerRate (fun d => C*f d) a := by
simpa only [zero_add] using (const C).mul hf
lemma mul_const {f : ℕ → ℝ} {a : ℝ} (hf : LogPowerRate f a) (C : ℝ) :
LogPowerRate (fun d => f d*C) a := by
simpa only [add_zero] using hf.mul (const C)
lemma add {f g : ℕ → ℝ} {a : ℝ} (hf : LogPowerRate f a) (hg : LogPowerRate g a) :
LogPowerRate (fun d => f d+g d) a := by
obtain ⟨k,hk⟩ := hf
obtain ⟨l,hl⟩ := hg
have bound (i j : ℕ) : (fun d : ℕ => dimensionLog d^i*(d:ℝ)^(-a)) =O[atTop]
(fun d => dimensionLog d^(i+j)*(d:ℝ)^(-a)) := by
apply IsBigO.of_bound 1
filter_upwards [] with d
rw [one_mul,Real.norm_of_nonneg (by positivity [dimensionLog_nonneg d]),
Real.norm_of_nonneg (by positivity [dimensionLog_nonneg d])]
exact mul_le_mul_of_nonneg_right (pow_le_pow_right₀ (dimensionLog_one_le d) (by omega)) (by positivity)
exact ⟨k+l,(hk.trans (bound k l)).add (hl.trans (by simpa only [Nat.add_comm] using bound l k))⟩
lemma of_le_abs {f g : ℕ → ℝ} {a : ℝ} (hg : LogPowerRate g a)
(hfg : ∀ᶠ d in atTop, |f d|≤|g d|) : LogPowerRate f a := by
obtain ⟨k,hk⟩ := hg
exact ⟨k,(IsBigO.of_bound 1 (by simpa only [one_mul,Real.norm_eq_abs] using hfg)).trans hk⟩
lemma eventually_small {f : ℕ → ℝ} {a b : ℝ} (hf : LogPowerRate f a) (hba : b<a) :
∀ᶠ d in atTop, |f d|≤(d:ℝ)^(-b) := by
obtain ⟨k,hk⟩ := hf
obtain ⟨C,hC⟩ := hk.bound
have hp := polylog_power_absorb C k hba
filter_upwards [hC,hp] with d hd hp
have hdn : 0≤dimensionLog d^k*(d:ℝ)^(-a) := by positivity [dimensionLog_nonneg d]
rw [Real.norm_eq_abs,Real.norm_of_nonneg hdn] at hd
calc
_ ≤ C*(dimensionLog d^k*(d:ℝ)^(-a)) := hd
_ ≤ |C| *(dimensionLog d^k*(d:ℝ)^(-a)) := mul_le_mul_of_nonneg_right (le_abs_self C) hdn
_ ≤ _ := by simpa only [mul_assoc] using hp
end LogPowerRate
end LogConcaveSampling
end
end
section
noncomputable section
namespace LogConcaveSampling
open Filter Asymptotics Set MeasureTheory Quadrature
open scoped Topology Classical BigOperators
namespace LogPowerRate
lemma abs {f : ℕ → ℝ} {a : ℝ} (hf : LogPowerRate f a) : LogPowerRate (fun d => |f d|) a := by
exact of_le_abs hf (Eventually.of_forall (fun d => by simp))
lemma div_const {f : ℕ → ℝ} {a : ℝ} (hf : LogPowerRate f a) (C : ℝ) :
LogPowerRate (fun d => f d/C) a := by
simpa only [div_eq_mul_inv] using hf.mul_const C⁻¹
lemma of_le {f g : ℕ → ℝ} {a : ℝ} (hg : LogPowerRate g a)
(hf : ∀ᶠ d : ℕ in atTop,0≤f d) (hfg : ∀ᶠ d : ℕ in atTop,f d≤g d) : LogPowerRate f a := by
apply of_le_abs hg
filter_upwards [hf,hfg] with d hd he
rw [abs_of_nonneg hd,abs_of_nonneg (hd.trans he)]
exact he
lemma inv_power (a : ℝ) : LogPowerRate (fun d => ((d:ℝ)^(-a))⁻¹) (-a) := by
apply (power (-a)).congr
filter_upwards [eventually_ge_atTop (1:ℕ)] with d hd
have hd0 : (0:ℝ)≤d := Nat.cast_nonneg d
rw [Real.rpow_neg hd0]
lemma log_nat : LogPowerRate (fun d : ℕ => Real.log (d:ℝ)) 0 := by
apply of_le log
· filter_upwards [eventually_ge_atTop (1:ℕ)] with d hd
exact Real.log_nonneg (by exact_mod_cast hd)
· filter_upwards [eventually_ge_atTop (1:ℕ)] with d hd
have hp : (0:ℝ)<d := by exact_mod_cast hd
have he := Real.log_le_log hp (by linarith : (d:ℝ)≤(d:ℝ)+1)
unfold dimensionLog
linarith
lemma log_power (a : ℝ) : LogPowerRate (fun d : ℕ => Real.log ((d:ℝ)^(-a))) 0 := by
apply (log_nat.const_mul (-a)).congr
filter_upwards [eventually_ge_atTop (1:ℕ)] with d hd
rw [Real.log_rpow (by exact_mod_cast hd : (0:ℝ)<d)]
end LogPowerRate
lemma logMeshLength_le_scale {T R : ℝ} (hT0 : 0<T) (hT1 : T<1)
(hR : 0<R) (hRT : R^2≤1-T^2) :
logMeshLength T≤Real.log 2-2*Real.log R := by
have hden : 0<1-T := by linarith
have hRR : R^2/2≤1-T := by nlinarith
have he := Real.log_le_log (by positivity : 0<R^2/2) hRR
rw [Real.log_div (by positivity : R^2≠0) (by norm_num),Real.log_pow] at he
unfold logMeshLength
norm_num at he
linarith
lemma logMeshLength_rate {T : ℕ → ℝ} (a : ℝ)
(hT0 : ∀ᶠ d : ℕ in atTop,0<T d) (hT1 : ∀ᶠ d : ℕ in atTop,T d<1)
(hRT : ∀ᶠ d : ℕ in atTop,((d:ℝ)^(-a))^2≤1-(T d)^2) :
LogPowerRate (fun d => logMeshLength (T d)) 0 := by
apply LogPowerRate.of_le ((LogPowerRate.const (Real.log 2)).add
((LogPowerRate.log_power a).const_mul (-2)))
· filter_upwards [hT0,hT1] with d hd0 hd1
exact (logMeshLength_pos hd0 hd1).le
· filter_upwards [hT0,hT1,hRT,eventually_ge_atTop (1:ℕ)] with d hd0 hd1 hRT hd
have hp : (0:ℝ)<d := by exact_mod_cast hd
simpa only [sub_eq_add_neg,neg_mul] using
logMeshLength_le_scale hd0 hd1 (Real.rpow_pos_of_pos hp (-a)) hRT
lemma terminalQuadratureWeight_rate (n : ℕ) (D : ℝ) (hD : 0≤D)
(hDu : ∀t∈Icc (0:ℝ) 1,∑i,|basisDerivative (probabilityNodes (n+1)) i t|≤D)
{T : ℕ → ℝ} (a b : ℝ)
(hT0 : ∀ᶠ d : ℕ in atTop,0<T d) (hT1 : ∀ᶠ d : ℕ in atTop,T d<1)
(hRT : ∀ᶠ d : ℕ in atTop,((d:ℝ)^(-a))^2≤1-(T d)^2)
(hsmall : ∀ᶠ d : ℕ in atTop,(d:ℝ)^(-b)≤Real.log 2)
(hlarge : ∀ᶠ d : ℕ in atTop,(d:ℝ)^(-b)≤logMeshLength (T d)) :
LogPowerRate (fun d => ∑v,|terminalQuadratureWeight (T d) ((d:ℝ)^(-b)) n v|) (-b) := by
have hlen := logMeshLength_rate a hT0 hT1 hRT
have he := ((LogPowerRate.inv_power b).const_mul 4).mul
((LogPowerRate.const (∑i,|zeroHermiteWeight (probabilityNodes (n+1)) 0 i|)).add
(((hlen.add (LogPowerRate.log_power b).abs).add (LogPowerRate.const (Real.log 4))).const_mul ((n+2)*D)))
simp only [add_zero] at he
apply LogPowerRate.of_le he
· exact Eventually.of_forall (fun d => by positivity)
· filter_upwards [hT0,hT1,hsmall,hlarge,eventually_ge_atTop (1:ℕ)] with d hd0 hd1 hs hl hd
have hp : (0:ℝ)<d := by exact_mod_cast hd
simpa only [div_eq_mul_inv] using terminalQuadratureWeight_sum hd0 hd1
(Real.rpow_pos_of_pos hp (-b)) hs hl n D hD hDu
end LogConcaveSampling
end
end
end OAI