math / data /lean /OAI /Probability /Moments /LineExpansion.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
43.5 kB
import Mathlib
namespace OAI
noncomputable section
open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators
open MvPolynomial
namespace CoordinateSweeps.MomentExpansion
variable {L : Type*} [Fintype L] [DecidableEq L]
/- The moment functional of independent line variables, defined algebraically
so only the finitely many moments actually used need be integrable. -/
def tensorMoment (m : L → ℕ → ℝ) : MvPolynomial L ℝ →ₗ[ℝ] ℝ :=
(MvPolynomial.basisMonomials L ℝ).constr ℝ (fun d => ∏ l, m l (d l))
omit [DecidableEq L] in
@[simp] theorem tensorMoment_monomial (m : L → ℕ → ℝ) (d : L →₀ ℕ) (a : ℝ) :
tensorMoment m (monomial d a) = a * ∏ l, m l (d l) := by
have hh : monomial d a = a • (MvPolynomial.basisMonomials L ℝ) d := by
rw [MvPolynomial.coe_basisMonomials]
rw [← map_smul]
simp
rw [hh, map_smul]
change a • (((MvPolynomial.basisMonomials L ℝ).constr ℝ)
(fun d => ∏ l, m l (d l))) ((MvPolynomial.basisMonomials L ℝ) d) = _
rw [Module.Basis.constr_basis, smul_eq_mul]
omit [DecidableEq L] in
@[simp] theorem tensorMoment_one (m : L → ℕ → ℝ) (hm : ∀ l, m l 0 = 1) :
tensorMoment m 1 = 1 := by
rw [MvPolynomial.one_def, tensorMoment_monomial]
simp [hm]
omit [DecidableEq L] in
theorem tensorMoment_sum (m : L → ℕ → ℝ) (p : MvPolynomial L ℝ) :
tensorMoment m p = ∑ d ∈ p.support, p.coeff d * ∏ l, m l (d l) := by
conv_lhs => rw [p.as_sum]
simp only [map_sum, tensorMoment_monomial]
/- Multiplicativity is asserted ONLY across disjoint sets of line variables. -/
omit [DecidableEq L] in
theorem tensorMoment_mul_disjoint (m : L → ℕ → ℝ) (hm : ∀ l, m l 0 = 1)
(p q : MvPolynomial L ℝ) (hd : Disjoint p.vars q.vars) :
tensorMoment m (p*q) = tensorMoment m p * tensorMoment m q := by
conv_lhs => rw [p.as_sum, q.as_sum]
simp only [Finset.sum_mul, Finset.mul_sum, map_sum, monomial_mul_monomial, tensorMoment_monomial]
rw [tensorMoment_sum, tensorMoment_sum, Finset.sum_mul, Finset.sum_comm]
apply Finset.sum_congr rfl
intro d hd'
rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro e he'
have heq : ∀ l, m l ((d+e) l) = m l (d l) * m l (e l) := by
intro l
by_cases hdl : d l = 0
· simp [hdl, hm]
· have hdp : l ∈ p.vars := p.support_subset_vars_of_mem_support hd'
(Finsupp.mem_support_iff.mpr hdl)
have hnot : l ∉ q.vars := fun he => Finset.disjoint_left.mp hd hdp he
have hel := MvPolynomial.mem_support_notMem_vars_zero he' hnot
simp [hel, hm]
simp only [heq, Finset.prod_mul_distrib]
ring
/- One-variable powers really have just the specified one-line moment. -/
omit [DecidableEq L] in
theorem tensorMoment_X_pow (m : L → ℕ → ℝ) (hm : ∀ l, m l 0 = 1) (l : L) (n : ℕ) :
tensorMoment m (X l ^ n) = m l n := by
rw [X_pow_eq_monomial, tensorMoment_monomial, one_mul]
rw [Finset.prod_eq_single l]
· simp
· intro a _ ha
simp [ha, hm]
· simp
/- Factorization of arbitrary polynomials, one for each distinct line. -/
theorem tensorMoment_prod_separated (m : L → ℕ → ℝ) (hm : ∀ l, m l 0 = 1)
(S : Finset L) (p : L → MvPolynomial L ℝ) (hp : ∀ l ∈ S, (p l).vars ⊆ {l}) :
tensorMoment m (∏ l ∈ S, p l) = ∏ l ∈ S, tensorMoment m (p l) := by
induction S using Finset.induction_on with
| empty => simp [tensorMoment_one m hm]
| @insert l S hl ih =>
rw [Finset.prod_insert hl, tensorMoment_mul_disjoint m hm,
Finset.prod_insert hl, ih (fun a ha => hp a (Finset.mem_insert_of_mem ha))]
apply Finset.disjoint_left.mpr
intro a ha hb
have hal : a = l := Finset.mem_singleton.mp (hp l (Finset.mem_insert_self _ _) ha)
subst a
have hv := MvPolynomial.vars_prod p hb
simp only [Finset.mem_biUnion] at hv
obtain ⟨a,ha,hla⟩ := hv
have hla' : l = a := Finset.mem_singleton.mp (hp a (Finset.mem_insert_of_mem ha) hla)
exact hl (hla'.symm ▸ ha)
/- The exact linear functional for a fixed subset of the non-good paths.
Translation by -1 retains all correlations between repeated uses of a line. -/
def shiftedMoment (m : L → ℕ → ℝ) (r : L → ℕ) : MvPolynomial L ℝ →ₗ[ℝ] ℝ :=
(tensorMoment m).comp
((LinearMap.mulLeft ℝ (∏ l, (X l : MvPolynomial L ℝ)^r l)).comp
(MvPolynomial.aeval (fun l => (X l : MvPolynomial L ℝ)-1)).toLinearMap)
def lineCenteredMoment (m : L → ℕ → ℝ) (l : L) (r u : ℕ) : ℝ :=
∑ a ∈ Finset.range (u+1), (-1 : ℝ)^(a+u) * (u.choose a : ℝ) * m l (r+a)
end CoordinateSweeps.MomentExpansion
namespace CoordinateSweeps.MomentExpansion
variable {L : Type*} [Fintype L] [DecidableEq L]
omit [Fintype L] in
theorem vars_X_centered_power (l : L) (r u : ℕ) :
(((X l : MvPolynomial L ℝ)^r) * (X l - 1)^u).vars ⊆ {l} := by
apply (MvPolynomial.vars_mul _ _).trans
apply Finset.union_subset
· exact (MvPolynomial.vars_pow _ _).trans (by simp)
· apply (MvPolynomial.vars_pow _ _).trans
exact (MvPolynomial.vars_sub_subset (p := (X l : MvPolynomial L ℝ)) (q := 1)).trans (by simp)
omit [DecidableEq L] in
theorem tensorMoment_X_centered_power (m : L → ℕ → ℝ) (hm : ∀ l, m l 0 = 1)
(l : L) (r u : ℕ) :
tensorMoment m ((X l : MvPolynomial L ℝ)^r * (X l-1)^u) =
lineCenteredMoment m l r u := by
rw [sub_pow, Finset.mul_sum, map_sum]
unfold lineCenteredMoment
apply Finset.sum_congr rfl
intro a _
have ht : (X l : MvPolynomial L ℝ)^r *
((-1)^(a+u) * X l^a * 1^(u-a) * (u.choose a : MvPolynomial L ℝ)) =
(((-1 : ℝ)^(a+u) * (u.choose a : ℝ)) • (X l : MvPolynomial L ℝ)^(r+a)) := by
rw [Algebra.smul_def, map_mul, map_pow, map_neg, map_one, map_natCast, pow_add]
ring
rw [ht, map_smul, tensorMoment_X_pow m hm, smul_eq_mul]
/- Repeated uses of one line are collected into a SINGLE mixed centered moment. -/
theorem shiftedMoment_monomial (m : L → ℕ → ℝ) (hm : ∀ l, m l 0 = 1)
(r : L → ℕ) (d : L →₀ ℕ) (a : ℝ) :
shiftedMoment m r (monomial d a) = a * ∏ l, lineCenteredMoment m l (r l) (d l) := by
unfold shiftedMoment
simp only [LinearMap.comp_apply, AlgHom.toLinearMap_apply, LinearMap.mulLeft_apply,
MvPolynomial.aeval_monomial]
rw [Finsupp.prod_fintype d _ (by simp)]
have he : (∏ l, (X l : MvPolynomial L ℝ)^r l) *
((algebraMap ℝ (MvPolynomial L ℝ)) a * ∏ l, (X l-1)^d l) =
a • (∏ l, (X l : MvPolynomial L ℝ)^r l * (X l-1)^d l) := by
rw [Finset.prod_mul_distrib, Algebra.smul_def]
ring
rw [he, map_smul, tensorMoment_prod_separated m hm _ _ (fun l _ => vars_X_centered_power l _ _)]
simp only [tensorMoment_X_centered_power m hm, smul_eq_mul]
/- Coefficientwise nonnegativity, used only for the positive centered expansion. -/
def NonnegCoeffs (p : MvPolynomial L ℝ) : Prop := ∀ d, 0 ≤ p.coeff d
omit [Fintype L] in
theorem nonnegCoeffs_one : NonnegCoeffs (1 : MvPolynomial L ℝ) := by
intro d
simp only [coeff_one]
split_ifs <;> norm_num
omit [Fintype L] [DecidableEq L] in
theorem NonnegCoeffs.add {p q : MvPolynomial L ℝ} (hp : NonnegCoeffs p) (hq : NonnegCoeffs q) :
NonnegCoeffs (p+q) := by
intro d
exact add_nonneg (hp d) (hq d)
omit [Fintype L] in
theorem NonnegCoeffs.mul {p q : MvPolynomial L ℝ} (hp : NonnegCoeffs p) (hq : NonnegCoeffs q) :
NonnegCoeffs (p*q) := by
intro d
rw [coeff_mul]
exact Finset.sum_nonneg (fun e _ => mul_nonneg (hp e.1) (hq e.2))
omit [Fintype L] in
theorem nonnegCoeffs_X (l : L) : NonnegCoeffs (X l : MvPolynomial L ℝ) := by
intro d
simp only [coeff_X]
split_ifs <;> norm_num
omit [Fintype L] [DecidableEq L] in
theorem nonnegCoeffs_prod {I : Type*} (S : Finset I) (p : I → MvPolynomial L ℝ)
(hp : ∀ i ∈ S, NonnegCoeffs (p i)) : NonnegCoeffs (∏ i ∈ S, p i) := by
classical
induction S using Finset.induction_on with
| empty => simpa using (nonnegCoeffs_one (L := L))
| @insert i S hi ih =>
rw [Finset.prod_insert hi]
exact (hp i (Finset.mem_insert_self _ _)).mul (ih (fun j hj => hp j (Finset.mem_insert_of_mem hj)))
omit [Fintype L] [DecidableEq L] in
theorem nonnegCoeffs_sum {I : Type*} (S : Finset I) (p : I → MvPolynomial L ℝ)
(hp : ∀ i ∈ S, NonnegCoeffs (p i)) : NonnegCoeffs (∑ i ∈ S, p i) := by
intro d
rw [coeff_sum]
exact Finset.sum_nonneg (fun i hi => hp i hi d)
/- Exact tensor moment estimate. Its potential premise is local in each
line and each used degree, not independence of particle factors. -/
theorem shiftedMoment_abs_le_eval (m : L → ℕ → ℝ) (hm : ∀ l, m l 0 = 1)
(r : L → ℕ) (p : MvPolynomial L ℝ) (hp : NonnegCoeffs p)
(C t : ℝ)
(hb : ∀ d ∈ p.support, ∀ l,
|lineCenteredMoment m l (r l) (d l)| ≤ C^(r l) * t^(d l)) :
|shiftedMoment m r p| ≤ C^(∑ l, r l) * MvPolynomial.eval (fun _ => t) p := by
conv_lhs => rw [p.as_sum]
rw [map_sum]
calc
_ ≤ ∑ d ∈ p.support, |shiftedMoment m r (monomial d (p.coeff d))| :=
Finset.abs_sum_le_sum_abs _ _
_ ≤ ∑ d ∈ p.support, p.coeff d * ∏ l, (C^(r l) * t^(d l)) := by
apply Finset.sum_le_sum
intro d hd
rw [shiftedMoment_monomial m hm, abs_mul, abs_of_nonneg (hp d), Finset.abs_prod]
exact mul_le_mul_of_nonneg_left
(Finset.prod_le_prod₀ (fun _ _ => abs_nonneg _) (fun l _ => hb d hd l)) (hp d)
_ = C^(∑ l, r l) * MvPolynomial.eval (fun _ => t) p := by
conv_rhs => rw [p.as_sum]
rw [map_sum, Finset.mul_sum]
apply Finset.sum_congr rfl
intro d _
rw [MvPolynomial.eval_monomial, Finsupp.prod_fintype d _ (by simp),
Finset.prod_mul_distrib, Finset.prod_pow_eq_pow_sum]
ring
end CoordinateSweeps.MomentExpansion
namespace CoordinateSweeps.MomentExpansion
variable {L : Type*} [Fintype L] [DecidableEq L]
variable {I J : Type*} [DecidableEq I] [Fintype J] [DecidableEq J]
/- Positive expansion for a centered particle factor. This is a sum over
NONEMPTY subsets of its stages; no independence of particle factors is used. -/
def pathExpansion (S : Finset J) (f : J → L) : MvPolynomial L ℝ :=
∑ T ∈ S.powerset.erase ∅, ∏ j ∈ T, X (f j)
omit [Fintype L] [DecidableEq L] [Fintype J] in
theorem pathExpansion_eq (S : Finset J) (f : J → L) :
pathExpansion S f = (∏ j ∈ S, ((X (f j) : MvPolynomial L ℝ)+1))-1 := by
have he := Finset.sum_erase_add S.powerset (fun T => ∏ j ∈ T, (X (f j) : MvPolynomial L ℝ))
(Finset.empty_mem_powerset S)
simp only [Finset.prod_empty] at he
unfold pathExpansion
rw [Finset.prod_add_one]
exact eq_sub_of_add_eq he
omit [Fintype L] [Fintype J] in
theorem pathExpansion_nonneg (S : Finset J) (f : J → L) :
NonnegCoeffs (pathExpansion S f) := by
exact nonnegCoeffs_sum _ _ (fun T _ => nonnegCoeffs_prod T _ (fun j _ => nonnegCoeffs_X _))
omit [Fintype L] [Fintype J] in
theorem pathExpansion_degree (S : Finset J) (f : J → L) (l : L) :
(pathExpansion S f).degreeOf l ≤ ∑ j ∈ S, if f j = l then 1 else 0 := by
rw [pathExpansion_eq]
apply (MvPolynomial.degreeOf_sub_le _ _ _).trans
rw [MvPolynomial.degreeOf_one, max_eq_left (Nat.zero_le _)]
apply (MvPolynomial.degreeOf_prod_le _ _ _).trans
apply Finset.sum_le_sum
intro j _
have hd := MvPolynomial.degreeOf_add_le l (X (f j) : MvPolynomial L ℝ) 1
simpa only [MvPolynomial.degreeOf_one, MvPolynomial.degreeOf_X, eq_comm,
max_eq_left (Nat.zero_le _)] using hd
omit [Fintype L] [DecidableEq L] [Fintype J] in
theorem pathExpansion_eval (S : Finset J) (f : J → L) (t : ℝ) :
MvPolynomial.eval (fun _ => t) (pathExpansion S f) = (1+t)^S.card-1 := by
rw [pathExpansion_eq]
simp [add_comm]
omit [Fintype L] [DecidableEq L] [Fintype J] in
theorem pathExpansion_shift (S : Finset J) (f : J → L) :
MvPolynomial.aeval (fun l => (X l : MvPolynomial L ℝ)-1) (pathExpansion S f) =
(∏ j ∈ S, (X (f j) : MvPolynomial L ℝ))-1 := by
rw [pathExpansion_eq]
simp
/- Combined centered expansion, with the actual same variable on a shared line. -/
def goodExpansion (G : Finset I) (path : I → J → L) : MvPolynomial L ℝ :=
∏ i ∈ G, pathExpansion Finset.univ (path i)
omit [Fintype L] [DecidableEq I] in
theorem goodExpansion_nonneg (G : Finset I) (path : I → J → L) :
NonnegCoeffs (goodExpansion G path) := by
exact nonnegCoeffs_prod _ _ (fun i _ => pathExpansion_nonneg _ _)
omit [Fintype L] [DecidableEq I] in
theorem goodExpansion_degree (G : Finset I) (path : I → J → L) (l : L) :
(goodExpansion G path).degreeOf l ≤ ∑ i ∈ G, ∑ j : J, if path i j = l then 1 else 0 := by
exact (MvPolynomial.degreeOf_prod_le _ _ _).trans
(Finset.sum_le_sum (fun _ _ => pathExpansion_degree _ _ _))
omit [Fintype L] [DecidableEq L] [DecidableEq I] in
theorem goodExpansion_eval (G : Finset I) (path : I → J → L) (t : ℝ) :
MvPolynomial.eval (fun _ => t) (goodExpansion G path) =
((1+t)^Fintype.card J-1)^G.card := by
simp [goodExpansion, pathExpansion_eval]
/- Uniform estimate for (1+C*x)^b-1, retaining one small factor per particle. -/
theorem centered_power_le (C x : ℝ) (hC : 0 ≤ C) (hx : 0 ≤ x) (hx1 : x ≤ 1) (b : ℕ) :
(1+C*x)^b-1 ≤ ((1+C)^b-1)*x := by
induction b with
| zero => simp
| succ b ih =>
have hCx : 0 ≤ C*x := mul_nonneg hC hx
have hb : 1 ≤ (1+C)^b := one_le_pow₀ (by linarith)
have hsmall : C*x ≤ C := mul_le_of_le_one_right hC hx1
have hmul := mul_le_mul_of_nonneg_right ih (by linarith : 0 ≤ 1+C*x)
have her : ((1+C)^b-1)*x*(1+C*x) ≤ ((1+C)^b-1)*x*(1+C) := by
exact mul_le_mul_of_nonneg_left (by linarith) (mul_nonneg (by linarith) hx)
rw [pow_succ, pow_succ]
nlinarith
omit [Fintype L] [DecidableEq L] [DecidableEq I] in
theorem goodExpansion_eval_le (G : Finset I) (path : I → J → L)
(C x : ℝ) (hC : 0 ≤ C) (hx : 0 ≤ x) (hx1 : x ≤ 1) :
MvPolynomial.eval (fun _ => C*x) (goodExpansion G path) ≤
(1+C)^(Fintype.card J*G.card) * x^G.card := by
rw [goodExpansion_eval]
have h1 : 1 ≤ (1+C*x)^Fintype.card J := one_le_pow₀ (by nlinarith)
have he := centered_power_le C x hC hx hx1 (Fintype.card J)
have hu : ((1+C)^Fintype.card J-1)*x ≤ (1+C)^Fintype.card J*x := by nlinarith
calc
_ ≤ ((1+C)^Fintype.card J*x)^G.card :=
pow_le_pow_left₀ (sub_nonneg.mpr h1) (he.trans hu) _
_ = _ := by rw [mul_pow, ← pow_mul]
/- Core shared-line estimate behind source (10), before inserting the actual
gamma moments. Each line degree is limited by the count of good trajectories
through it, and each good path supplies a factor sqrt(eta). -/
omit [DecidableEq I] in
theorem goodExpansion_moment_le (m : L → ℕ → ℝ) (hm : ∀ l, m l 0 = 1)
(r : L → ℕ) (G : Finset I) (path : I → J → L)
(C x : ℝ) (hC : 0 ≤ C) (hx : 0 ≤ x) (hx1 : x ≤ 1)
(hb : ∀ l u, u ≤ (∑ i ∈ G, ∑ j : J, if path i j = l then 1 else 0) →
|lineCenteredMoment m l (r l) u| ≤ C^(r l) * (C*x)^u) :
|shiftedMoment m r (goodExpansion G path)| ≤
C^(∑ l, r l) * (1+C)^(Fintype.card J*G.card) * x^G.card := by
have he := shiftedMoment_abs_le_eval m hm r (goodExpansion G path)
(goodExpansion_nonneg G path) C (C*x) (by
intro d hd l
exact hb l (d l) ((MvPolynomial.monomial_le_degreeOf l hd).trans
(goodExpansion_degree G path l)))
exact he.trans ((mul_le_mul_of_nonneg_left
(goodExpansion_eval_le G path C x hC hx hx1) (pow_nonneg hC _)).trans_eq (by ring))
end CoordinateSweeps.MomentExpansion
namespace CoordinateSweeps.MomentExpansion
variable {L : Type*} [Fintype L] [DecidableEq L]
variable {I J : Type*} [DecidableEq I] [Fintype J] [DecidableEq J]
def incidenceCount (A : Finset I) (path : I → J → L) (l : L) : ℕ :=
∑ i ∈ A, ∑ j : J, if path i j = l then 1 else 0
/- A monomial counts line uses, including simultaneous uses by distinct paths. -/
omit [DecidableEq I] [DecidableEq J] in
theorem tensorMoment_path_monomial (m : L → ℕ → ℝ) (r : L → ℕ)
(A : Finset I) (path : I → J → L) :
tensorMoment m ((∏ l, (X l : MvPolynomial L ℝ)^r l) *
∏ i ∈ A, ∏ j : J, X (path i j)) =
∏ l, m l (r l+incidenceCount A path l) := by
have hr : (∏ l, (X l : MvPolynomial L ℝ)^r l) =
monomial (∑ l, Finsupp.single l (r l)) 1 := by
rw [MvPolynomial.monomial_sum_one]
apply Finset.prod_congr rfl
intro l _
exact X_pow_eq_monomial
have hp : (∏ i ∈ A, ∏ j : J, (X (path i j) : MvPolynomial L ℝ)) =
monomial (∑ i ∈ A, ∑ j : J, Finsupp.single (path i j) 1) 1 := by
rw [MvPolynomial.monomial_sum_one]
apply Finset.prod_congr rfl
intro i _
rw [MvPolynomial.monomial_sum_one]
rfl
rw [hr, hp, MvPolynomial.monomial_mul_monomial, one_mul, tensorMoment_monomial, one_mul]
apply Finset.prod_congr rfl
intro l _
congr 1
simp [incidenceCount, Finsupp.single_apply, eq_comm]
/- Exact alternation identity. The summation set is the omitted subset of good
particles, so its sign is (-1)^|A|. This is source (10)'s inside-expectation
formula, with all shared-line correlations retained by the linear functional. -/
theorem shiftedMoment_goodExpansion_eq (m : L → ℕ → ℝ) (r : L → ℕ)
(G : Finset I) (path : I → J → L) :
shiftedMoment m r (goodExpansion G path) =
∑ A ∈ G.powerset, (-1 : ℝ)^A.card * ∏ l, m l (r l+incidenceCount (G\A) path l) := by
unfold shiftedMoment
simp only [LinearMap.comp_apply, AlgHom.toLinearMap_apply, LinearMap.mulLeft_apply,
goodExpansion, map_prod, pathExpansion_shift]
rw [Finset.prod_sub, Finset.mul_sum, map_sum]
apply Finset.sum_congr rfl
intro A _
simp only [Finset.prod_const_one, mul_one]
have he : (∏ l, (X l : MvPolynomial L ℝ)^r l) *
((-1 : MvPolynomial L ℝ)^A.card *
∏ i ∈ G\A, ∏ j : J, X (path i j)) =
(-1 : ℝ)^A.card • ((∏ l, (X l : MvPolynomial L ℝ)^r l) *
∏ i ∈ G\A, ∏ j : J, X (path i j)) := by
rw [Algebra.smul_def, map_pow, map_neg, map_one]
ring
rw [he, map_smul, tensorMoment_path_monomial, smul_eq_mul]
end CoordinateSweeps.MomentExpansion
/- Gamma-moment support. -/
/- The analytic light-line obligation 04-sparse.tex (11). The distribution
is exactly Mathlib's Gamma(shape, unit rate), not an assumed random variable. -/
noncomputable section
open MeasureTheory ProbabilityTheory Real Set Filter
open scoped ENNReal NNReal BigOperators
namespace CoordinateSweeps
theorem integral_gamma_eq {a r : ℝ} (ha : 0 < a) (hr : 0 < r) (f : ℝ → ℝ) :
(∫ x, f x ∂gammaMeasure a r) =
∫ x in Ioi 0, (r^a / Gamma a * x^(a-1) * exp (-(r*x))) * f x := by
rw [gammaMeasure]
change (∫ x, f x ∂volume.withDensity (fun x => ENNReal.ofReal (gammaPDFReal a r x))) = _
rw [integral_withDensity_eq_integral_toReal_smul
((measurable_gammaPDFReal a r).ennreal_ofReal) (ae_of_all _ (fun _ => ENNReal.ofReal_lt_top))]
simp only [ENNReal.toReal_ofReal (gammaPDFReal_nonneg ha hr _), smul_eq_mul]
have he : (fun x => gammaPDFReal a r x * f x) =
(Ici 0).indicator (fun x => (r^a / Gamma a * x^(a-1) * exp (-(r*x))) * f x) := by
funext x
by_cases hx : 0 ≤ x <;> simp [gammaPDFReal, hx, indicator_of_mem, indicator_of_notMem]
rw [he, integral_indicator measurableSet_Ici, integral_Ici_eq_integral_Ioi]
theorem gamma_mgf {a t : ℝ} (ha : 0 < a) (ht : t < 1) :
(∫ x, exp (t*x) ∂gammaMeasure a 1) = (1/(1-t))^a := by
rw [integral_gamma_eq ha zero_lt_one]
simp only [one_rpow, one_mul]
have he : (fun x : ℝ => (1 / Gamma a * x^(a-1) * exp (-x)) * exp (t*x)) =
fun x => (1 / Gamma a) * (x^(a-1) * exp (-((1-t)*x))) := by
funext x
rw [mul_assoc, mul_assoc, ← exp_add]
congr 3
ring
rw [he, integral_const_mul, integral_rpow_mul_exp_neg_mul_Ioi ha (sub_pos.mpr ht)]
field_simp [(Gamma_pos_of_pos ha).ne']
theorem gamma_mgf_integrable {a t : ℝ} (ha : 0 < a) (ht : t < 1) :
Integrable (fun x => exp (t*x)) (gammaMeasure a 1) := by
apply Integrable.of_integral_ne_zero
rw [gamma_mgf ha ht]
exact (rpow_pos_of_pos (one_div_pos.mpr (sub_pos.mpr ht)) _).ne'
theorem gamma_centered_mgf {a t : ℝ} (ha : 0 < a) (ht : t < 1) :
(∫ x, exp (t*(x-a)) ∂gammaMeasure a 1) = exp (a*(-t-log (1-t))) := by
have he : (fun x => exp (t*(x-a))) = fun x => exp (-t*a) * exp (t*x) := by
funext x
rw [← exp_add]
congr 1
ring
rw [he, integral_const_mul, gamma_mgf ha ht,
rpow_def_of_pos (one_div_pos.mpr (sub_pos.mpr ht)), ← exp_add,
one_div, log_inv]
congr 1
ring
theorem gamma_centered_mgf_integrable {a t : ℝ} (ha : 0 < a) (ht : t < 1) :
Integrable (fun x => exp (t*(x-a))) (gammaMeasure a 1) := by
apply Integrable.of_integral_ne_zero
rw [gamma_centered_mgf ha ht]
exact (exp_pos _).ne'
theorem log_mgf_bound {t : ℝ} (ht : |t| ≤ 1/2) : -t - log (1-t) ≤ 2*t^2 := by
have ht1 : |t| < 1 := by linarith
have hh := abs_log_sub_add_sum_range_le ht1 1
norm_num at hh
have hb : |t|^2 / (1-|t|) ≤ 2*t^2 := by
apply (div_le_iff₀ (by linarith : 0 < 1-|t|)).mpr
rw [sq_abs]
nlinarith [sq_nonneg t]
rw [sq_abs] at hb
have hl := neg_le_abs (t + log (1-t))
linarith
theorem gamma_centered_mgf_le {a t : ℝ} (ha : 0 < a) (ht : |t| ≤ 1/2) :
(∫ x, exp (t*(x-a)) ∂gammaMeasure a 1) ≤ exp (2*a*t^2) := by
rw [gamma_centered_mgf ha (by have := le_abs_self t; linarith)]
apply exp_le_exp.mpr
nlinarith [mul_le_mul_of_nonneg_left (log_mgf_bound ht) ha.le]
/- Pointwise exponential domination, used to obtain the actual centered
moments without a separate probabilistic Chernoff axiom. -/
theorem abs_pow_le_exp_sum (x : ℝ) (u : ℕ) {t : ℝ} (ht : 0 < t) :
|x|^u ≤ ((u : ℝ)/t)^u * (exp (t*x) + exp (-t*x)) := by
have hp := rpow_abs_le_mul_max_exp_of_pos x (Nat.cast_nonneg u) ht
rw [rpow_natCast, rpow_natCast] at hp
apply hp.trans
apply mul_le_mul_of_nonneg_left _ (by positivity)
exact max_le (le_add_of_nonneg_right (exp_nonneg _))
(le_add_of_nonneg_left (exp_nonneg _))
theorem abs_pow_integrable {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω}
{X : Ω → ℝ} (hX : AEMeasurable X μ) (u : ℕ) {t : ℝ} (ht : 0 < t)
(hp : Integrable (fun x => exp (t * X x)) μ)
(hn : Integrable (fun x => exp (-t * X x)) μ) :
Integrable (fun x => |X x|^u) μ := by
apply ((hp.add hn).const_mul (((u : ℝ)/t)^u)).mono'
· exact (hX.abs.pow_const u).aestronglyMeasurable
· filter_upwards [] with x
simpa only [Real.norm_eq_abs, abs_pow, abs_abs, Pi.add_apply] using abs_pow_le_exp_sum (X x) u ht
theorem abs_pow_integral_le {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω}
{X : Ω → ℝ} (hX : AEMeasurable X μ) (u : ℕ) {t : ℝ} (ht : 0 < t)
(hp : Integrable (fun x => exp (t * X x)) μ)
(hn : Integrable (fun x => exp (-t * X x)) μ) :
(∫ x, |X x|^u ∂μ) ≤ ((u : ℝ)/t)^u *
((∫ x, exp (t*X x) ∂μ) + (∫ x, exp (-t*X x) ∂μ)) := by
calc
_ ≤ ∫ x, ((u : ℝ)/t)^u * (exp (t*X x) + exp (-t*X x)) ∂μ :=
integral_mono (abs_pow_integrable hX u ht hp hn)
((hp.add hn).const_mul _) (fun x => abs_pow_le_exp_sum (X x) u ht)
_ = _ := by rw [integral_const_mul, integral_add hp hn]
/- A centered gamma moment in the range needed by every light line. -/
theorem gamma_abs_centered_moment_le {a : ℝ} (ha : 0 < a) {u : ℕ}
(hu : 1 ≤ u) (hua : 4*(u : ℝ) ≤ a) :
(∫ x, |x-a|^u ∂gammaMeasure a 1) ≤
(2 * exp 2 * Real.sqrt (a*u))^u := by
let t := Real.sqrt ((u : ℝ)/a)
have hu0 : (0 : ℝ) < u := by exact_mod_cast hu
have ht : 0 < t := Real.sqrt_pos.mpr (div_pos hu0 ha)
have ht2 : t^2 = (u : ℝ)/a := Real.sq_sqrt (by positivity)
have ht_half : t ≤ 1/2 := by
have hh : (u : ℝ)/a ≤ 1/4 := (div_le_iff₀ ha).mpr (by linarith)
nlinarith
have htab : |t| ≤ 1/2 := by rw [abs_of_pos ht]; exact ht_half
have hp := gamma_centered_mgf_integrable ha (show t < 1 by linarith)
have hn := gamma_centered_mgf_integrable ha (show -t < 1 by linarith)
have hh := abs_pow_integral_le
(X := fun x : ℝ => x-a) (by fun_prop) u ht hp hn
have hplus := gamma_centered_mgf_le ha htab
have hminus := gamma_centered_mgf_le ha (t := -t) (by simpa only [abs_neg] using htab)
have hat : a*t^2 = (u : ℝ) := by rw [ht2]; field_simp
have hratio : (u : ℝ)/t = Real.sqrt (a*u) := by
have ht0 : t ≠ 0 := ht.ne'
have he : (u : ℝ)/t * ((u : ℝ)/t) = a*u := by
field_simp
nlinarith [hat]
have hs := Real.sq_sqrt (show 0 ≤ a*(u : ℝ) by positivity)
have hr : 0 ≤ (u : ℝ)/t := by positivity
nlinarith [he, Real.sqrt_nonneg (a*u)]
calc
_ ≤ ((u : ℝ)/t)^u * (exp (2*a*t^2) + exp (2*a*(-t)^2)) :=
hh.trans (mul_le_mul_of_nonneg_left (add_le_add hplus hminus) (by positivity))
_ = 2 * (exp 2 * Real.sqrt (a*u))^u := by
rw [hratio, neg_sq]
have he : 2*a*t^2 = 2*(u : ℝ) := by nlinarith [hat]
rw [he, mul_comm (2 : ℝ) (u : ℝ), exp_nat_mul, mul_pow]
ring
_ ≤ (2 * exp 2 * Real.sqrt (a*u))^u := by
have htwo : (2 : ℝ) ≤ 2^u := by
simpa using (pow_le_pow_right₀ (by norm_num : (1 : ℝ) ≤ 2) hu)
calc
_ ≤ 2^u * (exp 2 * Real.sqrt (a*u))^u :=
mul_le_mul_of_nonneg_right htwo (by positivity)
_ = _ := by rw [← mul_pow]; congr 1; ring
/- No restriction at the density's null endpoint is needed. -/
theorem integral_gamma_congr {a r : ℝ} (ha : 0 < a) (hr : 0 < r)
{f g : ℝ → ℝ} (hfg : ∀ x, 0 < x → f x = g x) :
(∫ x, f x ∂gammaMeasure a r) = ∫ x, g x ∂gammaMeasure a r := by
rw [integral_gamma_eq ha hr, integral_gamma_eq ha hr]
apply setIntegral_congr_fun measurableSet_Ioi
intro x hx
dsimp only
rw [hfg x hx]
/- The exact inverse-power density tilt used, with all gamma laws concrete. -/
theorem gamma_inverse_tilt {a m : ℝ} (k : ℕ) (hak : (k : ℝ) < a)
(f : ℝ → ℝ) :
(∫ x, (m/x)^k * f x ∂gammaMeasure a 1) =
(m^k * Gamma (a-k) / Gamma a) * (∫ x, f x ∂gammaMeasure (a-k) 1) := by
have ha : 0 < a := lt_of_le_of_lt (Nat.cast_nonneg k) hak
have ha' : 0 < a-k := sub_pos.mpr hak
rw [integral_gamma_eq ha zero_lt_one, integral_gamma_eq ha' zero_lt_one,
← integral_const_mul]
apply setIntegral_congr_fun measurableSet_Ioi
intro x hx
dsimp only
have hx0 : x ≠ 0 := ne_of_gt hx
have hp : x^(a-1) = x^((a-k)-1) * x^k := by
rw [← rpow_natCast x k, ← rpow_add hx]
congr 1
ring
rw [hp]
simp only [one_rpow, one_mul, div_pow]
field_simp [(Gamma_pos_of_pos ha').ne', (Gamma_pos_of_pos ha).ne', hx0]
/- The gamma-ratio is the exact falling factorial, not an asymptotic. -/
theorem gamma_ratio_descFactorial {n k : ℕ} (hk : k ≤ n) :
Gamma ((n : ℝ)+1-k) / Gamma ((n : ℝ)+1) = (n.descFactorial k : ℝ)⁻¹ := by
have he : (n : ℝ)+1-k = (n-k : ℕ)+1 := by rw [Nat.cast_sub hk]; ring
rw [he, Gamma_nat_eq_factorial, Gamma_nat_eq_factorial]
have hh : ((n-k).factorial : ℝ) * (n.descFactorial k : ℝ) = n.factorial := by
exact_mod_cast Nat.factorial_mul_descFactorial hk
have hnp : (n.factorial : ℝ) ≠ 0 := by positivity
have hdp : (n.descFactorial k : ℝ) ≠ 0 := by
exact_mod_cast (Nat.descFactorial_pos.mpr hk).ne'
field_simp
exact hh
/- The first equality of manuscript (11). -/
theorem gamma_light_line_identity {m h u v : ℕ} (hm : 0 < m) (huv : h+u+v ≤ m) :
(∫ x, ((m : ℝ)/x)^v * |(m : ℝ)/x-1|^u
∂gammaMeasure ((m-h : ℕ)+1) 1) =
((m : ℝ)^(u+v) / ((m-h).descFactorial (u+v) : ℝ)) *
(∫ x, |1-x/(m : ℝ)|^u ∂gammaMeasure ((m-h : ℕ)+1-(u+v : ℕ)) 1) := by
have hh : h ≤ m := by omega
have hk : u+v ≤ m-h := by omega
have ha : (0 : ℝ) < (m-h : ℕ)+1 := by positivity
have hak : ((u+v : ℕ) : ℝ) < (m-h : ℕ)+1 := by exact_mod_cast (by omega : u+v < m-h+1)
have he := integral_gamma_congr ha zero_lt_one
(f := fun x => ((m : ℝ)/x)^v * |(m : ℝ)/x-1|^u)
(g := fun x => ((m : ℝ)/x)^(u+v) * |1-x/(m : ℝ)|^u) (by
intro x hx
have hm0 : (m : ℝ) ≠ 0 := by exact_mod_cast hm.ne'
have hx0 : x ≠ 0 := hx.ne'
have hz : (m : ℝ)/x-1 = ((m : ℝ)/x)*(1-x/(m : ℝ)) := by
field_simp
rw [hz, abs_mul, abs_of_pos (div_pos (by exact_mod_cast hm) hx), mul_pow, pow_add]
ring)
rw [he, gamma_inverse_tilt (u+v) hak]
rw [mul_div_assoc, gamma_ratio_descFactorial hk, ← div_eq_mul_inv]
/- Scale and bias estimate for the tilted gamma law. -/
theorem gamma_normalized_moment_le {a m η : ℝ} (ha : 0 < a) (hm : 0 < m)
(hη : 0 ≤ η) (hη1 : η ≤ 1) {u : ℕ} (hu : 1 ≤ u)
(hua : 4*(u : ℝ) ≤ a) (ham : a ≤ m) (huη : (u : ℝ) ≤ m*η)
(hbias : |1-a/m| ≤ η) :
(∫ x, |1-x/m|^u ∂gammaMeasure a 1) ≤
(8 * exp 2 * Real.sqrt η)^u := by
let : IsProbabilityMeasure (gammaMeasure a 1) := isProbabilityMeasure_gammaMeasure ha zero_lt_one
have hu0 : (0 : ℝ) ≤ u := Nat.cast_nonneg u
have hηsqrt : η ≤ Real.sqrt η := by
have hs := Real.sq_sqrt hη
nlinarith [Real.sqrt_nonneg η]
have hcenter : Integrable (fun x : ℝ => |x-a|^u) (gammaMeasure a 1) :=
abs_pow_integrable (by fun_prop) u (t := 1/4) (by norm_num)
(gamma_centered_mgf_integrable ha (by norm_num))
(gamma_centered_mgf_integrable ha (by norm_num))
have hratio : Real.sqrt (a*u)/m ≤ Real.sqrt η := by
apply (div_le_iff₀ hm).mpr
have hs := Real.sq_sqrt (show 0 ≤ a*(u : ℝ) by positivity)
have hsη := Real.sq_sqrt hη
have hp : a*(u : ℝ) ≤ m^2*η := by
nlinarith [mul_le_mul_of_nonneg_right ham hu0,
mul_le_mul_of_nonneg_left huη hm.le]
have hsq : (Real.sqrt η*m)^2 = m^2*η := by nlinarith [hsη]
nlinarith [Real.sqrt_nonneg (a*u), mul_nonneg (Real.sqrt_nonneg η) hm.le]
let B := 2 * exp 2 * Real.sqrt η
have he1 : (1 : ℝ) ≤ exp 2 := one_le_exp_iff.mpr (by norm_num)
have hB : 0 ≤ B := by dsimp [B]; positivity
have hsB : Real.sqrt η ≤ B := by dsimp [B]; nlinarith [Real.sqrt_nonneg η]
have hcB : (2*exp 2*Real.sqrt (a*u))/m ≤ B := by
calc
_ = (2*exp 2)*(Real.sqrt (a*u)/m) := by ring
_ ≤ B := mul_le_mul_of_nonneg_left hratio (by positivity)
have hmoment : (m^u)⁻¹ * (∫ x, |x-a|^u ∂gammaMeasure a 1) ≤ B^u := by
calc
_ ≤ (m^u)⁻¹ * (2*exp 2*Real.sqrt (a*u))^u :=
mul_le_mul_of_nonneg_left (gamma_abs_centered_moment_le ha hu hua) (by positivity)
_ = ((2*exp 2*Real.sqrt (a*u))/m)^u := by rw [div_pow]; ring
_ ≤ B^u := pow_le_pow_left₀ (by positivity) hcB u
have hgint : Integrable (fun x : ℝ => (2 : ℝ)^u *
((Real.sqrt η)^u + (m^u)⁻¹ * |x-a|^u)) (gammaMeasure a 1) :=
((integrable_const _).add (hcenter.const_mul _)).const_mul _
have hpt (x : ℝ) : |1-x/m|^u ≤ (2 : ℝ)^u *
((Real.sqrt η)^u + (m^u)⁻¹ * |x-a|^u) := by
have hde : 1-x/m = (1-a/m) + (-(x-a))/m := by ring
have hh : |1-x/m| ≤ Real.sqrt η + |x-a|/m := by
rw [hde]
apply (abs_add_le _ _).trans
rw [abs_div, abs_neg, abs_of_pos hm]
exact add_le_add (hbias.trans hηsqrt) le_rfl
calc
_ ≤ (Real.sqrt η + |x-a|/m)^u := pow_le_pow_left₀ (abs_nonneg _) hh u
_ ≤ 2^(u-1) * ((Real.sqrt η)^u + (|x-a|/m)^u) :=
add_pow_le (Real.sqrt_nonneg _) (by positivity) u
_ ≤ 2^u * ((Real.sqrt η)^u + (|x-a|/m)^u) := by
apply mul_le_mul_of_nonneg_right _ (by positivity)
exact pow_le_pow_right₀ (by norm_num) (Nat.sub_le _ _)
_ = _ := by rw [div_pow]; ring
calc
_ ≤ ∫ x, (2 : ℝ)^u * ((Real.sqrt η)^u + (m^u)⁻¹ * |x-a|^u)
∂gammaMeasure a 1 := integral_mono_of_nonneg
(ae_of_all _ (fun _ => by positivity)) hgint (ae_of_all _ hpt)
_ = 2^u * ((Real.sqrt η)^u + (m^u)⁻¹ *
(∫ x, |x-a|^u ∂gammaMeasure a 1)) := by
rw [integral_const_mul, integral_add (integrable_const _) (hcenter.const_mul _),
integral_const, integral_const_mul]
simp
_ ≤ 2^u * (B^u + B^u) := by
apply mul_le_mul_of_nonneg_left _ (by positivity)
exact add_le_add (pow_le_pow_left₀ (Real.sqrt_nonneg _) hsB _) hmoment
_ ≤ (8*exp 2*Real.sqrt η)^u := by
have htwo : (2 : ℝ) ≤ 2^u := by
simpa using (pow_le_pow_right₀ (by norm_num : (1 : ℝ) ≤ 2) hu)
calc
_ = 2^u * 2 * B^u := by ring
_ ≤ 2^u * 2^u * B^u := by gcongr
_ = (8*exp 2*Real.sqrt η)^u := by
rw [← mul_pow, ← mul_pow]
congr 1
dsimp [B]
ring
/- Uniform bound for the inverse-gamma prefactor, a light line cannot have
more than half of its sites assigned. -/
theorem light_prefactor_le {m h k : ℕ} (hm : 0 < m) (hk : 2*(h+k) ≤ m) :
(m : ℝ)^k / ((m-h).descFactorial k : ℝ) ≤ 2^k := by
have hkm : k ≤ m-h := by omega
have hpos : (0 : ℝ) < (m-h).descFactorial k := by
exact_mod_cast Nat.descFactorial_pos.mpr hkm
apply (div_le_iff₀ hpos).mpr
rw [Nat.descFactorial_eq_prod_range, Nat.cast_prod]
calc
(m : ℝ)^k = ∏ j ∈ Finset.range k, (m : ℝ) := by simp
_ ≤ ∏ j ∈ Finset.range k, (2 : ℝ)*(m-h-j : ℕ) := by
apply Finset.prod_le_prod₀
· intro _ _; positivity
· intro j hj
have hjk := Finset.mem_range.mp hj
have hjm : j ≤ m-h := by omega
rw [Nat.cast_sub hjm, Nat.cast_sub (show h ≤ m by omega)]
have hn : (2 : ℝ)*(h+k) ≤ m := by exact_mod_cast hk
have hjr : (j : ℝ) ≤ k := by exact_mod_cast (by omega : j ≤ k)
nlinarith
_ = 2^k * ∏ j ∈ Finset.range k, ((m-h-j : ℕ) : ℝ) := by
rw [Finset.prod_mul_distrib]
simp
/- The light-line estimate (11), with an explicit absolute constant. -/
theorem gamma_light_line_bound {m h u v : ℕ} (hm : 0 < m) {η : ℝ}
(hη : 0 ≤ η) (hηsmall : η ≤ 1/8)
(hlight : ((h+u+v : ℕ) : ℝ) ≤ (m : ℝ)*η) :
(∫ x, ((m : ℝ)/x)^v * |(m : ℝ)/x-1|^u
∂gammaMeasure ((m-h : ℕ)+1) 1) ≤
(16 * exp 2)^(u+v) * (Real.sqrt η)^u := by
have hm0 : (0 : ℝ) < m := by exact_mod_cast hm
have hmne : (m : ℝ) ≠ 0 := hm0.ne'
have htot : ((h+u+v : ℕ) : ℝ) ≤ (m : ℝ)/8 := by
nlinarith [mul_le_mul_of_nonneg_left hηsmall hm0.le]
have ht : h+u+v ≤ m := by
exact_mod_cast (show ((h+u+v : ℕ) : ℝ) ≤ (m : ℝ) by linarith)
have ht2 : 2*(h+(u+v)) ≤ m := by
have hh : (2 : ℝ)*(h+u+v) ≤ m := by push_cast at htot; linarith
simpa only [Nat.add_assoc] using (show 2*(h+u+v) ≤ m by exact_mod_cast hh)
have hh : h ≤ m := by omega
let a : ℝ := (m-h : ℕ)+1-(u+v : ℕ)
have hae : a = (m : ℝ)-(h+u+v : ℕ)+1 := by
dsimp [a]
rw [Nat.cast_sub hh]
push_cast
ring
have ha : 0 < a := by rw [hae]; linarith
have hnorm : (∫ x, |1-x/(m : ℝ)|^u ∂gammaMeasure a 1) ≤
(8 * exp 2 * Real.sqrt η)^u := by
by_cases hu : u = 0
· subst u
let : IsProbabilityMeasure (gammaMeasure a 1) := isProbabilityMeasure_gammaMeasure ha zero_lt_one
simp
· have hu1 : 1 ≤ u := by omega
have huS : (u : ℝ) ≤ (h+u+v : ℕ) := by exact_mod_cast (by omega : u ≤ h+u+v)
have hS1 : (1 : ℝ) ≤ (h+u+v : ℕ) := by exact_mod_cast (by omega : 1 ≤ h+u+v)
have hua : 4*(u : ℝ) ≤ a := by rw [hae]; linarith
have ham : a ≤ m := by rw [hae]; linarith
apply gamma_normalized_moment_le ha hm0 hη (by linarith) hu1 hua ham (huS.trans hlight)
have he : 1-a/(m : ℝ) = ((m : ℝ)-a)/m := by field_simp
rw [he, abs_of_nonneg (div_nonneg (sub_nonneg.mpr ham) hm0.le)]
apply (div_le_iff₀ hm0).mpr
rw [hae]
linarith
rw [gamma_light_line_identity hm ht]
have hpre := light_prefactor_le hm ht2
change _ * (∫ x, |1-x/(m : ℝ)|^u ∂gammaMeasure a 1) ≤ _
calc
_ ≤ (2 : ℝ)^(u+v) * (8 * exp 2 * Real.sqrt η)^u := by
apply mul_le_mul hpre hnorm
· exact integral_nonneg (fun _ => by positivity)
· positivity
_ = 2^(u+v) * (8*exp 2)^u * (Real.sqrt η)^u := by rw [mul_pow]; ring
_ ≤ 2^(u+v) * (8*exp 2)^(u+v) * (Real.sqrt η)^u := by
have hC : (1 : ℝ) ≤ 8*exp 2 := by nlinarith [one_le_exp_iff.mpr (show (0 : ℝ) ≤ 2 by norm_num)]
have hp := pow_le_pow_right₀ hC (Nat.le_add_right u v)
exact mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hp (by positivity)) (by positivity)
_ = (16 * exp 2)^(u+v) * (Real.sqrt η)^u := by
rw [← mul_pow]
congr 2
ring
/- Exactly the power convention printed in manuscript (11). -/
theorem gamma_light_line_bound_rpow {m h u v : ℕ} (hm : 0 < m) {η : ℝ}
(hη : 0 ≤ η) (hηsmall : η ≤ 1/8)
(hlight : ((h+u+v : ℕ) : ℝ) ≤ (m : ℝ)*η) :
(∫ x, ((m : ℝ)/x)^v * |(m : ℝ)/x-1|^u
∂gammaMeasure ((m-h : ℕ)+1) 1) ≤
(16 * exp 2)^(u+v) * η^((u : ℝ)/2) := by
have he : (Real.sqrt η)^u = η^((u : ℝ)/2) := by
rw [Real.sqrt_eq_rpow, ← Real.rpow_natCast (η^(1/2 : ℝ)) u,
← Real.rpow_mul hη]
congr 1
ring
simpa only [he] using gamma_light_line_bound hm hη hηsmall hlight
end CoordinateSweeps
namespace CoordinateSweeps.MomentExpansion
open MeasureTheory ProbabilityTheory Real
/- Source light-line factorial moment, with its exact finite-population shift. -/
def fallingMoment (m h n : ℕ) : ℝ := (m : ℝ)^n / ((m-h).descFactorial n : ℝ)
@[simp] theorem fallingMoment_zero (m h : ℕ) : fallingMoment m h 0 = 1 := by
simp [fallingMoment]
/- The algebraic moment is the ACTUAL inverse-gamma moment in every used degree. -/
theorem fallingMoment_eq_integral {m h n : ℕ} (hn : n ≤ m-h) :
fallingMoment m h n =
∫ x, ((m : ℝ)/x)^n ∂gammaMeasure ((m-h : ℕ)+1) 1 := by
have hak : (n : ℝ) < (m-h : ℕ)+1 := by exact_mod_cast (by omega : n < m-h+1)
have ha : (0 : ℝ) < (m-h : ℕ)+1-n := by linarith
let : IsProbabilityMeasure (gammaMeasure ((m-h : ℕ)+1-n) 1) :=
isProbabilityMeasure_gammaMeasure ha zero_lt_one
have he := gamma_inverse_tilt (m := (m : ℝ)) n hak (fun _ => (1 : ℝ))
simp only [mul_one, integral_const, Measure.real, measure_univ, ENNReal.toReal_one, smul_eq_mul,
mul_div_assoc, gamma_ratio_descFactorial hn] at he
simpa only [fallingMoment, div_eq_mul_inv] using he.symm
theorem fallingMoment_integrable {m h n : ℕ} (hm : 0 < m) (hn : n ≤ m-h) :
Integrable (fun x => ((m : ℝ)/x)^n) (gammaMeasure ((m-h : ℕ)+1) 1) := by
apply Integrable.of_integral_ne_zero
rw [← fallingMoment_eq_integral hn]
apply ne_of_gt
unfold fallingMoment
exact div_pos (pow_pos (by exact_mod_cast hm) _)
(by exact_mod_cast Nat.descFactorial_pos.mpr hn)
/- Centered finite differences collect all occurrences of the SAME line. -/
theorem fallingCenteredMoment_eq_integral {L : Type*} (m h : L → ℕ) (l : L)
(hm : 0 < m l) (v u : ℕ) (huv : v+u ≤ m l-h l) :
lineCenteredMoment (fun l => fallingMoment (m l) (h l)) l v u =
∫ x, ((m l : ℝ)/x)^v * ((m l : ℝ)/x-1)^u
∂gammaMeasure ((m l-h l : ℕ)+1) 1 := by
have he (a : ℕ) (ha : a ∈ Finset.range (u+1)) :
v+a ≤ m l-h l := by simp only [Finset.mem_range] at ha; omega
have hi (a : ℕ) (ha : a ∈ Finset.range (u+1)) :
Integrable (fun x => (-1 : ℝ)^(a+u) * (u.choose a : ℝ) * ((m l : ℝ)/x)^(v+a))
(gammaMeasure ((m l-h l : ℕ)+1) 1) :=
(fallingMoment_integrable hm (he a ha)).const_mul _
unfold lineCenteredMoment
have hs : (∑ a ∈ Finset.range (u+1), (-1 : ℝ)^(a+u) * (u.choose a : ℝ) *
fallingMoment (m l) (h l) (v+a)) =
∫ x, ∑ a ∈ Finset.range (u+1), (-1 : ℝ)^(a+u) * (u.choose a : ℝ) *
((m l : ℝ)/x)^(v+a) ∂gammaMeasure ((m l-h l : ℕ)+1) 1 := by
rw [integral_finsetSum _ hi]
apply Finset.sum_congr rfl
intro a ha
rw [integral_const_mul, ← fallingMoment_eq_integral (he a ha)]
rw [hs]
congr 1
funext x
rw [sub_pow, Finset.mul_sum]
apply Finset.sum_congr rfl
intro a _
rw [pow_add]
ring
/- Source (11) now applies directly to the exact finite-difference moment.
The gamma centered bound already existed; this bridge to Q's required moments is new. -/
theorem fallingCenteredMoment_abs_le {L : Type*} (m h : L → ℕ) (l : L)
(hm : 0 < m l) (v u : ℕ) {η : ℝ} (hη : 0 ≤ η) (hηsmall : η ≤ 1/8)
(hlight : ((h l+u+v : ℕ) : ℝ) ≤ (m l : ℝ)*η) :
|lineCenteredMoment (fun l => fallingMoment (m l) (h l)) l v u| ≤
(16 * exp 2)^v * ((16 * exp 2)*Real.sqrt η)^u := by
have huvn : h l+u+v ≤ m l := by
have hm0 : (0 : ℝ) ≤ m l := Nat.cast_nonneg _
have ht : (m l : ℝ)*η ≤ m l := mul_le_of_le_one_right hm0 (by linarith)
exact_mod_cast hlight.trans ht
rw [fallingCenteredMoment_eq_integral m h l hm v u (by omega)]
have ha : (0 : ℝ) < (m l-h l : ℕ)+1 := by positivity
have he : (∫ x, |((m l : ℝ)/x)^v * ((m l : ℝ)/x-1)^u|
∂gammaMeasure ((m l-h l : ℕ)+1) 1) =
∫ x, ((m l : ℝ)/x)^v * |(m l : ℝ)/x-1|^u
∂gammaMeasure ((m l-h l : ℕ)+1) 1 := by
apply integral_gamma_congr ha zero_lt_one
intro x hx
rw [abs_mul, abs_pow, abs_pow, abs_of_nonneg (div_nonneg (Nat.cast_nonneg _) hx.le)]
calc
_ ≤ ∫ x, |((m l : ℝ)/x)^v * ((m l : ℝ)/x-1)^u|
∂gammaMeasure ((m l-h l : ℕ)+1) 1 := by
simpa only [Real.norm_eq_abs] using norm_integral_le_integral_norm
(fun x => ((m l : ℝ)/x)^v * ((m l : ℝ)/x-1)^u)
_ = _ := he
_ ≤ (16 * exp 2)^(u+v) * (Real.sqrt η)^u := gamma_light_line_bound hm hη hηsmall hlight
_ = _ := by rw [pow_add, mul_pow]; ring
/- Actual inverse-gamma specialization of the shared-line expansion. -/
theorem goodExpansion_fallingMoment_le {L I J : Type*}
[Fintype L] [DecidableEq L] [Fintype J] [DecidableEq J]
(m h r : L → ℕ) (hm : ∀ l, 0 < m l) (G : Finset I) (path : I → J → L)
{η : ℝ} (hη : 0 ≤ η) (hηsmall : η ≤ 1/8)
(hlight : ∀ l, ((h l+r l+(∑ i ∈ G, ∑ j : J, if path i j = l then 1 else 0) : ℕ) : ℝ)
≤ (m l : ℝ)*η) :
|shiftedMoment (fun l => fallingMoment (m l) (h l)) r (goodExpansion G path)| ≤
(16 * exp 2)^(∑ l, r l) * (1+16 * exp 2)^(Fintype.card J*G.card) *
η^((G.card : ℝ)/2) := by
have he := goodExpansion_moment_le (fun l => fallingMoment (m l) (h l))
(fun l => fallingMoment_zero _ _) r G path (16*exp 2) (Real.sqrt η)
(by positivity) (Real.sqrt_nonneg _) (by
apply (Real.sqrt_le_left (by norm_num : (0 : ℝ) ≤ 1)).mpr
linarith) (by
intro l u hu
apply fallingCenteredMoment_abs_le m h l (hm l) (r l) u hη hηsmall
apply le_trans _ (hlight l)
exact_mod_cast (show h l+u+r l ≤ h l+r l+∑ i ∈ G, ∑ j : J, if path i j = l then 1 else 0 by omega))
have hs : (Real.sqrt η)^G.card = η^((G.card : ℝ)/2) := by
rw [sqrt_eq_rpow, ← rpow_natCast, ← rpow_mul hη]
congr 1; ring
simpa only [hs] using he
end CoordinateSweeps.MomentExpansion
end
end
end
end
open scoped Matrix.Norms.L2Operator
end OAI