math / data /lean /OAI /Probability /LogConcave /Complexity /KernelAnalyticNormalizedBudget.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 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