import OAI.Geometry.LatticeCovering.GridCounts namespace OAI section noncomputable section noncomputable section noncomputable section open MeasureTheory Filter Set open scoped Topology noncomputable section namespace SingleLatticeCovering.SharpYoung structure PositiveDensity where toFun : ℝ → ℝ continuous : Continuous toFun positive : ∀ x, 0 < toFun x integrable : Integrable toFun volume integral_one : ∫ x, toFun x = 1 instance : CoeFun PositiveDensity (fun _ => ℝ → ℝ) := ⟨PositiveDensity.toFun⟩ def densityCDF (f : PositiveDensity) (x : ℝ) : ℝ := ∫ t in Iic x, f t lemma densityCDF_hasDerivAt (f : PositiveDensity) (x : ℝ) : HasDerivAt (densityCDF f) (f x) x := by have h := (intervalIntegral.integral_hasDerivAt_right (f.integrable.intervalIntegrable (a := 0) (b := x)) (f.continuous.stronglyMeasurableAtFilter volume (𝓝 x)) f.continuous.continuousAt).const_add (densityCDF f 0) convert! h using 1 funext u have hdiff := intervalIntegral.integral_Iic_sub_Iic (f.integrable.integrableOn (s := Iic 0)) (f.integrable.integrableOn (s := Iic u)) dsimp [densityCDF] at * linarith lemma densityCDF_continuous (f : PositiveDensity) : Continuous (densityCDF f) := continuous_iff_continuousAt.mpr (fun x => (densityCDF_hasDerivAt f x).continuousAt) lemma densityCDF_strictMono (f : PositiveDensity) : StrictMono (densityCDF f) := by apply strictMono_of_deriv_pos intro x rw [(densityCDF_hasDerivAt f x).deriv] exact f.positive x lemma densityCDF_add_tail (f : PositiveDensity) (x : ℝ) : densityCDF f x + (∫ t in Ioi x, f t) = 1 := by simpa [densityCDF, f.integral_one] using integral_add_compl measurableSet_Iic f.integrable lemma densityCDF_mem_Ioo (f : PositiveDensity) (x : ℝ) : densityCDF f x ∈ Ioo 0 1 := by have hnonneg (y : ℝ) : 0 ≤ densityCDF f y := integral_nonneg (fun t => (f.positive t).le) have hle (y : ℝ) : densityCDF f y ≤ 1 := by have ht : 0 ≤ ∫ t in Ioi y, f t := integral_nonneg (fun t => (f.positive t).le) linarith [densityCDF_add_tail f y] constructor · exact lt_of_le_of_lt (hnonneg (x-1)) (densityCDF_strictMono f (by linarith)) · exact lt_of_lt_of_le (densityCDF_strictMono f (show x < x+1 by linarith)) (hle (x+1)) lemma densityCDF_tendsto_bot (f : PositiveDensity) : Tendsto (densityCDF f) atBot (𝓝 0) := tendsto_integral_Iic_zero tendsto_id lemma densityCDF_tendsto_top (f : PositiveDensity) : Tendsto (densityCDF f) atTop (𝓝 1) := by have h : Tendsto (fun x : ℝ => 1 - ∫ t in Ioi x, f t) atTop (𝓝 (1-0)) := tendsto_const_nhds.sub (tendsto_integral_Ioi_zero tendsto_id) convert h using 1 · funext x linarith [densityCDF_add_tail f x] · norm_num lemma densityCDF_surjOn (f : PositiveDensity) : SurjOn (densityCDF f) univ (Ioo 0 1) := by exact isPreconnected_univ.intermediate_value_Ioo (by simp) (by simp) (densityCDF_continuous f).continuousOn (densityCDF_tendsto_bot f) (densityCDF_tendsto_top f) def densityCDFIso (f : PositiveDensity) : ℝ ≃o Ioo (0 : ℝ) 1 := StrictMono.orderIsoOfSurjective (fun x => ⟨densityCDF f x, densityCDF_mem_Ioo f x⟩) (fun _ _ h => densityCDF_strictMono f h) (fun y => by obtain ⟨x, _, hx⟩ := densityCDF_surjOn f y.property exact ⟨x, Subtype.ext hx⟩) @[simp] lemma densityCDFIso_apply (f : PositiveDensity) (x : ℝ) : (densityCDFIso f x : ℝ) = densityCDF f x := rfl def densityTransport (f g : PositiveDensity) : ℝ ≃o ℝ := (densityCDFIso f).trans (densityCDFIso g).symm lemma densityCDF_transport (f g : PositiveDensity) (x : ℝ) : densityCDF g (densityTransport f g x) = densityCDF f x := by change ((densityCDFIso g) ((densityCDFIso g).symm (densityCDFIso f x)) : ℝ) = _ simp lemma densityTransport_hasDerivAt (f g : PositiveDensity) (x : ℝ) : HasDerivAt (densityTransport f g) (f x / g (densityTransport f g x)) x := by apply HasDerivAt.of_comp_left (densityTransport f g).continuous.continuousAt (densityCDF_hasDerivAt g _) (densityCDF_hasDerivAt f x) (ne_of_gt (g.positive _)) exact Filter.Eventually.of_forall (densityCDF_transport f g) def normalizedGaussianDensity : PositiveDensity where toFun := fun x => Real.exp (-x^2) / Real.sqrt Real.pi continuous := by fun_prop positive := fun x => div_pos (Real.exp_pos _) (Real.sqrt_pos.mpr Real.pi_pos) integrable := by have h := integrable_exp_neg_mul_sq (show (0:ℝ) < 1 by norm_num) simpa using h.div_const (Real.sqrt Real.pi) integral_one := by simp_rw [div_eq_mul_inv] rw [integral_mul_const] have h := integral_gaussian (1 : ℝ) simp only [neg_mul, one_mul, div_one] at h rw [h, mul_inv_cancel₀ (ne_of_gt (Real.sqrt_pos.mpr Real.pi_pos))] lemma gaussian_transport_density (f : PositiveDensity) (x : ℝ) : Real.exp (-(densityTransport f normalizedGaussianDensity x)^2) * (f x / normalizedGaussianDensity (densityTransport f normalizedGaussianDensity x)) = Real.sqrt Real.pi * f x := by change Real.exp _ * (f x / (Real.exp _ / Real.sqrt Real.pi)) = _ field_simp end SingleLatticeCovering.SharpYoung namespace SingleLatticeCovering.SimplexYoung open SingleLatticeCovering.SharpYoung open MeasureTheory Filter Set open scoped Topology ENNReal def simplexConstant (r : ℕ) : ℝ := (Real.sqrt ((r:ℝ)/(r+1:ℕ)))⁻¹^r / Real.sqrt (r+1:ℕ) lemma simplexConstant_nonneg (r : ℕ) : 0 ≤ simplexConstant r := by unfold simplexConstant; positivity lemma simplex_positiveDensity_integral {r : ℕ} (hr : 0 < r) (f : Fin (r+1) → PositiveDensity) : (∫⁻ x : V r, ENNReal.ofReal (∏ i, (f i (simplexForm i x)) ^ ((r:ℝ)/(r+1:ℕ)))) ≤ ENNReal.ofReal (simplexConstant r) := by let T (i : Fin (r+1)) := densityTransport (f i) normalizedGaussianDensity let T' (i : Fin (r+1)) (t : ℝ) := f i t / normalizedGaussianDensity (T i t) have ht := simplex_transport_integral hr (T := fun i => T i) (T' := T') (fun i => (T i).strictMono) (fun i => densityTransport_hasDerivAt (f i) _) (fun i t => div_pos ((f i).positive t) (normalizedGaussianDensity.positive _)) have hpoint (x : V r) : (∏ i, (Real.exp (-(T i (simplexForm i x))^2) * T' i (simplexForm i x)) ^ ((r:ℝ)/(r+1:ℕ))) = (Real.sqrt Real.pi)^r * ∏ i, (f i (simplexForm i x)) ^ ((r:ℝ)/(r+1:ℕ)) := by change (∏ i, (Real.exp (-(densityTransport (f i) normalizedGaussianDensity (simplexForm i x))^2) * (f i (simplexForm i x) / normalizedGaussianDensity (densityTransport (f i) normalizedGaussianDensity (simplexForm i x)))) ^ ((r:ℝ)/(r+1:ℕ))) = _ simp_rw [gaussian_transport_density, Real.mul_rpow (Real.sqrt_nonneg _) ((f _).positive _).le] rw [Finset.prod_mul_distrib, Finset.prod_const, Finset.card_univ, Fintype.card_fin] congr 1 rw [←Real.rpow_natCast, ←Real.rpow_mul (Real.sqrt_nonneg _), div_mul_cancel₀ _ (by positivity : (r+1:ℕ) ≠ (0:ℝ)), Real.rpow_natCast] simp_rw [hpoint, ENNReal.ofReal_mul (pow_nonneg (Real.sqrt_nonneg _) r)] at ht rw [lintegral_const_mul' _ _ ENNReal.ofReal_ne_top] at ht have hp : 0 < (Real.sqrt Real.pi)^r := pow_pos (Real.sqrt_pos.mpr Real.pi_pos) r have hh : (∫⁻ x : V r, ENNReal.ofReal (∏ i, (f i (simplexForm i x)) ^ ((r:ℝ)/(r+1:ℕ)))) ≤ ENNReal.ofReal ((Real.sqrt (Real.pi/((r:ℝ)/(r+1:ℕ))))^r / Real.sqrt (r+1:ℕ)) / ENNReal.ofReal ((Real.sqrt Real.pi)^r) := (ENNReal.le_div_iff_mul_le (Or.inl (ne_of_gt (ENNReal.ofReal_pos.mpr hp))) (Or.inl ENNReal.ofReal_ne_top)).mpr (by rw [mul_comm]; exact ht) rw [←ENNReal.ofReal_div_of_pos hp] at hh have he : ((Real.sqrt (Real.pi/((r:ℝ)/(r+1:ℕ))))^r / Real.sqrt (r+1:ℕ)) / (Real.sqrt Real.pi)^r = simplexConstant r := by unfold simplexConstant rw [Real.sqrt_div Real.pi_pos.le, div_pow] have hc : 0 < Real.sqrt ((r:ℝ)/(r+1:ℕ)) := by positivity field_simp [hc.ne'] simp only [←mul_pow, one_div, mul_inv_cancel₀ hc.ne', one_pow] simpa only [he] using hh lemma integral_pos_of_continuous_density {f : ℝ → ℝ} (hp : ∀ x, 0 < f x) (hi : Integrable f volume) : 0 < ∫ x, f x := by apply (integral_pos_iff_support_of_nonneg (fun x => (hp x).le) hi).mpr have he : Function.support f = univ := by ext x simp [Function.mem_support, ne_of_gt (hp x)] rw [he] simp def normalizePositiveDensity (f : ℝ → ℝ) (hc : Continuous f) (hp : ∀ x, 0 < f x) (hi : Integrable f volume) : PositiveDensity where toFun := fun x => f x / ∫ t, f t continuous := hc.div_const _ positive := fun x => div_pos (hp x) (integral_pos_of_continuous_density hp hi) integrable := hi.div_const _ integral_one := by rw [integral_div, div_self (ne_of_gt (integral_pos_of_continuous_density hp hi))] lemma simplex_positive_integral {r : ℕ} (hr : 0 < r) (f : Fin (r+1) → ℝ → ℝ) (hc : ∀ i, Continuous (f i)) (hp : ∀ i x, 0 < f i x) (hi : ∀ i, Integrable (f i) volume) : (∫⁻ x : V r, ENNReal.ofReal (∏ i, (f i (simplexForm i x)) ^ ((r:ℝ)/(r+1:ℕ)))) ≤ ENNReal.ofReal (simplexConstant r * ∏ i, (∫ t, f i t) ^ ((r:ℝ)/(r+1:ℕ))) := by let g (i : Fin (r+1)) := normalizePositiveDensity (f i) (hc i) (hp i) (hi i) have hmass (i : Fin (r+1)) := integral_pos_of_continuous_density (hp i) (hi i) have he (i : Fin (r+1)) (x : ℝ) : f i x = (∫ t, f i t) * g i x := by dsimp [g, normalizePositiveDensity] field_simp [ne_of_gt (hmass i)] have hpoint (x : V r) : (∏ i, (f i (simplexForm i x)) ^ ((r:ℝ)/(r+1:ℕ))) = (∏ i, (∫ t, f i t) ^ ((r:ℝ)/(r+1:ℕ))) * ∏ i, (g i (simplexForm i x)) ^ ((r:ℝ)/(r+1:ℕ)) := by conv_lhs => arg 2; ext i; rw [he i (simplexForm i x)] simp_rw [Real.mul_rpow (hmass _).le ((g _).positive _).le] rw [Finset.prod_mul_distrib] have hn : 0 ≤ ∏ i, (∫ t, f i t) ^ ((r:ℝ)/(r+1:ℕ)) := Finset.prod_nonneg (fun i _ => Real.rpow_nonneg (hmass i).le _) simp_rw [hpoint, ENNReal.ofReal_mul hn] rw [lintegral_const_mul' _ _ ENNReal.ofReal_ne_top, ENNReal.ofReal_mul (simplexConstant_nonneg r)] rw [mul_comm (ENNReal.ofReal (simplexConstant r))] exact mul_le_mul' le_rfl (simplex_positiveDensity_integral hr g) lemma simplex_nonneg_integral {r : ℕ} (hr : 0 < r) (f : Fin (r+1) → ℝ → ℝ) (hc : ∀ i, Continuous (f i)) (hp : ∀ i x, 0 ≤ f i x) (hi : ∀ i, Integrable (f i) volume) : (∫⁻ x : V r, ENNReal.ofReal (∏ i, (f i (simplexForm i x)) ^ ((r:ℝ)/(r+1:ℕ)))) ≤ ENNReal.ofReal (simplexConstant r * ∏ i, (∫ t, f i t) ^ ((r:ℝ)/(r+1:ℕ))) := by have he (ε : ℝ) (hε : 0 < ε) : (∫⁻ x : V r, ENNReal.ofReal (∏ i, (f i (simplexForm i x)) ^ ((r:ℝ)/(r+1:ℕ)))) ≤ ENNReal.ofReal (simplexConstant r * ∏ i, ((∫ t, f i t)+ε) ^ ((r:ℝ)/(r+1:ℕ))) := by let F (i : Fin (r+1)) (x : ℝ) := f i x + ε * normalizedGaussianDensity x have hcF (i : Fin (r+1)) : Continuous (F i) := (hc i).add (continuous_const.mul normalizedGaussianDensity.continuous) have hpF (i : Fin (r+1)) (x : ℝ) : 0 < F i x := add_pos_of_nonneg_of_pos (hp i x) (mul_pos hε (normalizedGaussianDensity.positive x)) have hiF (i : Fin (r+1)) : Integrable (F i) volume := (hi i).add (normalizedGaussianDensity.integrable.const_mul ε) have hmF (i : Fin (r+1)) : ∫ t, F i t = (∫ t, f i t)+ε := by dsimp [F] rw [integral_add (hi i) (normalizedGaussianDensity.integrable.const_mul ε), integral_const_mul, normalizedGaussianDensity.integral_one, mul_one] have hmono : (∫⁻ x : V r, ENNReal.ofReal (∏ i, (f i (simplexForm i x)) ^ ((r:ℝ)/(r+1:ℕ)))) ≤ (∫⁻ x : V r, ENNReal.ofReal (∏ i, (F i (simplexForm i x)) ^ ((r:ℝ)/(r+1:ℕ)))) := by apply lintegral_mono intro x apply ENNReal.ofReal_le_ofReal apply Finset.prod_le_prod₀ · intro i _ exact Real.rpow_nonneg (hp i _) _ · intro i _ apply Real.rpow_le_rpow (hp i _) · exact le_add_of_nonneg_right (mul_nonneg hε.le (normalizedGaussianDensity.positive _).le) · positivity simpa only [hmF] using hmono.trans (simplex_positive_integral hr F hcF hpF hiF) have hct : ContinuousAt (fun ε : ℝ => ENNReal.ofReal (simplexConstant r * ∏ i, ((∫ t, f i t)+ε) ^ ((r:ℝ)/(r+1:ℕ)))) 0 := by apply ENNReal.continuous_ofReal.continuousAt.comp fun_prop (disch := positivity) have ht := hct.tendsto.comp (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)) simp only [add_zero] at ht apply ge_of_tendsto ht exact Filter.Eventually.of_forall (fun n => he (1 / ((n:ℝ)+1)) (by positivity)) end SingleLatticeCovering.SimplexYoung open MeasureTheory Filter Set open scoped Topology ENNReal noncomputable section namespace SingleLatticeCovering.SharpYoung lemma continuous_finTail {d : ℕ} {E : Type*} [TopologicalSpace E] : Continuous (Fin.tail : (Fin (d+1) → E) → (Fin d → E)) := by exact continuous_pi (fun j => continuous_apply j.succ) lemma hasCompactSupport_finCons {d : ℕ} {f : (Fin (d+1) → ℝ) → ℝ} (hf : HasCompactSupport f) : HasCompactSupport (fun p : ℝ × (Fin d → ℝ) => f (Fin.cons p.1 p.2)) := by apply HasCompactSupport.intro (hf.isCompact.image ((continuous_apply 0).prodMk continuous_finTail)) intro p hp by_contra hn apply hp refine ⟨Fin.cons p.1 p.2, subset_tsupport f hn, ?_⟩ simp lemma hasCompactSupport_finSlice {d : ℕ} {f : (Fin (d+1) → ℝ) → ℝ} (hf : HasCompactSupport f) (y : Fin d → ℝ) : HasCompactSupport (fun t : ℝ => f (Fin.cons t y)) := by apply HasCompactSupport.intro (hf.isCompact.image (continuous_apply 0)) intro t ht by_contra hn exact ht ⟨Fin.cons t y, subset_tsupport f hn, by simp⟩ def finMarginal {d : ℕ} (f : (Fin (d+1) → ℝ) → ℝ) (y : Fin d → ℝ) : ℝ := ∫ t : ℝ, f (Fin.cons t y) lemma hasCompactSupport_finMarginal {d : ℕ} {f : (Fin (d+1) → ℝ) → ℝ} (hf : HasCompactSupport f) : HasCompactSupport (finMarginal f) := by apply HasCompactSupport.intro (hf.isCompact.image continuous_finTail) intro y hy have hz (t : ℝ) : f (Fin.cons t y) = 0 := by by_contra hn exact hy ⟨Fin.cons t y, subset_tsupport f hn, by simp⟩ simp [finMarginal, hz] lemma continuous_finMarginal {d : ℕ} {f : (Fin (d+1) → ℝ) → ℝ} (hc : Continuous f) (hk : HasCompactSupport f) : Continuous (finMarginal f) := by apply continuousOn_univ.mp apply continuousOn_integral_of_compact_support (hk.isCompact.image (continuous_apply 0)) · exact (hc.comp (continuous_snd.finCons continuous_fst)).continuousOn · intro y t _ ht by_contra hn exact ht ⟨Fin.cons t y, subset_tsupport f hn, by simp⟩ lemma finMarginal_nonneg {d : ℕ} {f : (Fin (d+1) → ℝ) → ℝ} (hf : 0 ≤ f) : 0 ≤ finMarginal f := fun y => integral_nonneg (fun t => hf (Fin.cons t y)) lemma integral_finMarginal {d : ℕ} {f : (Fin (d+1) → ℝ) → ℝ} (hc : Continuous f) (hk : HasCompactSupport f) : ∫ y, finMarginal f y = ∫ x, f x := by have hm := (volume_preserving_piFinSuccAbove (fun _ : Fin (d+1) => ℝ) 0).symm have he := hm.integral_comp' f simp only [MeasurableEquiv.piFinSuccAbove_symm_apply, Fin.insertNthEquiv_zero] at he rw [← he] symm exact integral_prod_symm (fun p : ℝ × (Fin d → ℝ) => f (Fin.cons p.1 p.2)) ((hc.comp (continuous_fst.finCons continuous_snd)).integrable_of_hasCompactSupport (hasCompactSupport_finCons hk)) lemma lintegral_finCons {d : ℕ} {E : Type*} [MeasureSpace E] [SigmaFinite (volume : Measure E)] (f : (Fin (d+1) → E) → ℝ≥0∞) (hf : Measurable f) : ∫⁻ x, f x = ∫⁻ y : Fin d → E, ∫⁻ t : E, f (Fin.cons t y) := by have hm := (volume_preserving_piFinSuccAbove (fun _ : Fin (d+1) => E) 0).symm have he := hm.lintegral_comp_emb (MeasurableEquiv.measurableEmbedding _) f simp only [MeasurableEquiv.piFinSuccAbove_symm_apply, Fin.insertNthEquiv_zero] at he rw [← he] apply lintegral_prod_symm _ simpa only [MeasurableEquiv.piFinSuccAbove_symm_apply, Fin.insertNthEquiv_zero, Function.comp_def, Fin.consEquiv_apply] using (hf.comp (MeasurableEquiv.piFinSuccAbove (fun _ : Fin (d+1) => E) 0).symm.measurable).aemeasurable end SingleLatticeCovering.SharpYoung namespace SingleLatticeCovering.SimplexYoung open SingleLatticeCovering.SharpYoung open MeasureTheory Filter Set open scoped Topology ENNReal def simplexSpatial {r d : ℕ} (i : Fin (r+1)) (x : Fin d → V r) : Fin d → ℝ := fun j => simplexForm i (x j) lemma continuous_simplexSpatial {r d : ℕ} (i : Fin (r+1)) : Continuous (simplexSpatial (d := d) i) := by exact continuous_pi (fun j => (simplexForm i).continuous_of_finiteDimensional.comp (continuous_apply j)) lemma simplexSpatial_cons {r d : ℕ} (i : Fin (r+1)) (t : V r) (x : Fin d → V r) : simplexSpatial i (Fin.cons t x) = Fin.cons (simplexForm i t) (simplexSpatial i x) := by ext j refine Fin.cases ?_ (fun k => ?_) j <;> simp [simplexSpatial] lemma simplex_cc_integral {r : ℕ} (hr : 0 < r) (d : ℕ) (f : Fin (r+1) → (Fin d → ℝ) → ℝ) (hc : ∀ i, Continuous (f i)) (hn : ∀ i x, 0 ≤ f i x) (hk : ∀ i, HasCompactSupport (f i)) : (∫⁻ x : Fin d → V r, ENNReal.ofReal (∏ i, (f i (simplexSpatial i x)) ^ ((r:ℝ)/(r+1:ℕ)))) ≤ ENNReal.ofReal ((simplexConstant r)^d * ∏ i, (∫ t, f i t) ^ ((r:ℝ)/(r+1:ℕ))) := by induction d with | zero => rw [Measure.volume_pi_eq_dirac (0 : Fin 0 → V r), lintegral_dirac] simp_rw [Measure.volume_pi_eq_dirac (0 : Fin 0 → ℝ), integral_dirac] simp only [pow_zero, one_mul] apply le_of_eq congr 1 apply Finset.prod_congr rfl intro i _ congr 2 exact Subsingleton.elim _ _ | succ d ih => have hmeas : Measurable (fun x : Fin (d+1) → V r => ENNReal.ofReal (∏ i, (f i (simplexSpatial i x)) ^ ((r:ℝ)/(r+1:ℕ)))) := by apply Continuous.measurable apply ENNReal.continuous_ofReal.comp exact continuous_finsetProd _ (fun i _ => (hc i |>.comp (continuous_simplexSpatial i)).rpow_const (fun _ => Or.inr (by positivity))) rw [lintegral_finCons _ hmeas] let g (i : Fin (r+1)) := finMarginal (f i) have hcons (z : Fin d → ℝ) : Continuous (fun t : ℝ => (Fin.cons t z : Fin (d+1) → ℝ)) := by apply continuous_pi intro j exact Fin.cases continuous_id (fun _ => continuous_const) j have hinner (y : Fin d → V r) : (∫⁻ t : V r, ENNReal.ofReal (∏ i, f i (simplexSpatial i (Fin.cons t y)) ^ ((r:ℝ)/(r+1:ℕ)))) ≤ ENNReal.ofReal (simplexConstant r * ∏ i, g i (simplexSpatial i y) ^ ((r:ℝ)/(r+1:ℕ))) := by simp_rw [simplexSpatial_cons] apply simplex_nonneg_integral hr (fun i t => f i (Fin.cons t (simplexSpatial i y))) · intro i exact (hc i).comp (hcons (simplexSpatial i y)) · intro i t exact hn i _ · intro i exact ((hc i).comp (hcons (simplexSpatial i y))).integrable_of_hasCompactSupport (hasCompactSupport_finSlice (hk i) _) apply (lintegral_mono hinner).trans have hcst : 0 ≤ simplexConstant r := simplexConstant_nonneg r simp_rw [ENNReal.ofReal_mul hcst] rw [lintegral_const_mul' _ _ ENNReal.ofReal_ne_top] have hbound := ih g (fun i => continuous_finMarginal (hc i) (hk i)) (fun i x => finMarginal_nonneg (hn i) x) (fun i => hasCompactSupport_finMarginal (hk i)) have hmass (i : Fin (r+1)) : ∫ t, g i t = ∫ t, f i t := integral_finMarginal (hc i) (hk i) simp_rw [hmass] at hbound have hh := mul_le_mul' (le_refl (ENNReal.ofReal (simplexConstant r))) hbound convert hh using 1 rw [← ENNReal.ofReal_mul hcst, pow_succ] congr 1 ring end SingleLatticeCovering.SimplexYoung namespace SingleLatticeCovering.SimplexYoung open MeasureTheory Filter Set open scoped Topology ENNReal def simplexConfiguration {r d : ℕ} (J : Fin (r+1) → Set (Fin d → ℝ)) : Set (Fin d → V r) := {x | ∀ i, simplexSpatial i x ∈ J i} lemma simplexConfiguration_measurable {r d : ℕ} {J : Fin (r+1) → Set (Fin d → ℝ)} (hJ : ∀ i, MeasurableSet (J i)) : MeasurableSet (simplexConfiguration J) := by unfold simplexConfiguration rw [Set.ofPred_forall] apply MeasurableSet.iInter intro i exact (hJ i).preimage (continuous_simplexSpatial i).measurable lemma simplex_measure_le_cc {r d : ℕ} (hr : 0 < r) {J : Fin (r+1) → Set (Fin d → ℝ)} (hJ : ∀ i, MeasurableSet (J i)) (f : Fin (r+1) → (Fin d → ℝ) → ℝ) (hc : ∀ i, Continuous (f i)) (hn : ∀ i z, 0 ≤ f i z) (hk : ∀ i, HasCompactSupport (f i)) (hf : ∀ i, EqOn (f i) 1 (J i)) : volume (simplexConfiguration J) ≤ ENNReal.ofReal ((simplexConstant r)^d * ∏ i, (∫ z, f i z) ^ ((r:ℝ)/(r+1:ℕ))) := by apply le_trans _ (simplex_cc_integral hr d f hc hn hk) rw [←lintegral_indicator_one (simplexConfiguration_measurable hJ)] apply lintegral_mono intro x by_cases hx : x ∈ simplexConfiguration J · have hh (i : Fin (r+1)) : f i (simplexSpatial i x) = 1 := hf i (hx i) simp [Set.indicator_of_mem hx, hh] · simp [Set.indicator_of_notMem hx] lemma volume_simplexConfiguration_le {r d : ℕ} (hr : 0 < r) {J : Fin (r+1) → Set (Fin d → ℝ)} (hJ : ∀ i, IsCompact (J i)) : volume (simplexConfiguration J) ≤ ENNReal.ofReal ((simplexConstant r)^d * ∏ i, ((volume (J i)).toReal)^((r:ℝ)/(r+1:ℕ))) := by let M (i : Fin (r+1)) := (volume (J i)).toReal have hM (i) : 0 ≤ M i := ENNReal.toReal_nonneg have hh (ε : ℝ) (hε : 0 < ε) : volume (simplexConfiguration J) ≤ ENNReal.ofReal ((simplexConstant r)^d * ∏ i, (M i+ε)^((r:ℝ)/(r+1:ℕ))) := by have hex (i : Fin (r+1)) : ∃ f : (Fin d → ℝ) → ℝ, Continuous f ∧ HasCompactSupport f ∧ EqOn f 1 (J i) ∧ (∀ z, 0 ≤ f z) ∧ ENNReal.ofReal (∫ z, f z) < ENNReal.ofReal (M i+ε) := by have hlt : volume (J i) < ENNReal.ofReal (M i+ε) := by rw [←ENNReal.ofReal_toReal (hJ i).measure_ne_top] apply ENNReal.ofReal_lt_ofReal_iff (add_pos_of_nonneg_of_pos (hM i) hε) |>.mpr dsimp [M]; linarith rw [(hJ i).measure_eq_biInf_integral_hasCompactSupport volume] at hlt simp only [iInf_lt_iff] at hlt obtain ⟨f, hc, hk, heq, hn, hfi⟩ := hlt exact ⟨f, hc, hk, heq, hn, hfi⟩ choose f hc hk heq hn hfi using hex apply (simplex_measure_le_cc hr (fun i => (hJ i).measurableSet) f hc hn hk heq).trans apply ENNReal.ofReal_le_ofReal apply mul_le_mul_of_nonneg_left _ (pow_nonneg (simplexConstant_nonneg r) _) apply Finset.prod_le_prod₀ · intro i _; exact Real.rpow_nonneg (integral_nonneg (hn i)) _ · intro i _ apply Real.rpow_le_rpow (integral_nonneg (hn i)) _ (by positivity) exact (ENNReal.ofReal_lt_ofReal_iff (add_pos_of_nonneg_of_pos (hM i) hε)).mp (hfi i) |>.le have hct : ContinuousAt (fun ε : ℝ => ENNReal.ofReal ((simplexConstant r)^d * ∏ i, (M i+ε)^((r:ℝ)/(r+1:ℕ)))) 0 := by apply ENNReal.continuous_ofReal.continuousAt.comp fun_prop (disch := positivity) have ht := hct.tendsto.comp (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)) have hle := ge_of_tendsto ht (Filter.Eventually.of_forall (fun n => hh (1/((n:ℝ)+1)) (by positivity))) simpa only [add_zero, M] using hle end SingleLatticeCovering.SimplexYoung namespace SingleLatticeCovering.SimplexYoung open MeasureTheory Measure Set Matrix open scoped ENNReal Pointwise def weightedSimplexConfiguration {r d : ℕ} (J : Set (Fin d → ℝ)) (c : Fin r → ℝ) : Set (Fin d → V r) := {x | (∀ j, (fun a => x a j) ∈ J) ∧ (fun a => ∑ j, c j * x a j) ∈ J} def simplexDiagonal {r d : ℕ} (c : Fin r → ℝ) : (Fin d → V r) →ₗ[ℝ] (Fin d → V r) := LinearMap.pi (fun a : Fin d => (Matrix.diagonal c).mulVecLin.comp (LinearMap.proj a)) lemma simplexDiagonal_apply {r d : ℕ} (c : Fin r → ℝ) (x : Fin d → V r) (a : Fin d) (j : Fin r) : simplexDiagonal c x a j = c j * x a j := by simp [simplexDiagonal, Matrix.mulVec_diagonal] lemma simplexDiagonal_det {r d : ℕ} (c : Fin r → ℝ) : LinearMap.det (simplexDiagonal (d := d) c) = (∏ j, c j)^d := by unfold simplexDiagonal rw [LinearMap.det_pi] have h : LinearMap.det (Matrix.diagonal c).mulVecLin = ∏ j, c j := by rw [←Matrix.toLin'_apply', LinearMap.det_toLin', Matrix.det_diagonal] simp [h] def scaledCircuitFamily {r d : ℕ} (J : Set (Fin d → ℝ)) (c : Fin r → ℝ) : Fin (r+1) → Set (Fin d → ℝ) := Fin.cons ((-1:ℝ) • J) (fun j => c j • J) lemma scaledCircuitFamily_compact {r d : ℕ} {J : Set (Fin d → ℝ)} (hJ : IsCompact J) (c : Fin r → ℝ) (i : Fin (r+1)) : IsCompact (scaledCircuitFamily J c i) := by refine Fin.cases ?_ (fun j => ?_) i <;> exact hJ.image (by fun_prop) lemma weightedSimplexConfiguration_preimage {r d : ℕ} (J : Set (Fin d → ℝ)) (c : Fin r → ℝ) (hc : ∀ j, c j ≠ 0) : weightedSimplexConfiguration J c = simplexDiagonal c ⁻¹' simplexConfiguration (scaledCircuitFamily J c) := by ext x change (_ ∧ _) ↔ ∀ i, simplexSpatial i (simplexDiagonal c x) ∈ scaledCircuitFamily J c i rw [Fin.forall_fin_succ] have h0 : simplexSpatial 0 (simplexDiagonal c x) = (-1:ℝ) • (fun a => ∑ j, c j * x a j) := by ext a simp [simplexSpatial, simplexForm_zero, simplexDiagonal_apply] have hs (j : Fin r) : simplexSpatial j.succ (simplexDiagonal c x) = c j • (fun a => x a j) := by ext a simp [simplexSpatial, simplexForm_succ, simplexDiagonal_apply] simp only [scaledCircuitFamily, Fin.cons_zero, Fin.cons_succ, h0, hs, smul_mem_smul_set_iff₀ (by norm_num : (-1:ℝ) ≠ 0), smul_mem_smul_set_iff₀ (hc _)] exact and_comm lemma volume_scaledCircuitFamily {r d : ℕ} (J : Set (Fin d → ℝ)) (c : Fin r → ℝ) : (volume (scaledCircuitFamily J c 0)).toReal = (volume J).toReal ∧ ∀ j, (volume (scaledCircuitFamily J c j.succ)).toReal = |c j|^d * (volume J).toReal := by constructor · simp [scaledCircuitFamily] · intro j simp [scaledCircuitFamily, Measure.addHaar_smul, abs_pow, ENNReal.toReal_mul] theorem volume_weightedSimplexConfiguration_le {r d : ℕ} (hr : 0 < r) {J : Set (Fin d → ℝ)} (hJ : IsCompact J) (c : Fin r → ℝ) (hc : ∀ j, c j ≠ 0) : volume (weightedSimplexConfiguration J c) ≤ ENNReal.ofReal ((∏ j, |c j|)⁻¹^d * (simplexConstant r)^d * ((volume J).toReal^((r:ℝ)/(r+1:ℕ)) * ∏ j, (|c j|^d * (volume J).toReal)^((r:ℝ)/(r+1:ℕ)))) := by rw [weightedSimplexConfiguration_preimage J c hc, addHaar_preimage_linearMap volume (by rw [simplexDiagonal_det]; exact pow_ne_zero _ (Finset.prod_ne_zero_iff.mpr (fun j _ => hc j))), simplexDiagonal_det] have hb := volume_simplexConfiguration_le hr (scaledCircuitFamily_compact hJ c) apply (mul_le_mul_right hb _).trans_eq rw [←ENNReal.ofReal_mul (by positivity)] congr 1 rw [Fin.prod_univ_succ, (volume_scaledCircuitFamily J c).1] simp_rw [(volume_scaledCircuitFamily J c).2] rw [←inv_pow, abs_pow, abs_inv, Finset.abs_prod] ring end SingleLatticeCovering.SimplexYoung noncomputable section namespace SingleLatticeCovering.SimplexYoung open scoped BigOperators lemma weightedCircuitFactor {r d : ℕ} (hr : 0 < r) (a : Fin r → ℝ) (ha : ∀ j, 0 < a j) (u C : ℝ) (hu : 0 ≤ u) : (∏ j, a j)⁻¹^d * C^d * (u^((r:ℝ)/(r+1:ℕ)) * ∏ j, (a j^d*u)^((r:ℝ)/(r+1:ℕ))) = C^d * (∏ j, a j^(-((d:ℝ)/(r+1:ℕ)))) * u^r := by have hn : (r+1:ℝ) ≠ 0 := by positivity have hp : 0 < (r:ℝ)/(r+1:ℕ) := div_pos (by exact_mod_cast hr) (by positivity) by_cases hz : u = 0 · rw [hz, Real.zero_rpow hp.ne', zero_mul, mul_zero, zero_pow hr.ne', mul_zero] have hu' : 0 < u := lt_of_le_of_ne hu (Ne.symm hz) let p : ℝ := (r:ℝ)/(r+1:ℕ) change _ * _ * (u^p * ∏ j, (a j^d*u)^p) = _ have hdist (j : Fin r) : (a j^d*u)^p = (a j)^(d*p) * u^p := by rw [Real.mul_rpow (pow_nonneg (ha j).le _) hu, ←Real.rpow_natCast, ←Real.rpow_mul (ha j).le] simp_rw [hdist] rw [Finset.prod_mul_distrib, Finset.prod_const, Finset.card_univ, Fintype.card_fin] have he : p*(r+1:ℕ) = (r:ℝ) := by dsimp [p]; exact div_mul_cancel₀ _ (by positivity) have huPow : u^p*(u^p)^r = u^r := by rw [←pow_succ', ←Real.rpow_natCast, ←Real.rpow_mul hu, he, Real.rpow_natCast] have hprod : (∏ j, a j)⁻¹^d * (∏ j, (a j)^((d:ℝ)*p)) = ∏ j, a j^(-((d:ℝ)/(r+1:ℕ))) := by rw [←Finset.prod_inv_distrib, ←Finset.prod_pow, ←Finset.prod_mul_distrib] apply Finset.prod_congr rfl intro j _ rw [←Real.rpow_natCast, ←Real.rpow_neg_one, ←Real.rpow_mul (ha j).le, ←Real.rpow_add (ha j)] congr 1 dsimp [p] push_cast field_simp ring calc _ = C^d * ((∏ j, a j)⁻¹^d * (∏ j, (a j)^((d:ℝ)*p))) * (u^p*(u^p)^r) := by ring _ = _ := by rw [hprod, huPow] end SingleLatticeCovering.SimplexYoung end end end end end end end end OAI