| import Mathlib |
| import OAI.Probability.LogConcave.JetEstimates.TensorTerm |
| import OAI.Probability.LogConcave.Complexity.PolynomialBudget |
| import OAI.Probability.LogConcave.Sampling.FinSnocSlots |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
| namespace LogConcaveSampling |
| open MeasureTheory TensorExpression |
| open scoped Classical BigOperators ENNReal NNReal |
|
|
| namespace TensorAtom |
| variable {S : Type} [Fintype S] |
| def slice {d : ℕ} (A : TensorAtom S) (F : Point d → ℝ) (x : Point d) (r ρ L : ℝ) : |
| (S → Fin d) → Point d → ℝ := fun c y => A.eval F x r L c (ρ,y) |
|
|
| omit [Fintype S] in |
| lemma slice_polySmooth {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0 < r) |
| (hlam : 0 < lam) (hl : (lam:ℝ)*r^2≤1/2) (h0 : 0≤ρ) (h1 : ρ<1) |
| (A : TensorAtom S) (c : S → Fin d) : PolySmooth (A.slice F x r ρ ((lam:ℝ)*r) c) := by |
| change PolySmooth (fun y => A.expression.jointEval F x r ((lam:ℝ)*r) (c ∘ A.labels) (ρ,y)) |
| rw [TensorExpression.jointEval_slice hF x hr hlam hl h0 h1] |
| exact TensorExpression.eval_polySmooth (physicalBase_polySmooth hF x hr hlam hl h0 h1) |
| (interpolationPotential_polySmooth hF x hr hlam hl h0 h1) A.expression _ |
|
|
| def spatialBound {d : ℕ} (A : TensorAtom S) (F : Point d → ℝ) (x : Point d) |
| (r ρ L : ℝ) (j : ℕ) : Point d → ℝ := |
| spatialEnvelope (A.expression.eval (physicalBase F x r ρ L) (interpolationPotential F x r ρ)) j |
|
|
| omit [Fintype S] in |
| lemma spatialBound_nonneg {d : ℕ} (A : TensorAtom S) (F : Point d → ℝ) (x : Point d) |
| (r ρ L : ℝ) (j : ℕ) (y : Point d) : 0≤A.spatialBound F x r ρ L j y := |
| spatialEnvelope_nonneg _ _ _ |
|
|
| omit [Fintype S] in |
| lemma spatialBound_measurable {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0 < r) |
| (hlam : 0 < lam) (hl : (lam:ℝ)*r^2≤1/2) (h0 : 0≤ρ) (h1 : ρ<1) |
| (A : TensorAtom S) (j : ℕ) : Measurable (A.spatialBound F x r ρ ((lam:ℝ)*r) j) := |
| spatialEnvelope_measurable _ (TensorExpression.eval_polySmooth |
| (physicalBase_polySmooth hF x hr hlam hl h0 h1) |
| (interpolationPotential_polySmooth hF x hr hlam hl h0 h1) A.expression) j |
|
|
| lemma spatialBound_allSplit {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0 < r) |
| (hlam : 0 < lam) (hl : (lam:ℝ)*r^2≤1/2) (h0 : 0≤ρ) (h1 : ρ<1) |
| (A : TensorAtom S) (j : ℕ) (y : Point d) : |
| TensorEnergy.AllSplitBound (spatialTensor (A.slice F x r ρ ((lam:ℝ)*r)) (List.finRange j) y) |
| (A.spatialBound F x r ρ ((lam:ℝ)*r) j y) := by |
| let V := A.expression.eval (physicalBase F x r ρ ((lam:ℝ)*r)) (interpolationPotential F x r ρ) |
| have hs := TensorExpression.eval_polySmooth (physicalBase_polySmooth hF x hr hlam hl h0 h1) |
| (interpolationPotential_polySmooth hF x hr hlam hl h0 h1) A.expression |
| have he : A.slice F x r ρ ((lam:ℝ)*r)=fun c => V (c ∘ A.labels) := by |
| funext c |
| exact A.expression.jointEval_slice hF x hr hlam hl h0 h1 _ |
| rw [he] |
| exact spatialTensor_allSplit_relabel V (fun c => (hs c).smooth) A.labels |
| (Equiv.refl (Fin j)) _ _ (by simp) y _ (TensorEnergy.allSplitBound_envelope _) |
|
|
| omit [Fintype S] in |
| lemma spatialBound_Lp {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0 < r) |
| (hlam : 0 < lam) (hl : (lam:ℝ)*r^2≤1/2) (h0 : 0≤ρ) (h1 : ρ<1) |
| (hd : 1≤d) (A : TensorAtom S) (j : ℕ) {p : ℝ≥0∞} (hpf : p≠⊤) : |
| eLpNorm (A.spatialBound F x r ρ ((lam:ℝ)*r) j) p (interpolationLaw F x r ρ)≤ |
| ((4*(A.expression.profileConstant:ℝ≥0∞))*ENNReal.ofReal (p.toReal+j+Real.log ((d:ℝ)+1)+1))^ |
| (A.expression.profileConstant*(j+1))* |
| ENNReal.ofReal ((Real.sqrt (1-ρ^2))⁻¹)^(A.expression.weight+j) := by |
| let : IsProbabilityMeasure (interpolationLaw F x r ρ) := interpolationLaw_probability hF x hr.le (by linarith) ρ |
| exact TameAt.eLpNorm (TensorExpression.eval_polySmooth |
| (physicalBase_polySmooth hF x hr hlam hl h0 h1) |
| (interpolationPotential_polySmooth hF x hr hlam hl h0 h1) A.expression) |
| (A.expression.physical_tame hF x hr hlam hl h0 h1 hd) j hpf |
| end TensorAtom |
|
|
| namespace TensorEnergy |
| lemma AllSplitBound.abs_const_mul {S : Type} [Fintype S] {d : ℕ} |
| {T : (S → Fin d) → ℝ} {M : ℝ} (h : AllSplitBound T M) (c : ℝ) : |
| AllSplitBound (fun a => c*T a) (|c| * M) := by |
| intro I O _ _ _ _ _ _ e |
| convert (h.const_mul c) I O e using 1 |
| simp only [mul_pow,sq_abs] |
| end TensorEnergy |
|
|
| lemma spatialTensor_const_mul {S : Type} {d j : ℕ} |
| (V : (S → Fin d) → Point d → ℝ) (hV : ∀c,ContDiff ℝ (⊤:ℕ∞) (V c)) |
| (a : ℝ) (y : Point d) : |
| spatialTensor (fun c z => a*V c z) (List.finRange j) y= |
| fun c => a*spatialTensor V (List.finRange j) y c := by |
| funext c |
| exact congrFun (JetCalculus.jet_const_mul (hV _) _ _ a) y |
|
|
| lemma spatialTensor_sum {S I : Type} [Fintype I] {d j : ℕ} |
| (V : I → (S → Fin d) → Point d → ℝ) (hV : ∀i c,ContDiff ℝ (⊤:ℕ∞) (V i c)) |
| (y : Point d) : |
| spatialTensor (fun c z => ∑i,V i c z) (List.finRange j) y= |
| fun c => ∑i,spatialTensor (V i) (List.finRange j) y c := by |
| funext c |
| exact congrFun (JetCalculus.jet_sum Finset.univ (fun i _ => hV i _) _ _) y |
|
|
| namespace TensorSum |
| variable {S : Type} [Fintype S] |
| def slice {d : ℕ} (A : TensorSum S) (F : Point d → ℝ) (x : Point d) (r ρ L : ℝ) : |
| (S → Fin d) → Point d → ℝ := fun c y => A.eval F x r L c (ρ,y) |
|
|
| def spatialBound {d : ℕ} (A : TensorSum S) (F : Point d → ℝ) (x : Point d) |
| (r ρ L : ℝ) (j : ℕ) : Point d → ℝ := fun y => |
| ∑i,polynomialBudget (A.term i).coefficient*(A.term i).atom.spatialBound F x r ρ L j y |
|
|
| omit [Fintype S] in |
| lemma spatialBound_nonneg {d : ℕ} (A : TensorSum S) (F : Point d → ℝ) (x : Point d) |
| (r ρ L : ℝ) (j : ℕ) (y : Point d) : 0≤A.spatialBound F x r ρ L j y := |
| Finset.sum_nonneg (fun _ _ => mul_nonneg (polynomialBudget_nonneg _) (TensorAtom.spatialBound_nonneg _ _ _ _ _ _ _ _)) |
|
|
| omit [Fintype S] in |
| lemma spatialBound_measurable {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0 < r) |
| (hlam : 0 < lam) (hl : (lam:ℝ)*r^2≤1/2) (h0 : 0≤ρ) (h1 : ρ<1) |
| (A : TensorSum S) (j : ℕ) : Measurable (A.spatialBound F x r ρ ((lam:ℝ)*r) j) := |
| Finset.measurable_sum _ (fun i _ => measurable_const.mul |
| ((A.term i).atom.spatialBound_measurable hF x hr hlam hl h0 h1 j)) |
|
|
| omit [Fintype S] in |
| lemma slice_polySmooth {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0 < r) |
| (hlam : 0 < lam) (hl : (lam:ℝ)*r^2≤1/2) (h0 : 0≤ρ) (h1 : ρ<1) |
| (A : TensorSum S) (c : S → Fin d) : PolySmooth (A.slice F x r ρ ((lam:ℝ)*r) c) := |
| by |
| change PolySmooth (fun z => ∑i, ((r*((lam:ℝ)*r))^(A.term i).power* |
| (A.term i).coefficient.eval ρ)*(A.term i).atom.slice F x r ρ ((lam:ℝ)*r) c z) |
| exact PolySmooth.sum Finset.univ (fun i _ => |
| (PolySmooth.const _).mul ((A.term i).atom.slice_polySmooth hF x hr hlam hl h0 h1 c)) |
|
|
| lemma spatialBound_allSplit {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0 < r) |
| (hlam : 0 < lam) (hl : (lam:ℝ)*r^2≤1/2) (h0 : 0≤ρ) (h1 : ρ<1) |
| (A : TensorSum S) (j : ℕ) (y : Point d) : |
| TensorEnergy.AllSplitBound (spatialTensor (A.slice F x r ρ ((lam:ℝ)*r)) (List.finRange j) y) |
| (A.spatialBound F x r ρ ((lam:ℝ)*r) j y) := by |
| let L := (lam:ℝ)*r |
| let a := fun i => (r*L)^(A.term i).power*(A.term i).coefficient.eval ρ |
| have hs (i : A.index) (c : S → Fin d) := (A.term i).atom.slice_polySmooth hF x hr hlam hl h0 h1 c |
| have he : A.slice F x r ρ L=fun c z => ∑i,a i*(A.term i).atom.slice F x r ρ L c z := rfl |
| rw [he,spatialTensor_sum _ (fun i c => contDiff_const.mul (hs i c).smooth)] |
| simp_rw [spatialTensor_const_mul _ (fun c => (hs _ c).smooth)] |
| apply TensorEnergy.AllSplitBound.finite_sum |
| · intro i; exact mul_nonneg (polynomialBudget_nonneg _) (TensorAtom.spatialBound_nonneg _ _ _ _ _ _ _ _) |
| · intro i |
| have ht := (A.term i).atom.spatialBound_allSplit hF x hr hlam hl h0 h1 j y |
| apply (TensorEnergy.AllSplitBound.abs_const_mul ht (a i)).mono (mul_nonneg (abs_nonneg _) (TensorAtom.spatialBound_nonneg _ _ _ _ _ _ _ _)) |
| apply mul_le_mul_of_nonneg_right _ (TensorAtom.spatialBound_nonneg _ _ _ _ _ _ _ _) |
| exact scaledCoefficient_bound _ _ (by dsimp [L]; positivity) |
| (by change r*((lam:ℝ)*r)≤1; nlinarith [hl]) h0 h1.le |
| end TensorSum |
| end LogConcaveSampling |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| noncomputable section |
| namespace LogConcaveSampling |
| open MeasureTheory |
| open scoped Classical BigOperators ENNReal NNReal |
|
|
| namespace TensorSum |
| variable {S : Type} [Fintype S] |
|
|
| def momentBudget (A : TensorSum S) (d j : ℕ) (p : ℝ≥0∞) : ℝ≥0∞ := |
| ∑i,ENNReal.ofReal (polynomialBudget (A.term i).coefficient)* |
| ((4*((A.term i).atom.expression.profileConstant:ℝ≥0∞))* |
| ENNReal.ofReal (p.toReal+j+Real.log ((d:ℝ)+1)+1))^ |
| ((A.term i).atom.expression.profileConstant*(j+1)) |
|
|
| omit [Fintype S] in |
| lemma momentBudget_ne_top (A : TensorSum S) (d j : ℕ) (p : ℝ≥0∞) : |
| A.momentBudget d j p≠⊤ := by |
| apply ne_of_lt |
| apply ENNReal.sum_lt_top.mpr |
| intro i _ |
| apply ENNReal.mul_lt_top (ENNReal.ofReal_lt_top) |
| exact ENNReal.pow_lt_top (ENNReal.mul_lt_top (ENNReal.mul_lt_top (by norm_num) (ENNReal.natCast_lt_top _)) ENNReal.ofReal_lt_top) |
|
|
| omit [Fintype S] in |
| lemma spatialBound_Lp {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0 < r) |
| (hlam : 0 < lam) (hl : (lam:ℝ)*r^2≤1/2) (h0 : 0≤ρ) (h1 : ρ<1) |
| (hd : 1≤d) (A : TensorSum S) {w : ℕ} (hw : A.weightLE w) |
| (j : ℕ) {p : ℝ≥0∞} (hp : 1≤p) (hpf : p≠⊤) : |
| eLpNorm (A.spatialBound F x r ρ ((lam:ℝ)*r) j) p (interpolationLaw F x r ρ)≤ |
| A.momentBudget d j p*ENNReal.ofReal ((Real.sqrt (1-ρ^2))⁻¹)^(w+j) := by |
| let μ := interpolationLaw F x r ρ |
| let V := fun i => (A.term i).atom.spatialBound F x r ρ ((lam:ℝ)*r) j |
| let a := fun i => polynomialBudget (A.term i).coefficient |
| have he : A.spatialBound F x r ρ ((lam:ℝ)*r) j=∑i,a i • V i := by |
| funext y |
| simp only [spatialBound,Finset.sum_apply,Pi.smul_apply,smul_eq_mul,V,a] |
| rw [he] |
| apply (eLpNorm_sum_le (μ:=μ) (s:=Finset.univ) (f:=fun index => a index • V index) hp).trans |
| rw [momentBudget,Finset.sum_mul] |
| apply Finset.sum_le_sum |
| intro i _ |
| rw [eLpNorm_const_smul] |
| have ha : ‖a i‖ₑ=ENNReal.ofReal (a i) := by |
| rw [Real.enorm_eq_ofReal_abs,abs_of_nonneg (polynomialBudget_nonneg _)] |
| rw [ha,mul_assoc] |
| apply mul_le_mul' le_rfl |
| apply ((A.term i).atom.spatialBound_Lp hF x hr hlam hl h0 h1 hd j hpf).trans |
| apply mul_le_mul' le_rfl |
| apply pow_le_pow_right' |
| · apply ENNReal.one_le_ofReal.mpr |
| have hs0 : 0 < Real.sqrt (1-ρ^2) := Real.sqrt_pos.2 (by nlinarith) |
| have hs1 : Real.sqrt (1-ρ^2)≤1 := by |
| exact (Real.sqrt_le_iff).2 ⟨by norm_num,by nlinarith [sq_nonneg ρ]⟩ |
| exact (one_le_inv₀ hs0).mpr hs1 |
| · exact Nat.add_le_add_right (hw i) j |
| end TensorSum |
| end LogConcaveSampling |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| noncomputable section |
| namespace LogConcaveSampling |
| open scoped Classical BigOperators |
|
|
| namespace TensorEnergy |
| variable {I J S : Type} [Fintype I] [Fintype J] [Fintype S] |
|
|
| lemma Bound.frobeniusSquared_row {A : I → J → ℝ} {C : ℝ} (h : Bound A C) (hC : 0≤C) : |
| ∑i,∑j,(A i j)^2≤Fintype.card I*C := by |
| have hb (i : I) : ∑j,(A i j)^2≤C := by |
| have hh := h.transpose hC (fun k => if k=i then 1 else 0) |
| simpa using hh |
| exact (Finset.sum_le_sum (fun i _ => hb i)).trans_eq (by simp) |
|
|
| lemma AllSplitBound.frobeniusSquared {d : ℕ} {T : (S → Fin d) → ℝ} {M : ℝ} |
| (h : AllSplitBound T M) [Nonempty I] (e : S ≃ I ⊕ Unit) : |
| ∑c,(T c)^2≤d*M^2 := by |
| let A : (Unit → Fin d) → (I → Fin d) → ℝ := |
| fun o i => T (fun s => Sum.elim i o (e s)) |
| have hb : Bound A (M^2) := h I Unit e |
| have he : (∑c,(T c)^2)=∑o : Unit → Fin d,∑i : I → Fin d,(A o i)^2 := by |
| let ec : ((Unit → Fin d) × (I → Fin d)) ≃ (S → Fin d) := |
| ((Equiv.prodComm _ _).trans (Equiv.sumArrowEquivProdArrow I Unit (Fin d)).symm).trans |
| (Equiv.arrowCongr e.symm (Equiv.refl (Fin d))) |
| have hh := Equiv.sum_comp ec (fun c => (T c)^2) |
| rw [Fintype.sum_prod_type] at hh |
| exact hh.symm |
| rw [he] |
| simpa using hb.frobeniusSquared_row (sq_nonneg M) |
| end TensorEnergy |
| end LogConcaveSampling |
|
|
| end |
|
|
| end |
|
|
| end |
|
|
| end OAI |
|
|
