openAI-math-dataset / lean /OAI /MathematicalPhysics /Boltzmann /Approximation /CapFiniteBackgroundLimit.lean
| import OAI.MathematicalPhysics.Boltzmann.Approximation.CapHotUndamped | |
| import OAI.MathematicalPhysics.Boltzmann.Approximation.CapLabelFreeLimit | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.BackgroundCappedLoss | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.FiniteDepthKernelOrder | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.FiniteHorizonRatio | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.WeakL1ToWeakStar | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.WeakL1Operations | |
| import OAI.MathematicalPhysics.Boltzmann.Jets.ColdMildRepresentative | |
| import OAI.MathematicalPhysics.Boltzmann.Jets.JetCoreMomentBound | |
| import OAI.MathematicalPhysics.Boltzmann.Jets.JetFamilyBounds | |
| import OAI.MathematicalPhysics.Boltzmann.Jets.ThermalStripeIdentity | |
| namespace OAI | |
| section | |
| /-! # Cold free-flight convergence without additional small-scale hypotheses -/ | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped Topology Pointwise | |
| open BoltzmannNonuniqueness.JetLattice BoltzmannNonuniqueness.JetGeometry | |
| open BoltzmannNonuniqueness.VelocityWeight BoltzmannNonuniqueness.WeightedTranslation | |
| namespace BoltzmannNonuniqueness.JetCopyDatum | |
| theorem cap_cold_dilation_limit {s₀ η K α γ d₀ q T a S U : ℝ} | |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) | |
| (hK : 0 ≤ K) (hα : 0 ≤ α) (hαmax : α ≤ 1/4) (hγ : 0 ≤ γ) | |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) (hT : 0 ≤ T) (hTmax : T ≤ 1/32) | |
| (hq : q < 2) (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) | |
| (N : ℕ → ℕ) (F : ∀ n, CapApproximation s₀ η K α γ d₀ q T (N n)) | |
| (j : ℕ → Label) (hj0 : ∀ n, (j n).lattice = 0) (hj : ∀ n, (j n).annulus < N n) | |
| (r t : ℕ → ℝ) (hr : ∀ n, 0 < r n) (hrlim : Tendsto r atTop (𝓝 0)) | |
| (ht : ∀ n, t n ∈ Ioc 0 T) (ha : 0 < a) (hS : 0 ≤ S) | |
| (hlo : ∀ n, a*r n ≤ jetScale s₀ η (j n).annulus) | |
| (hhi : ∀ n, jetScale s₀ η (j n).annulus ≤ S*r n) | |
| (htime : ∀ n, t n ≤ U*r n) | |
| (hδ : ∀ n, DatumBounds.scale s₀ η (N n+1) ≤ r n) | |
| (Ω : Set JetPrototype.Space) (hΩ : IsCompact Ω) : | |
| Tendsto (fun n => ∫ x in Ω, ∫ v : Velocity, | |
| |r n*(H q v*(F n).cold (j n) (t n,(r n • x,v))- | |
| JetFreeTransport.free η K α γ (jetScale s₀ η (j n).annulus) | |
| (d₀*jetScale s₀ η (j n).annulus^10) (t n) (j n).positive | |
| (shift (displacement (j n).lattice) (r n • x,v)))| | |
| ∂volume ∂JetPrototype.spaceVolume) atTop (𝓝 0) := by | |
| have hslim : Tendsto (fun n => jetScale s₀ η (j n).annulus) atTop (𝓝 0) := by | |
| apply squeeze_zero (fun n => (DatumBounds.scale_pos (η := η) hs₀ _).le) hhi | |
| simpa only [mul_zero] using hrlim.const_mul S | |
| obtain ⟨n₀,hn₀⟩ := eventually_atTop.mp (eventually_cold_survival_geometry (T := T) (d₀ := d₀) hη hslim) | |
| apply (tendsto_add_atTop_iff_nat n₀).mp | |
| exact cap_cold_dilation_free_error hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max hT hTmax hq hsmall | |
| (fun n => N (n+n₀)) (fun n => F (n+n₀)) (fun n => j (n+n₀)) | |
| (fun n => hj0 (n+n₀)) (fun n => hj (n+n₀)) (fun n => r (n+n₀)) (fun n => t (n+n₀)) | |
| (fun n => hr (n+n₀)) (hrlim.comp (tendsto_add_atTop_nat n₀)) | |
| (fun n => ht (n+n₀)) ha hS (fun n => hlo (n+n₀)) (fun n => hhi (n+n₀)) | |
| (fun n => htime (n+n₀)) (fun n => hδ (n+n₀)) | |
| (fun n => (hn₀ (n+n₀) (by omega)).1) (fun n => (hn₀ (n+n₀) (by omega)).2) Ω hΩ | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| end | |
| end | |
| section | |
| /-! # Local integrability of the actual cold colors and their free profiles -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open BoltzmannNonuniqueness.VelocityWeight | |
| namespace BoltzmannNonuniqueness.JetCopyDatum | |
| theorem CapApproximation.cold_physical_integrable {s₀ η K α γ d₀ q T : ℝ} {N : ℕ} | |
| (F : CapApproximation s₀ η K α γ d₀ q T N) | |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) | |
| (hK : 0 ≤ K) (hd₀ : 0 ≤ d₀) (hq : q < 2) (hT : 0 ≤ T) | |
| (i : JetLattice.Label) (t : ℝ) (μ : Measure JetPrototype.Space) [IsFiniteMeasure μ] : | |
| Integrable (fun p : JetPrototype.Phase => H q p.2*F.cold i (t,p)) (μ.prod volume) := by | |
| have hc := F.cold_properties hs₀ hsmax hη hηmax hK hd₀ hq hT | |
| have hm : Measurable (fun p : JetPrototype.Phase => H q p.2*F.cold i (t,p)) := | |
| ((ChartKernel.measurable_H q).comp measurable_snd).mul | |
| ((hc.1 i).comp (measurable_const.prodMk measurable_id)) | |
| apply (((integrable_H hq).comp_snd μ).const_mul (2*F.amplitude)).mono' hm.aestronglyMeasurable | |
| filter_upwards [] with p | |
| rw [Real.norm_of_nonneg (mul_nonneg (H_nonneg q p.2) (hc.2.1 i (t,p)))] | |
| have hb : F.cold i (t,p) ≤ 2*F.amplitude := by | |
| simpa only [Finset.sum_singleton] using (hc.2.2.1 {i} (t,p)).trans (F.solution.value_bounds (t,p)).2 | |
| exact (mul_le_mul_of_nonneg_left hb (H_nonneg q p.2)).trans_eq (mul_comm _ _) | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| namespace BoltzmannNonuniqueness.JetFreeTransport | |
| theorem local_integrable {K α γ s d t : ℝ} | |
| (hK : 0 ≤ K) (hα : 0 ≤ α) (hγ : 0 ≤ γ) (hs : 0 < s) (hd : 0 < d) | |
| (ht : 0 < t) (htmax : t ≤ 1) (η : ℝ) (a : Bool) | |
| (μ : Measure JetPrototype.Space) [IsFiniteMeasure μ] : | |
| Integrable (free η K α γ s d t a) (μ.prod volume) := by | |
| have hi := JetBarrierLocalMass.local_integrable hK hα hγ hs hd ht htmax η a 0 μ | |
| simp only [sub_zero] at hi | |
| apply hi.mono' (measurable_free η K α γ s d t a).aestronglyMeasurable | |
| filter_upwards [] with p | |
| rw [Real.norm_of_nonneg (free_nonneg hK hs.le hd.le η α γ t a p)] | |
| exact free_le_barrier hK hd hα hγ hs ht (htmax.trans (by norm_num)) η a p | |
| end BoltzmannNonuniqueness.JetFreeTransport | |
| end | |
| end | |
| section | |
| /-! # Product-space L1 convergence of the actual cold dilation to free transport -/ | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped Topology Pointwise | |
| open BoltzmannNonuniqueness.JetLattice BoltzmannNonuniqueness.JetGeometry | |
| open BoltzmannNonuniqueness.VelocityWeight BoltzmannNonuniqueness.WeightedTranslation | |
| namespace BoltzmannNonuniqueness.JetCopyDatum | |
| theorem cap_cold_L1_dilation_limit {s₀ η K α γ d₀ q T a S U : ℝ} | |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) | |
| (hK : 0 ≤ K) (hα : 0 ≤ α) (hαmax : α ≤ 1/4) (hγ : 0 ≤ γ) | |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) (hT : 0 ≤ T) (hTmax : T ≤ 1/32) | |
| (hq : q < 2) (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) | |
| (N : ℕ → ℕ) (F : ∀ n, CapApproximation s₀ η K α γ d₀ q T (N n)) | |
| (j : ℕ → Label) (hj0 : ∀ n, (j n).lattice = 0) (hj : ∀ n, (j n).annulus < N n) | |
| (r t : ℕ → ℝ) (hr : ∀ n, 0 < r n) (hrlim : Tendsto r atTop (𝓝 0)) | |
| (ht : ∀ n, t n ∈ Ioc 0 T) (ha : 0 < a) (hS : 0 ≤ S) | |
| (hlo : ∀ n, a*r n ≤ jetScale s₀ η (j n).annulus) | |
| (hhi : ∀ n, jetScale s₀ η (j n).annulus ≤ S*r n) | |
| (htime : ∀ n, t n ≤ U*r n) | |
| (hδ : ∀ n, DatumBounds.scale s₀ η (N n+1) ≤ r n) | |
| (Ω : Set JetPrototype.Space) (hΩ : IsCompact Ω) : | |
| Tendsto (fun n => ∫ p : JetPrototype.Phase, | |
| |r n*(H q p.2*(F n).cold (j n) (t n,(r n • p.1,p.2))- | |
| JetFreeTransport.free η K α γ (jetScale s₀ η (j n).annulus) | |
| (d₀*jetScale s₀ η (j n).annulus^10) (t n) (j n).positive | |
| (shift (displacement (j n).lattice) (r n • p.1,p.2)))| | |
| ∂(JetPrototype.spaceVolume.restrict Ω).prod volume) atTop (𝓝 0) := by | |
| have hbase := cap_cold_dilation_limit hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max | |
| hT hTmax hq hsmall N F j hj0 hj r t hr hrlim ht ha hS hlo hhi htime hδ Ω hΩ | |
| apply hbase.congr' | |
| have hslim : Tendsto (fun n => jetScale s₀ η (j n).annulus) atTop (𝓝 0) := by | |
| apply squeeze_zero (fun n => (DatumBounds.scale_pos (η := η) hs₀ _).le) hhi | |
| simpa only [mul_zero] using hrlim.const_mul S | |
| filter_upwards [eventually_cold_survival_geometry (T := T) (d₀ := d₀) hη hslim] with n hn | |
| have hcomp : IsCompact (r n • Ω) := hΩ.image (continuous_const_smul (r n)) | |
| let _ : IsFiniteMeasure (JetPrototype.spaceVolume.restrict (r n • Ω)) := | |
| isFiniteMeasure_restrict.mpr hcomp.measure_lt_top.ne | |
| have hb := (F n).local_free_error hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max | |
| hT hTmax hq hsmall 0 (j n) (hj0 n) (hj n) hn.1 hn.2 (r n • Ω) (ht n) | |
| dsimp only at hb | |
| exact (integral_prod _ (ColdDilationMeasure.integrable_dilated_error (hr n) Ω hb.1)).symm | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| end | |
| end | |
| section | |
| /-! # Bounded testing of the actual cold/free error -/ | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped Topology ENNReal Pointwise | |
| open BoltzmannNonuniqueness.VelocityWeight BoltzmannNonuniqueness.WeightedTranslation | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| def HotLimitExtraction.coldLabelError (E : HotLimitExtraction S) (k : ℤ) (a : Bool) | |
| (n : ℕ) (t : ℝ) (p : JetPrototype.Phase) : ℝ := | |
| S.radius (E.indices n)*(H q p.2*(F.approximation (E.indices n)).cold (E.coldLabel k a n) | |
| (S.radius (E.indices n)*t,(S.radius (E.indices n) • p.1,p.2))- | |
| JetFreeTransport.free η K α γ (JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus) | |
| (d₀*(JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus)^10) | |
| (S.radius (E.indices n)*t) a | |
| (shift (displacement (E.coldLabel k a n).lattice) (S.radius (E.indices n) • p.1,p.2))) | |
| theorem HotLimitExtraction.coldLabelError_integrable (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) | |
| (hK : 0 ≤ K) (hα : 0 ≤ α) (hγ : 0 ≤ γ) (hd₀ : 0 < d₀) (hq : q < 2) | |
| (k : ℤ) (a : Bool) (n : ℕ) {t : ℝ} (ht : 0 < t) | |
| (htmax : S.radius (E.indices n)*t ≤ 1) | |
| (Ω : Set JetPrototype.Space) (hΩ : IsCompact Ω) : | |
| Integrable (E.coldLabelError k a n t) ((JetPrototype.spaceVolume.restrict Ω).prod volume) := by | |
| let r := S.radius (E.indices n) | |
| let i := E.coldLabel k a n | |
| let s := JetGeometry.jetScale s₀ η i.annulus | |
| let d := d₀*s^10 | |
| let μ := JetPrototype.spaceVolume.restrict (r • Ω) | |
| have hr : 0 < r := S.radius_pos hs₀ (E.indices n) | |
| have hs : 0 < s := DatumBounds.scale_pos hs₀ _ | |
| have hd : 0 < d := mul_pos hd₀ (pow_pos hs 10) | |
| let _ : IsFiniteMeasure μ := | |
| isFiniteMeasure_restrict.mpr (hΩ.image (continuous_const_smul r)).measure_lt_top.ne | |
| have hc := (F.approximation (E.indices n)).cold_physical_integrable hs₀ hsmax hη hηmax hK hd₀.le hq | |
| (shrinkingHorizon_pos F.horizonScale_pos _).le i (r*t) μ | |
| have hb := JetBarrierLocalMass.local_integrable hK hα hγ hs hd (mul_pos hr ht) htmax η a | |
| (displacement i.lattice) μ | |
| have hf : Integrable (fun p : JetPrototype.Phase => JetFreeTransport.free η K α γ s d (r*t) a | |
| (shift (displacement i.lattice) p)) (μ.prod volume) := by | |
| apply hb.mono' ((JetFreeTransport.measurable_free η K α γ s d (r*t) a).comp | |
| (measurable_shift _)).aestronglyMeasurable | |
| filter_upwards [] with p | |
| dsimp only [Function.comp_apply] | |
| rw [Real.norm_of_nonneg (JetFreeTransport.free_nonneg hK hs.le hd.le η α γ (r*t) a _)] | |
| exact JetFreeTransport.free_le_barrier hK hd hα hγ hs (mul_pos hr ht) | |
| (htmax.trans (by norm_num)) η a _ | |
| exact (ColdDilationMeasure.integrable_dilate hr Ω (hc.sub hf)).const_mul r | |
| theorem HotLimitExtraction.coldLabel_bounded_test_free_limit (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) | |
| (hK : 0 ≤ K) (hα : 0 ≤ α) (hαmax : α ≤ 1/4) (hγ : 0 ≤ γ) | |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) | |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) | |
| (hq : q < 2) (k : ℤ) (a : Bool) (hk : E.fraction < E.phase*Real.exp (η*(k:ℝ))) | |
| {t : ℝ} (ht : 0 < t) (htU : ENNReal.ofReal t < E.horizon) | |
| (Ω : Set JetPrototype.Space) (hΩ : IsCompact Ω) | |
| {C : ℝ} (hC : 0 ≤ C) (φ : JetPrototype.Phase → ℝ) (hφ : ∀ p, |φ p| ≤ C) : | |
| Tendsto (fun n => ∫ p, φ p*E.coldLabelError k a n t p | |
| ∂(JetPrototype.spaceVolume.restrict Ω).prod volume) atTop (𝓝 0) := by | |
| have hl := E.coldLabel_free_limit hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max hsmall hq | |
| k a hk ht htU Ω hΩ | |
| change Tendsto (fun n => ∫ p, |E.coldLabelError k a n t p| | |
| ∂(JetPrototype.spaceVolume.restrict Ω).prod volume) atTop (𝓝 0) at hl | |
| apply squeeze_zero_norm' _ (by simpa only [mul_zero] using hl.const_mul C) | |
| filter_upwards [S.eventually_scaled_slab hs₀ E.horizon_limit htU] with n hn | |
| have htime : S.radius (E.indices n)*t ≤ 1 := | |
| (hn t ⟨ht.le,le_rfl⟩).2.trans | |
| (((shrinkingHorizon_le F.horizonScale_pos _).trans F.horizonScale_le).trans (by norm_num)) | |
| have hi := (E.coldLabelError_integrable hs₀ hsmax hη hηmax hK hα hγ hd₀ hq k a n ht htime Ω hΩ).abs | |
| have hb := norm_integral_le_of_norm_le (hi.const_mul C) (ae_of_all _ (fun p => by | |
| rw [Real.norm_eq_abs,abs_mul] | |
| exact mul_le_mul (hφ p) le_rfl (abs_nonneg _) hC)) | |
| simpa only [integral_const_mul] using hb | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # Annular mask replacement along the actual mesh-label sequence -/ | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped Topology | |
| open BoltzmannNonuniqueness.VelocityWeight | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| theorem HotLimitExtraction.coldLabel_mask_limit (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hη : 0 < η) (k : ℤ) (a : Bool) (t : ℝ) | |
| (Ω : Set Transverse) (hΩ : volume Ω < ⊤) : | |
| let r := fun n => S.radius (E.indices n) | |
| let s := fun n => JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus | |
| let d := fun n => d₀*(s n)^10 | |
| let μ := E.phase*Real.exp (η*(k:ℝ)) | |
| Tendsto (fun n => ∫ p : Transverse × (Transverse × ℝ), | |
| |(JetGeometry.mask η (s n) a).indicator (fun _ => (1:ℝ)) | |
| (r n • (p.1-t • (d n • p.2.1)))- | |
| (JetGeometry.scaleShell η μ).indicator (fun _ => (1:ℝ)) p.1* | |
| (JetGeometry.stripe (s n) a).indicator (fun _ => (1:ℝ)) | |
| (r n • (p.1-t • (d n • p.2.1)))| * | |
| JetThermalKernel.J (SheetMeasures.join p.2) | |
| ∂(volume.restrict Ω).prod ((volume : Measure Transverse).prod volume)) atTop (𝓝 0) := by | |
| intro r s d μ | |
| have hr (n) : 0 < r n := S.radius_pos hs₀ (E.indices n) | |
| have hb := JetGeometry.spatial_mask_L1_tendsto hr | |
| ((S.radius_tendsto_zero hs₀).comp E.indices_strict.tendsto_atTop) | |
| (E.coldLabel_scale_limit hs₀ hη k a) (E.coldLabel_width_tendsto_zero hs₀ hη k a) | |
| η t a Ω hΩ | |
| change Tendsto (fun n => ∫ p : Transverse × (Transverse × ℝ), | |
| |(JetGeometry.mask η (r n*(s n/r n)) a).indicator (fun _ => (1:ℝ)) | |
| (r n • (p.1-t • (d n • p.2.1)))- | |
| (JetGeometry.scaleShell η μ).indicator (fun _ => (1:ℝ)) p.1* | |
| (JetGeometry.stripe (r n*(s n/r n)) a).indicator (fun _ => (1:ℝ)) | |
| (r n • (p.1-t • (d n • p.2.1)))| * | |
| JetThermalKernel.J (SheetMeasures.join p.2) | |
| ∂(volume.restrict Ω).prod ((volume : Measure Transverse).prod volume)) atTop (𝓝 0) at hb | |
| simpa only [mul_div_cancel₀ _ (hr _).ne'] using hb | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # Local L1 convergence of the cold/free velocity-average error -/ | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped Topology ENNReal | |
| open BoltzmannNonuniqueness.VelocityWeight | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| theorem HotLimitExtraction.coldLabel_average_error_limit (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) | |
| (hK : 0 ≤ K) (hα : 0 ≤ α) (hαmax : α ≤ 1/4) (hγ : 0 ≤ γ) | |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) | |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) | |
| (hq : q < 2) (k : ℤ) (a : Bool) (hk : E.fraction < E.phase*Real.exp (η*(k:ℝ))) | |
| {t : ℝ} (ht : 0 < t) (htU : ENNReal.ofReal t < E.horizon) | |
| (Ω : Set JetPrototype.Space) (hΩ : IsCompact Ω) | |
| {B : ℝ} {ψ : Velocity → ℝ} (hψB : ∀ v, |ψ v| ≤ B) : | |
| Tendsto (fun n => ∫ x, |∫ v, ψ v*E.coldLabelError k a n t (x,v)| | |
| ∂JetPrototype.spaceVolume.restrict Ω) atTop (𝓝 0) := by | |
| have hB : 0 ≤ B := (abs_nonneg (ψ 0)).trans (hψB 0) | |
| have hl := E.coldLabel_free_limit hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max hsmall hq | |
| k a hk ht htU Ω hΩ | |
| change Tendsto (fun n => ∫ p, |E.coldLabelError k a n t p| | |
| ∂(JetPrototype.spaceVolume.restrict Ω).prod volume) atTop (𝓝 0) at hl | |
| apply squeeze_zero' (Eventually.of_forall (fun _ => integral_nonneg (fun _ => abs_nonneg _))) | |
| _ (by simpa only [mul_zero] using hl.const_mul B) | |
| filter_upwards [S.eventually_scaled_slab hs₀ E.horizon_limit htU] with n hn | |
| have htime : S.radius (E.indices n)*t ≤ 1 := | |
| (hn t ⟨ht.le,le_rfl⟩).2.trans | |
| (((shrinkingHorizon_le F.horizonScale_pos _).trans F.horizonScale_le).trans (by norm_num)) | |
| have hi := E.coldLabelError_integrable hs₀ hsmax hη hηmax hK hα hγ hd₀ hq k a n ht htime Ω hΩ | |
| rw [← integral_const_mul,integral_prod _ (hi.abs.const_mul B)] | |
| apply integral_mono_of_nonneg (ae_of_all _ (fun _ => abs_nonneg _)) | |
| (hi.abs.const_mul B).integral_prod_left | |
| filter_upwards [hi.prod_right_ae] with x hx | |
| rw [← Real.norm_eq_abs] | |
| apply norm_integral_le_of_norm_le (hx.abs.const_mul B) | |
| filter_upwards [] with v | |
| rw [Real.norm_eq_abs,abs_mul] | |
| exact mul_le_mul_of_nonneg_right (hψB v) (abs_nonneg _) | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # The velocity averages of the actual retained cold colors -/ | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped Topology ENNReal Pointwise | |
| open BoltzmannNonuniqueness.VelocityWeight | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| def HotLimitExtraction.coldLabelDensity (E : HotLimitExtraction S) (k : ℤ) (a : Bool) | |
| (n : ℕ) (t : ℝ) (p : JetPrototype.Phase) : ℝ := | |
| S.radius (E.indices n)*(H q p.2*(F.approximation (E.indices n)).cold (E.coldLabel k a n) | |
| (S.radius (E.indices n)*t,(S.radius (E.indices n) • p.1,p.2))) | |
| def HotLimitExtraction.coldLabelAverage (E : HotLimitExtraction S) (k : ℤ) (a : Bool) | |
| (n : ℕ) (t : ℝ) (ψ : Velocity → ℝ) (x : JetPrototype.Space) : ℝ := | |
| ∫ v, ψ v*E.coldLabelDensity k a n t (x,v) | |
| theorem HotLimitExtraction.coldLabelDensity_integrable (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) | |
| (hK : 0 ≤ K) (hd₀ : 0 ≤ d₀) (hq : q < 2) | |
| (k : ℤ) (a : Bool) (n : ℕ) (t : ℝ) (Ω : Set JetPrototype.Space) (hΩ : IsCompact Ω) : | |
| Integrable (E.coldLabelDensity k a n t) ((JetPrototype.spaceVolume.restrict Ω).prod volume) := by | |
| let r := S.radius (E.indices n) | |
| let μ := JetPrototype.spaceVolume.restrict (r • Ω) | |
| have hr : 0 < r := S.radius_pos hs₀ (E.indices n) | |
| let _ : IsFiniteMeasure μ := | |
| isFiniteMeasure_restrict.mpr (hΩ.image (continuous_const_smul r)).measure_lt_top.ne | |
| have hi := (F.approximation (E.indices n)).cold_physical_integrable hs₀ hsmax hη hηmax | |
| hK hd₀ hq (shrinkingHorizon_pos F.horizonScale_pos _).le (E.coldLabel k a n) (r*t) μ | |
| exact (ColdDilationMeasure.integrable_dilate hr Ω hi).const_mul r | |
| theorem HotLimitExtraction.coldLabelError_eq (E : HotLimitExtraction S) | |
| (k : ℤ) (a : Bool) (n : ℕ) (t : ℝ) (p : JetPrototype.Phase) : | |
| E.coldLabelError k a n t p = E.coldLabelDensity k a n t p- | |
| S.radius (E.indices n)*JetFreeTransport.free η K α γ | |
| (JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus) | |
| (d₀*(JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus)^10) | |
| (S.radius (E.indices n)*t) a (S.radius (E.indices n) • p.1,p.2) := by | |
| have hz : displacement (E.coldLabel k a n).lattice = 0 := by | |
| change (JetLattice.transverseShift 0,JetLattice.axialShift 0) = 0 | |
| ext i <;> simp [JetLattice.transverseShift,JetLattice.axialShift] | |
| unfold coldLabelError coldLabelDensity | |
| rw [hz] | |
| simp only [WeightedTranslation.shift,sub_zero] | |
| change _ = _ | |
| ring | |
| theorem HotLimitExtraction.coldLabelAverage_sub_free (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) | |
| (hK : 0 ≤ K) (hα : 0 ≤ α) (hγ : 0 ≤ γ) (hd₀ : 0 < d₀) (hq : q < 2) | |
| (k : ℤ) (a : Bool) (n : ℕ) {t : ℝ} (ht : 0 < t) | |
| (htmax : S.radius (E.indices n)*t ≤ 1) (Ω : Set JetPrototype.Space) (hΩ : IsCompact Ω) | |
| {B : ℝ} {ψ : Velocity → ℝ} (hψ : Measurable ψ) (hψB : ∀ v, |ψ v| ≤ B) : | |
| ∀ᵐ x ∂JetPrototype.spaceVolume.restrict Ω, | |
| E.coldLabelAverage k a n t ψ x-E.coldLabelFreeAverage k a n t ψ x = | |
| ∫ v, ψ v*E.coldLabelError k a n t (x,v) := by | |
| have hm := hψ.comp (measurable_snd : Measurable (Prod.snd : JetPrototype.Phase → Velocity)) | |
| have hi := (E.coldLabelDensity_integrable hs₀ hsmax hη hηmax hK hd₀.le hq k a n t Ω hΩ).bdd_mul | |
| hm.aestronglyMeasurable (ae_of_all _ (fun p => hψB p.2)) | |
| have he := (E.coldLabelError_integrable hs₀ hsmax hη hηmax hK hα hγ hd₀ hq k a n ht htmax Ω hΩ).bdd_mul | |
| hm.aestronglyMeasurable (ae_of_all _ (fun p => hψB p.2)) | |
| filter_upwards [hi.prod_right_ae,he.prod_right_ae] with x hix hex | |
| dsimp only [Function.comp_apply] at hix hex | |
| have hd : Integrable (fun v => S.radius (E.indices n)*JetFreeTransport.free η K α γ | |
| (JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus) | |
| (d₀*(JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus)^10) | |
| (S.radius (E.indices n)*t) a (S.radius (E.indices n) • x,v)*ψ v) := by | |
| apply (hix.sub hex).congr | |
| filter_upwards [] with v | |
| dsimp only [Pi.sub_apply] | |
| rw [E.coldLabelError_eq] | |
| ring | |
| have hident : (fun v => ψ v*E.coldLabelError k a n t (x,v)) = | |
| (fun v => ψ v*E.coldLabelDensity k a n t (x,v)- | |
| S.radius (E.indices n)*JetFreeTransport.free η K α γ | |
| (JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus) | |
| (d₀*(JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus)^10) | |
| (S.radius (E.indices n)*t) a (S.radius (E.indices n) • x,v)*ψ v) := by | |
| funext v | |
| rw [E.coldLabelError_eq] | |
| ring | |
| rw [hident,integral_sub hix hd] | |
| rfl | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # Integrability of the actual, free and striped cold averages -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open BoltzmannNonuniqueness.VelocityWeight | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| theorem HotLimitExtraction.coldLabelStripeAverage_measurable (E : HotLimitExtraction S) | |
| (k : ℤ) (a : Bool) (n : ℕ) (t : ℝ) : Measurable (E.coldLabelStripeAverage k a n t) := by | |
| let r := S.radius (E.indices n) | |
| let s := JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus | |
| have hm : Measurable (fun p : Transverse × (Transverse × ℝ) => | |
| (JetGeometry.stripe s a).indicator (fun _ => (1:ℝ)) | |
| (r • (p.1-t • ((d₀*s^10) • p.2.1)))) := | |
| (measurable_const.indicator (JetMaskMeasure.measurableSet_stripe s a)).comp (by fun_prop) | |
| exact (hm.mul ((JetThermalKernel.J_smooth.continuous.measurable.comp | |
| SheetMeasures.join.measurable).comp measurable_snd)).stronglyMeasurable.integral_prod_right'.measurable | |
| theorem HotLimitExtraction.coldLabelStripeAverage_bound (E : HotLimitExtraction S) | |
| (k : ℤ) (a : Bool) (n : ℕ) (t : ℝ) (y : Transverse) : | |
| |E.coldLabelStripeAverage k a n t y| ≤ 1 := by | |
| apply JetCoreDensity.masked_thermal_bound | |
| intro w | |
| by_cases h : S.radius (E.indices n) • | |
| (y-t • ((d₀*(JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus)^10) • w.1)) ∈ | |
| JetGeometry.stripe (JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus) a | |
| · simp only [indicator_of_mem h,abs_one,le_refl] | |
| · simp only [indicator_of_notMem h,abs_zero,zero_le_one] | |
| theorem HotLimitExtraction.coldLabelStripedProfile_measurable (E : HotLimitExtraction S) | |
| (hα : 0 ≤ α) (hγ : 0 ≤ γ) (k : ℤ) (a : Bool) (n : ℕ) {t : ℝ} (ht : 0 ≤ t) | |
| {ψ : Velocity → ℝ} (hψ : Continuous ψ) : | |
| Measurable (E.coldLabelStripedProfile k a n t ψ) := by | |
| have hμ : 0 < E.phase*Real.exp (η*(k:ℝ)) := | |
| mul_pos (zero_lt_one.trans_le E.phase_mem.1) (Real.exp_pos _) | |
| exact (JetCoreDensity.limitingCoefficient_measurable hα hγ hμ ht K (JetPrototype.sign a) hψ).mul | |
| (((measurable_const.indicator (JetGeometry.measurableSet_scaleShell η | |
| (E.phase*Real.exp (η*(k:ℝ))))).comp measurable_fst).mul | |
| ((E.coldLabelStripeAverage_measurable k a n t).comp measurable_fst)) | |
| theorem HotLimitExtraction.coldLabelStripedProfile_bound (E : HotLimitExtraction S) | |
| (hK : 0 ≤ K) (hα : 0 < α) (hγ : 0 < γ) (k : ℤ) (a : Bool) (n : ℕ) {t : ℝ} (ht : 0 < t) | |
| {B : ℝ} {ψ : Velocity → ℝ} (hψB : ∀ v, |ψ v| ≤ B) (x : JetPrototype.Space) : | |
| |E.coldLabelStripedProfile k a n t ψ x| ≤ ((K*max 1 (α*γ)⁻¹)/t)*B := by | |
| have hμ : 0 < E.phase*Real.exp (η*(k:ℝ)) := | |
| mul_pos (zero_lt_one.trans_le E.phase_mem.1) (Real.exp_pos _) | |
| have hc := JetCoreDensity.limitingCoefficient_bound hK hα hγ hμ ht hψB (JetPrototype.sign a) x | |
| have hs := E.coldLabelStripeAverage_bound k a n t x.1 | |
| dsimp only [coldLabelStripedProfile] | |
| by_cases hx : x.1 ∈ JetGeometry.scaleShell η (E.phase*Real.exp (η*(k:ℝ))) | |
| · rw [indicator_of_mem hx,one_mul,abs_mul] | |
| exact (mul_le_of_le_one_right (abs_nonneg _) hs).trans hc | |
| · rw [indicator_of_notMem hx,zero_mul,mul_zero,abs_zero] | |
| exact (abs_nonneg _).trans hc | |
| theorem HotLimitExtraction.coldLabelStripedProfile_integrable (E : HotLimitExtraction S) | |
| (hK : 0 ≤ K) (hα : 0 < α) (hγ : 0 < γ) (k : ℤ) (a : Bool) (n : ℕ) {t : ℝ} (ht : 0 < t) | |
| {B : ℝ} {ψ : Velocity → ℝ} (hψ : Continuous ψ) (hψB : ∀ v, |ψ v| ≤ B) | |
| (ρ : Measure JetPrototype.Space) [IsFiniteMeasure ρ] : | |
| Integrable (E.coldLabelStripedProfile k a n t ψ) ρ := | |
| Integrable.of_bound (E.coldLabelStripedProfile_measurable hα.le hγ.le k a n ht.le hψ).aestronglyMeasurable | |
| _ (ae_of_all _ (fun x => E.coldLabelStripedProfile_bound hK hα hγ k a n ht hψB x)) | |
| theorem HotLimitExtraction.coldLabelFreeAverage_integrable (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hK : 0 ≤ K) (hα : 0 < α) (hγ : 0 < γ) | |
| (hd₀ : 0 < d₀) (k : ℤ) (a : Bool) (n : ℕ) {t : ℝ} (ht : 0 < t) | |
| {B : ℝ} {ψ : Velocity → ℝ} (hψ : Continuous ψ) (hψB : ∀ v, |ψ v| ≤ B) | |
| (ρ : Measure JetPrototype.Space) [IsFiniteMeasure ρ] : | |
| Integrable (E.coldLabelFreeAverage k a n t ψ) ρ := by | |
| have hs : 0 < JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus := DatumBounds.scale_pos hs₀ _ | |
| apply Integrable.of_bound | |
| (JetCoreDensity.free_average_measurable _ _ _ _ _ _ _ _ _ hψ.measurable).aestronglyMeasurable | |
| (((K*max 1 (α*γ)⁻¹)/t)*B) | |
| exact ae_of_all _ (fun x => JetCoreDensity.dilated_free_average_bound (S.radius_pos hs₀ _) hK hα hγ | |
| hs (mul_pos hd₀ (pow_pos hs 10)) ht η a x hψ hψB) | |
| theorem HotLimitExtraction.coldLabelAverage_integrable (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) | |
| (hK : 0 ≤ K) (hd₀ : 0 ≤ d₀) (hq : q < 2) | |
| (k : ℤ) (a : Bool) (n : ℕ) (t : ℝ) (Ω : Set JetPrototype.Space) (hΩ : IsCompact Ω) | |
| {B : ℝ} {ψ : Velocity → ℝ} (hψ : Measurable ψ) (hψB : ∀ v, |ψ v| ≤ B) : | |
| Integrable (E.coldLabelAverage k a n t ψ) (JetPrototype.spaceVolume.restrict Ω) := by | |
| have hi := (E.coldLabelDensity_integrable hs₀ hsmax hη hηmax hK hd₀ hq k a n t Ω hΩ).bdd_mul | |
| (hψ.comp measurable_snd).aestronglyMeasurable (ae_of_all _ (fun p => hψB p.2)) | |
| exact hi.integral_prod_left | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # The actual cold-label stripes average to one quarter -/ | |
| noncomputable section | |
| open MeasureTheory Filter | |
| open scoped Topology | |
| open BoltzmannNonuniqueness.VelocityWeight | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| theorem HotLimitExtraction.coldLabelStripe_centered_eq (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (k : ℤ) (a : Bool) (n : ℕ) (t : ℝ) (y : Transverse) : | |
| E.coldLabelStripeAverage k a n t y-1/4 = | |
| JetGeometry.thermalStripeCentered | |
| (S.radius (E.indices n)* | |
| (JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus/S.radius (E.indices n))^2) | |
| (d₀*(JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus)^10) t a y := | |
| (JetGeometry.thermalStripeCentered_eq (S.radius_pos hs₀ _) _ _ _ _ _).symm | |
| theorem HotLimitExtraction.coldLabelStripe_centered_weakStar (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hη : 0 < η) (k : ℤ) (a : Bool) (t : ℝ) : | |
| Compactness.WeakStarLInfConverges (volume : Measure Transverse) | |
| (fun n y => E.coldLabelStripeAverage k a n t y-1/4) (fun _ => 0) := by | |
| let r := fun n => S.radius (E.indices n) | |
| let s := fun n => JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus | |
| have hr (n) : 0 < r n := S.radius_pos hs₀ _ | |
| have hs (n) : 0 < s n := DatumBounds.scale_pos hs₀ _ | |
| have hp (n) : 0 < r n*(s n/r n)^2 := mul_pos (hr n) (pow_pos (div_pos (hs n) (hr n)) 2) | |
| have hplim := JetGeometry.stripe_period_tendsto_zero | |
| ((S.radius_tendsto_zero hs₀).comp E.indices_strict.tendsto_atTop) | |
| (E.coldLabel_scale_limit hs₀ hη k a) | |
| have h := JetGeometry.thermalStripeCentered_weakStar hp hplim | |
| (fun n => d₀*(s n)^10) t a | |
| have heq : (fun n y => E.coldLabelStripeAverage k a n t y-1/4) = | |
| (fun n => JetGeometry.thermalStripeCentered (r n*(s n/r n)^2) (d₀*(s n)^10) t a) := by | |
| funext n y | |
| exact E.coldLabelStripe_centered_eq hs₀ k a n t y | |
| rw [heq] | |
| exact h | |
| theorem HotLimitExtraction.coldLabelStripe_weakStar (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hη : 0 < η) (k : ℤ) (a : Bool) (t : ℝ) : | |
| Compactness.WeakStarLInfConverges (volume : Measure Transverse) | |
| (fun n => E.coldLabelStripeAverage k a n t) (fun _ => 1/4) := by | |
| refine ⟨measurable_const,?_⟩ | |
| intro ψ hψ | |
| have hi (n) : Integrable (fun y => ψ y*E.coldLabelStripeAverage k a n t y) := | |
| (hψ.bdd_mul (E.coldLabelStripeAverage_measurable k a n t).aestronglyMeasurable | |
| (ae_of_all _ (E.coldLabelStripeAverage_bound k a n t))).congr | |
| (ae_of_all _ (fun y => mul_comm _ _)) | |
| have heq (n) : (∫ y, ψ y*(E.coldLabelStripeAverage k a n t y-1/4)) = | |
| (∫ y, ψ y*E.coldLabelStripeAverage k a n t y)-(∫ y, ψ y*(1/4)) := by | |
| simp_rw [mul_sub] | |
| exact integral_sub (hi n) (hψ.mul_const (1/4)) | |
| have h := (E.coldLabelStripe_centered_weakStar hs₀ hη k a t).2 ψ hψ | |
| simp only [mul_zero,integral_zero,heq] at h | |
| simpa only [zero_add,sub_add_cancel] using h.add_const (∫ y, ψ y*(1/4)) | |
| theorem HotLimitExtraction.coldLabelStripe_space_centered_weakStar (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hη : 0 < η) (k : ℤ) (a : Bool) (t : ℝ) : | |
| Compactness.WeakStarLInfConverges JetPrototype.spaceVolume | |
| (fun n x => E.coldLabelStripeAverage k a n t x.1-1/4) (fun _ => 0) := by | |
| apply Compactness.weakStar_zero_of_fibers | |
| · intro n | |
| exact ((E.coldLabelStripeAverage_measurable k a n t).comp measurable_fst).sub_const (1/4) | |
| · intro n x | |
| rw [E.coldLabelStripe_centered_eq hs₀] | |
| exact JetGeometry.thermalStripeCentered_bound _ _ _ _ _ | |
| · intro _ | |
| exact E.coldLabelStripe_centered_weakStar hs₀ hη k a t | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # Every actual cold-label velocity fiber is integrable -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open BoltzmannNonuniqueness.VelocityWeight | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| theorem HotLimitExtraction.coldLabelDensity_measurable (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) | |
| (hK : 0 ≤ K) (hd₀ : 0 ≤ d₀) (hq : q < 2) (k : ℤ) (a : Bool) (n : ℕ) (t : ℝ) : | |
| Measurable (E.coldLabelDensity k a n t) := by | |
| have hc := (F.approximation (E.indices n)).cold_properties hs₀ hsmax hη hηmax hK hd₀ hq | |
| (shrinkingHorizon_pos F.horizonScale_pos _).le | |
| have hp : Measurable (fun p : JetPrototype.Phase => | |
| (S.radius (E.indices n)*t,(S.radius (E.indices n) • p.1,p.2))) := by fun_prop | |
| exact (((ChartKernel.measurable_H q).comp measurable_snd).mul ((hc.1 _).comp hp)).const_mul _ | |
| theorem HotLimitExtraction.coldLabelDensity_bounds (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) | |
| (hK : 0 ≤ K) (hd₀ : 0 ≤ d₀) (hq : q < 2) (k : ℤ) (a : Bool) (n : ℕ) (t : ℝ) | |
| (p : JetPrototype.Phase) : | |
| 0 ≤ E.coldLabelDensity k a n t p ∧ E.coldLabelDensity k a n t p ≤ | |
| (S.radius (E.indices n)*(2*(F.approximation (E.indices n)).amplitude))*H q p.2 := by | |
| have hc := (F.approximation (E.indices n)).cold_properties hs₀ hsmax hη hηmax hK hd₀ hq | |
| (shrinkingHorizon_pos F.horizonScale_pos _).le | |
| have hb := (hc.2.2.1 {E.coldLabel k a n} | |
| (S.radius (E.indices n)*t,(S.radius (E.indices n) • p.1,p.2))).trans | |
| ((F.approximation (E.indices n)).solution.value_bounds _).2 | |
| simp only [Finset.sum_singleton] at hb | |
| have hrH := mul_nonneg (S.radius_pos hs₀ (E.indices n)).le (H_nonneg q p.2) | |
| refine ⟨mul_nonneg (S.radius_pos hs₀ _).le (mul_nonneg (H_nonneg q p.2) (hc.2.1 _ _)),?_⟩ | |
| calc | |
| _ = S.radius (E.indices n)*H q p.2* | |
| (F.approximation (E.indices n)).cold (E.coldLabel k a n) | |
| (S.radius (E.indices n)*t,(S.radius (E.indices n) • p.1,p.2)) := by | |
| dsimp [coldLabelDensity] | |
| ring | |
| _ ≤ S.radius (E.indices n)*H q p.2*(2*(F.approximation (E.indices n)).amplitude) := | |
| mul_le_mul_of_nonneg_left hb hrH | |
| _ = _ := by ring | |
| theorem HotLimitExtraction.coldLabelDensity_fiber_integrable (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) | |
| (hK : 0 ≤ K) (hd₀ : 0 ≤ d₀) (hq : q < 2) (k : ℤ) (a : Bool) (n : ℕ) (t : ℝ) | |
| (x : JetPrototype.Space) : Integrable (fun v => E.coldLabelDensity k a n t (x,v)) := by | |
| have hm : Measurable (fun v => E.coldLabelDensity k a n t (x,v)) := | |
| (E.coldLabelDensity_measurable hs₀ hsmax hη hηmax hK hd₀ hq k a n t).comp | |
| (measurable_const.prodMk measurable_id) | |
| apply ((integrable_H hq).const_mul | |
| (S.radius (E.indices n)*(2*(F.approximation (E.indices n)).amplitude))).mono' hm.aestronglyMeasurable | |
| filter_upwards [] with v | |
| have hb := E.coldLabelDensity_bounds hs₀ hsmax hη hηmax hK hd₀ hq k a n t (x,v) | |
| simpa only [Real.norm_of_nonneg hb.1] using hb.2 | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # The limiting average of an individual cold label -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| def HotLimitExtraction.coldLabelLimitProfile (E : HotLimitExtraction S) (k : ℤ) (a : Bool) | |
| (t : ℝ) (ψ : Velocity → ℝ) (x : JetPrototype.Space) : ℝ := | |
| let μ := E.phase*Real.exp (η*(k:ℝ)) | |
| JetCoreDensity.limitingCoefficient K α γ μ t (JetPrototype.sign a) ψ x* | |
| ((JetGeometry.scaleShell η μ).indicator (fun _ => (1:ℝ)) x.1*(1/4)) | |
| theorem HotLimitExtraction.coldLabelLimitProfile_measurable (E : HotLimitExtraction S) | |
| (hα : 0 ≤ α) (hγ : 0 ≤ γ) (k : ℤ) (a : Bool) {t : ℝ} (ht : 0 ≤ t) | |
| {ψ : Velocity → ℝ} (hψ : Continuous ψ) : | |
| Measurable (E.coldLabelLimitProfile k a t ψ) := by | |
| have hμ : 0 < E.phase*Real.exp (η*(k:ℝ)) := | |
| mul_pos (zero_lt_one.trans_le E.phase_mem.1) (Real.exp_pos _) | |
| exact (JetCoreDensity.limitingCoefficient_measurable hα hγ hμ ht K (JetPrototype.sign a) hψ).mul | |
| (((measurable_const.indicator (JetGeometry.measurableSet_scaleShell η | |
| (E.phase*Real.exp (η*(k:ℝ))))).comp measurable_fst).mul_const (1/4)) | |
| theorem HotLimitExtraction.coldLabelLimitProfile_bound (E : HotLimitExtraction S) | |
| (hK : 0 ≤ K) (hα : 0 < α) (hγ : 0 < γ) (k : ℤ) (a : Bool) {t : ℝ} (ht : 0 < t) | |
| {B : ℝ} {ψ : Velocity → ℝ} (hψB : ∀ v, |ψ v| ≤ B) (x : JetPrototype.Space) : | |
| |E.coldLabelLimitProfile k a t ψ x| ≤ ((K*max 1 (α*γ)⁻¹)/t)*B := by | |
| have hμ : 0 < E.phase*Real.exp (η*(k:ℝ)) := | |
| mul_pos (zero_lt_one.trans_le E.phase_mem.1) (Real.exp_pos _) | |
| have hc := JetCoreDensity.limitingCoefficient_bound hK hα hγ hμ ht hψB (JetPrototype.sign a) x | |
| have hm : |(JetGeometry.scaleShell η (E.phase*Real.exp (η*(k:ℝ)))).indicator | |
| (fun _ => (1:ℝ)) x.1*(1/4)| ≤ 1 := by | |
| classical | |
| by_cases hx : x.1 ∈ JetGeometry.scaleShell η (E.phase*Real.exp (η*(k:ℝ))) <;> norm_num [hx] | |
| unfold coldLabelLimitProfile | |
| rw [abs_mul] | |
| exact (mul_le_of_le_one_right (abs_nonneg _) hm).trans hc | |
| theorem HotLimitExtraction.coldLabelLimitProfile_integrable (E : HotLimitExtraction S) | |
| (hK : 0 ≤ K) (hα : 0 < α) (hγ : 0 < γ) (k : ℤ) (a : Bool) {t : ℝ} (ht : 0 < t) | |
| {B : ℝ} {ψ : Velocity → ℝ} (hψ : Continuous ψ) (hψB : ∀ v, |ψ v| ≤ B) | |
| (ρ : Measure JetPrototype.Space) [IsFiniteMeasure ρ] : | |
| Integrable (E.coldLabelLimitProfile k a t ψ) ρ := | |
| Integrable.of_bound (E.coldLabelLimitProfile_measurable hα.le hγ.le k a ht.le hψ).aestronglyMeasurable | |
| _ (ae_of_all _ (fun x => E.coldLabelLimitProfile_bound hK hα hγ k a ht hψB x)) | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # Removing the stripes from an individual cold-label profile -/ | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped Topology ENNReal | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| theorem HotLimitExtraction.coldLabel_striped_weak_limit (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hη : 0 < η) (hK : 0 ≤ K) (hα : 0 < α) (hγ : 0 < γ) | |
| (k : ℤ) (a : Bool) {t : ℝ} (ht : 0 < t) | |
| (Ω : Set JetPrototype.Space) (hΩ : MeasurableSet Ω) (hΩfin : JetPrototype.spaceVolume Ω < ⊤) | |
| {B : ℝ} {ψ : Velocity → ℝ} (hψ : Continuous ψ) (hψB : ∀ v, |ψ v| ≤ B) : | |
| Published.WeakL1Converges (JetPrototype.spaceVolume.restrict Ω) | |
| (fun n => E.coldLabelStripedProfile k a n t ψ) (E.coldLabelLimitProfile k a t ψ) := by | |
| let ρ := JetPrototype.spaceVolume.restrict Ω | |
| let _ : IsFiniteMeasure ρ := isFiniteMeasure_restrict.mpr hΩfin.ne | |
| let μ := E.phase*Real.exp (η*(k:ℝ)) | |
| let c := JetCoreDensity.limitingCoefficient K α γ μ t (JetPrototype.sign a) ψ | |
| let m : JetPrototype.Space → ℝ := fun x => | |
| (JetGeometry.scaleShell η μ).indicator (fun _ => (1:ℝ)) x.1 | |
| have hμ : 0 < μ := mul_pos (zero_lt_one.trans_le E.phase_mem.1) (Real.exp_pos _) | |
| have hcm : Measurable c := JetCoreDensity.limitingCoefficient_measurable | |
| hα.le hγ.le hμ ht.le K (JetPrototype.sign a) hψ | |
| have hci : Integrable c ρ := Integrable.of_bound hcm.aestronglyMeasurable _ | |
| (ae_of_all _ (fun x => JetCoreDensity.limitingCoefficient_bound hK hα hγ hμ ht hψB _ x)) | |
| have hmm : Measurable m := | |
| (measurable_const.indicator (JetGeometry.measurableSet_scaleShell η μ)).comp measurable_fst | |
| have hmb (x) : |m x| ≤ 1 := by | |
| classical | |
| by_cases hx : x.1 ∈ JetGeometry.scaleShell η μ <;> simp [m,hx] | |
| have hli := E.coldLabelLimitProfile_integrable hK hα hγ k a ht hψ hψB ρ | |
| refine ⟨E.coldLabelLimitProfile_measurable hα.le hγ.le k a ht.le hψ,hli,?_⟩ | |
| intro φ hφ hφB | |
| obtain ⟨D,hD⟩ := hφB | |
| let χ : JetPrototype.Space → ℝ := fun x => φ x*(m x*c x) | |
| have hχi : Integrable χ ρ := | |
| (hci.bdd_mul hmm.aestronglyMeasurable (ae_of_all _ hmb)).bdd_mul | |
| hφ.aestronglyMeasurable (ae_of_all _ hD) | |
| have hzero := ((E.coldLabelStripe_space_centered_weakStar hs₀ hη k a t).restrict hΩ).2 χ hχi | |
| have hi (n) := (E.coldLabelStripedProfile_integrable hK hα hγ k a n ht hψ hψB ρ).bdd_mul | |
| hφ.aestronglyMeasurable (ae_of_all _ hD) | |
| have hl := hli.bdd_mul hφ.aestronglyMeasurable (ae_of_all _ hD) | |
| have heq (n) : (∫ x, χ x*(E.coldLabelStripeAverage k a n t x.1-1/4) ∂ρ) = | |
| (∫ x, φ x*E.coldLabelStripedProfile k a n t ψ x ∂ρ)- | |
| (∫ x, φ x*E.coldLabelLimitProfile k a t ψ x ∂ρ) := by | |
| rw [← integral_sub (hi n) hl] | |
| apply integral_congr_ae | |
| filter_upwards [] with x | |
| dsimp [χ,m,c,μ,coldLabelStripedProfile,coldLabelLimitProfile] | |
| ring | |
| simp only [mul_zero,integral_zero] at hzero | |
| change Tendsto (fun n => ∫ x, χ x*(E.coldLabelStripeAverage k a n t x.1-1/4) ∂ρ) | |
| atTop (𝓝 0) at hzero | |
| simp_rw [heq] at hzero | |
| simpa only [zero_add,sub_add_cancel] using | |
| hzero.add_const (∫ x, φ x*E.coldLabelLimitProfile k a t ψ x ∂ρ) | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # Joint measurability and positive-time bounds of the atomic label limits -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| theorem HotLimitExtraction.coldLabelLimitProfile_clamped_measurable (E : HotLimitExtraction S) | |
| (hK : 0 ≤ K) (hα : 0 ≤ α) (hγ : 0 ≤ γ) (k : ℤ) (a : Bool) | |
| {ψ : Velocity → ℝ} (hψ : Measurable ψ) : | |
| Measurable (fun z : ℝ × JetPrototype.Space => E.coldLabelLimitProfile k a (max 0 z.1) ψ z.2) := by | |
| let μ := E.phase*Real.exp (η*(k:ℝ)) | |
| have hμ : 0 < μ := mul_pos (zero_lt_one.trans_le E.phase_mem.1) (Real.exp_pos _) | |
| have hmA := (AxialBackground.clamped_atom_test_measurable hK hα hγ hμ (JetPrototype.sign a) hψ).comp | |
| (measurable_fst.prodMk measurable_snd.snd : | |
| Measurable (fun z : ℝ × JetPrototype.Space => (z.1,z.2.2))) | |
| have hmS : Measurable (fun z : ℝ × JetPrototype.Space => | |
| (JetGeometry.scaleShell η μ).indicator (fun _ => (1:ℝ)) z.2.1) := | |
| (measurable_const.indicator (JetGeometry.measurableSet_scaleShell η μ)).comp measurable_snd.fst | |
| have heq : (fun z : ℝ × JetPrototype.Space => E.coldLabelLimitProfile k a (max 0 z.1) ψ z.2) = | |
| (fun z => (JetGeometry.scaleShell η μ).indicator (fun _ => (1:ℝ)) z.2.1* | |
| (∫ v, ψ v ∂AxialBackground.atom K α γ μ (max 0 z.1) (JetPrototype.sign a) z.2.2)) := by | |
| funext z | |
| rw [AxialBackground.integral_atom hK hα hγ hμ (le_max_left _ _)] | |
| unfold coldLabelLimitProfile AxialBackground.weight JetCoreDensity.limitingCoefficient | |
| dsimp only [μ] | |
| ring | |
| rw [heq] | |
| exact hmS.mul hmA | |
| theorem HotLimitExtraction.coldLabelLimitProfile_slab_bound (E : HotLimitExtraction S) | |
| (hK : 0 ≤ K) (hα : 0 < α) (hγ : 0 < γ) (k : ℤ) (σ : Bool) | |
| {a t B : ℝ} (ha : 0 < a) (ht : a ≤ t) {ψ : Velocity → ℝ} (hψB : ∀ v, |ψ v| ≤ B) | |
| (x : JetPrototype.Space) : | |
| |E.coldLabelLimitProfile k σ t ψ x| ≤ ((K*max 1 (α*γ)⁻¹)/a)*B := by | |
| have hb := E.coldLabelLimitProfile_bound hK hα hγ k σ (ha.trans_le ht) hψB x | |
| have hB : 0 ≤ B := (abs_nonneg (ψ 0)).trans (hψB 0) | |
| exact hb.trans (mul_le_mul_of_nonneg_right | |
| (div_le_div_of_nonneg_left (mul_nonneg hK (le_max_of_le_left zero_le_one)) ha ht) hB) | |
| theorem HotLimitExtraction.coldLabelLimitProfile_clamped_integrable (E : HotLimitExtraction S) | |
| (hK : 0 ≤ K) (hα : 0 < α) (hγ : 0 < γ) (k : ℤ) (σ : Bool) | |
| {a A B : ℝ} (ha : 0 < a) {ψ : Velocity → ℝ} (hψ : Measurable ψ) (hψB : ∀ v, |ψ v| ≤ B) | |
| (ρ : Measure JetPrototype.Space) [IsFiniteMeasure ρ] : | |
| Integrable (fun z => E.coldLabelLimitProfile k σ (max 0 z.1) ψ z.2) | |
| ((volume.restrict (Icc a A)).prod ρ) := by | |
| apply Integrable.of_bound | |
| (E.coldLabelLimitProfile_clamped_measurable hK hα.le hγ.le k σ hψ).aestronglyMeasurable | |
| (((K*max 1 (α*γ)⁻¹)/a)*B) | |
| filter_upwards [Measure.quasiMeasurePreserving_fst.ae (ae_restrict_mem measurableSet_Icc)] with z hz | |
| rw [Real.norm_eq_abs,max_eq_right (ha.le.trans hz.1)] | |
| exact E.coldLabelLimitProfile_slab_bound hK hα hγ k σ ha hz.1 hψB z.2 | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # L1 comparison of the actual and free cold velocity averages -/ | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped Topology ENNReal | |
| open BoltzmannNonuniqueness.VelocityWeight | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| theorem HotLimitExtraction.coldLabel_average_free_L1_limit (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) | |
| (hK : 0 ≤ K) (hα : 0 ≤ α) (hαmax : α ≤ 1/4) (hγ : 0 ≤ γ) | |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) | |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) | |
| (hq : q < 2) (k : ℤ) (a : Bool) (hk : E.fraction < E.phase*Real.exp (η*(k:ℝ))) | |
| {t : ℝ} (ht : 0 < t) (htU : ENNReal.ofReal t < E.horizon) | |
| (Ω : Set JetPrototype.Space) (hΩ : IsCompact Ω) | |
| {B : ℝ} {ψ : Velocity → ℝ} (hψ : Measurable ψ) (hψB : ∀ v, |ψ v| ≤ B) : | |
| Tendsto (fun n => ∫ x, |E.coldLabelAverage k a n t ψ x-E.coldLabelFreeAverage k a n t ψ x| | |
| ∂JetPrototype.spaceVolume.restrict Ω) atTop (𝓝 0) := by | |
| have hl := E.coldLabel_average_error_limit hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max | |
| hsmall hq k a hk ht htU Ω hΩ hψB | |
| apply hl.congr' | |
| filter_upwards [S.eventually_scaled_slab hs₀ E.horizon_limit htU] with n hn | |
| have htime : S.radius (E.indices n)*t ≤ 1 := | |
| (hn t ⟨ht.le,le_rfl⟩).2.trans | |
| (((shrinkingHorizon_le F.horizonScale_pos _).trans F.horizonScale_le).trans (by norm_num)) | |
| apply integral_congr_ae | |
| filter_upwards [E.coldLabelAverage_sub_free hs₀ hsmax hη hηmax hK hα hγ hd₀ hq | |
| k a n ht htime Ω hΩ hψ hψB] with x hx | |
| rw [hx] | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # Actual cold averages converge to the shell-weighted stripe averages -/ | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped Topology ENNReal | |
| open BoltzmannNonuniqueness.VelocityWeight | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| theorem HotLimitExtraction.coldLabel_actual_striped_L1_limit (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) | |
| (hK : 0 ≤ K) (hα : 0 < α) (hαmax : α ≤ 1/4) (hγ : 0 < γ) | |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) | |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) | |
| (hq : q < 2) (k : ℤ) (a : Bool) (hk : E.fraction < E.phase*Real.exp (η*(k:ℝ))) | |
| {t : ℝ} (ht : 0 < t) (htU : ENNReal.ofReal t < E.horizon) | |
| (Ω₁ : Set Transverse) (hΩ₁ : IsCompact Ω₁) (Ω₂ : Set ℝ) (hΩ₂ : IsCompact Ω₂) | |
| {B : ℝ} {ψ : Velocity → ℝ} (hψ : Continuous ψ) (hψB : ∀ v, |ψ v| ≤ B) : | |
| Tendsto (fun n => ∫ x, |E.coldLabelAverage k a n t ψ x-E.coldLabelStripedProfile k a n t ψ x| | |
| ∂JetPrototype.spaceVolume.restrict (Ω₁ ×ˢ Ω₂)) atTop (𝓝 0) := by | |
| let Ω := Ω₁ ×ˢ Ω₂ | |
| have hΩ : IsCompact Ω := hΩ₁.prod hΩ₂ | |
| let ρ := JetPrototype.spaceVolume.restrict Ω | |
| let _ : IsFiniteMeasure ρ := isFiniteMeasure_restrict.mpr hΩ.measure_lt_top.ne | |
| let _ : IsFiniteMeasure ((volume : Measure ℝ).restrict Ω₂) := | |
| isFiniteMeasure_restrict.mpr hΩ₂.measure_lt_top.ne | |
| have hactual := E.coldLabel_average_free_L1_limit hs₀ hsmax hη hηmax hK hα.le hαmax hγ.le | |
| hd₀ hd₀max hsmall hq k a hk ht htU Ω hΩ hψ.measurable hψB | |
| have hfree := E.coldLabel_free_striped_L1_limit hs₀ hη hK hα hγ hd₀ k a ht hψ hψB | |
| Ω₁ hΩ₁.measure_lt_top (volume.restrict Ω₂) | |
| rw [Measure.prod_restrict] at hfree | |
| have hlim := hactual.add hfree | |
| simp only [zero_add] at hlim | |
| apply squeeze_zero (fun _ => integral_nonneg (fun _ => abs_nonneg _)) _ hlim | |
| intro n | |
| have hiA := E.coldLabelAverage_integrable hs₀ hsmax hη hηmax hK hd₀.le hq k a n t Ω hΩ | |
| hψ.measurable hψB | |
| have hiF := E.coldLabelFreeAverage_integrable hs₀ hK hα hγ hd₀ k a n ht hψ hψB ρ | |
| have hiS := E.coldLabelStripedProfile_integrable hK hα hγ k a n ht hψ hψB ρ | |
| have hsum : (∫ x, |E.coldLabelAverage k a n t ψ x-E.coldLabelFreeAverage k a n t ψ x|+ | |
| |E.coldLabelFreeAverage k a n t ψ x-E.coldLabelStripedProfile k a n t ψ x| ∂ρ) = | |
| (∫ x, |E.coldLabelAverage k a n t ψ x-E.coldLabelFreeAverage k a n t ψ x| ∂ρ)+ | |
| (∫ x, |E.coldLabelFreeAverage k a n t ψ x-E.coldLabelStripedProfile k a n t ψ x| ∂ρ) := | |
| integral_add (hiA.sub hiF).abs (hiF.sub hiS).abs | |
| rw [← hsum] | |
| apply integral_mono_of_nonneg (ae_of_all _ (fun _ => abs_nonneg _)) | |
| ((hiA.sub hiF).abs.add (hiF.sub hiS).abs) | |
| exact ae_of_all _ (fun x => abs_sub_le _ _ _) | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # Simultaneous striped approximation on a finite retained mesh -/ | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped Topology ENNReal | |
| open BoltzmannNonuniqueness.VelocityWeight | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| def HotLimitExtraction.finiteColdAverage (E : HotLimitExtraction S) (L U : ℤ) | |
| (n : ℕ) (t : ℝ) (ψ : Velocity → ℝ) (x : JetPrototype.Space) : ℝ := | |
| ∑ a : Bool, ∑ k ∈ Finset.Icc L U, if E.fraction < E.phase*Real.exp (η*(k:ℝ)) then | |
| E.coldLabelAverage k a n t ψ x else 0 | |
| def HotLimitExtraction.finiteStripedProfile (E : HotLimitExtraction S) (L U : ℤ) | |
| (n : ℕ) (t : ℝ) (ψ : Velocity → ℝ) (x : JetPrototype.Space) : ℝ := | |
| ∑ a : Bool, ∑ k ∈ Finset.Icc L U, if E.fraction < E.phase*Real.exp (η*(k:ℝ)) then | |
| E.coldLabelStripedProfile k a n t ψ x else 0 | |
| theorem HotLimitExtraction.finite_actual_striped_L1_limit (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) | |
| (hK : 0 ≤ K) (hα : 0 < α) (hαmax : α ≤ 1/4) (hγ : 0 < γ) | |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) | |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) | |
| (hq : q < 2) (L U : ℤ) {t : ℝ} (ht : 0 < t) (htU : ENNReal.ofReal t < E.horizon) | |
| (Ω₁ : Set Transverse) (hΩ₁ : IsCompact Ω₁) (Ω₂ : Set ℝ) (hΩ₂ : IsCompact Ω₂) | |
| {B : ℝ} {ψ : Velocity → ℝ} (hψ : Continuous ψ) (hψB : ∀ v, |ψ v| ≤ B) : | |
| Tendsto (fun n => ∫ x, |E.finiteColdAverage L U n t ψ x-E.finiteStripedProfile L U n t ψ x| | |
| ∂JetPrototype.spaceVolume.restrict (Ω₁ ×ˢ Ω₂)) atTop (𝓝 0) := by | |
| classical | |
| let ρ := JetPrototype.spaceVolume.restrict (Ω₁ ×ˢ Ω₂) | |
| let _ : IsFiniteMeasure ρ := isFiniteMeasure_restrict.mpr (hΩ₁.prod hΩ₂).measure_lt_top.ne | |
| let f : Bool → ℤ → ℕ → JetPrototype.Space → ℝ := fun a k n x => | |
| if E.fraction < E.phase*Real.exp (η*(k:ℝ)) then | |
| E.coldLabelAverage k a n t ψ x-E.coldLabelStripedProfile k a n t ψ x else 0 | |
| have hi (a k n) : Integrable (f a k n) ρ := by | |
| by_cases hk : E.fraction < E.phase*Real.exp (η*(k:ℝ)) | |
| · exact ((E.coldLabelAverage_integrable hs₀ hsmax hη hηmax hK hd₀.le hq k a n t | |
| (Ω₁ ×ˢ Ω₂) (hΩ₁.prod hΩ₂) hψ.measurable hψB).sub | |
| (E.coldLabelStripedProfile_integrable hK hα hγ k a n ht hψ hψB ρ)).congr | |
| (ae_of_all _ (fun _ => by simp only [f,hk,ite_true]; rfl)) | |
| · simpa only [f,hk,ite_false] using (integrable_const (μ := ρ) (0:ℝ)) | |
| have hl (a k) : Tendsto (fun n => ∫ x, |f a k n x| ∂ρ) atTop (𝓝 0) := by | |
| by_cases hk : E.fraction < E.phase*Real.exp (η*(k:ℝ)) | |
| · simpa only [f,hk,ite_true] using E.coldLabel_actual_striped_L1_limit hs₀ hsmax hη hηmax | |
| hK hα hαmax hγ hd₀ hd₀max hsmall hq k a hk ht htU Ω₁ hΩ₁ Ω₂ hΩ₂ hψ hψB | |
| · simp only [f,hk,ite_false,abs_zero,integral_zero] | |
| exact tendsto_const_nhds | |
| have hinner (a) := Compactness.finite_integral_L1_zero (Finset.Icc L U) | |
| (fun k _ n => hi a k n) (fun k _ => hl a k) | |
| have houter := Compactness.finite_integral_L1_zero (Finset.univ : Finset Bool) | |
| (fun a _ n => integrable_finsetSum (Finset.Icc L U) (fun k _ => hi a k n)) | |
| (fun a _ => hinner a) | |
| convert houter using 1 | |
| funext n | |
| congr 1 | |
| funext x | |
| congr 1 | |
| rw [finiteColdAverage,finiteStripedProfile,← Finset.sum_sub_distrib] | |
| apply Finset.sum_congr rfl | |
| intro a _ | |
| rw [← Finset.sum_sub_distrib] | |
| apply Finset.sum_congr rfl | |
| intro k _ | |
| by_cases hk : E.fraction < E.phase*Real.exp (η*(k:ℝ)) <;> simp only [f,hk,ite_true,ite_false,sub_self] | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # The weak limit of an actual retained cold label -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open scoped ENNReal | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| theorem HotLimitExtraction.coldLabel_weak_limit (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) | |
| (hK : 0 ≤ K) (hα : 0 < α) (hαmax : α ≤ 1/4) (hγ : 0 < γ) | |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) | |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) | |
| (hq : q < 2) (k : ℤ) (a : Bool) (hk : E.fraction < E.phase*Real.exp (η*(k:ℝ))) | |
| {t : ℝ} (ht : 0 < t) (htU : ENNReal.ofReal t < E.horizon) | |
| (Ω₁ : Set VelocityWeight.Transverse) (hΩ₁ : IsCompact Ω₁) | |
| (Ω₂ : Set ℝ) (hΩ₂ : IsCompact Ω₂) | |
| {B : ℝ} {ψ : Velocity → ℝ} (hψ : Continuous ψ) (hψB : ∀ v, |ψ v| ≤ B) : | |
| Published.WeakL1Converges (JetPrototype.spaceVolume.restrict (Ω₁ ×ˢ Ω₂)) | |
| (fun n => E.coldLabelAverage k a n t ψ) (E.coldLabelLimitProfile k a t ψ) := by | |
| let ρ := JetPrototype.spaceVolume.restrict (Ω₁ ×ˢ Ω₂) | |
| let _ : IsFiniteMeasure ρ := isFiniteMeasure_restrict.mpr (hΩ₁.prod hΩ₂).measure_lt_top.ne | |
| have hw := E.coldLabel_striped_weak_limit hs₀ hη hK hα hγ k a ht | |
| (Ω₁ ×ˢ Ω₂) (hΩ₁.prod hΩ₂).measurableSet (hΩ₁.prod hΩ₂).measure_lt_top hψ hψB | |
| exact hw.of_integral_abs_sub | |
| (fun n => E.coldLabelStripedProfile_integrable hK hα hγ k a n ht hψ hψB ρ) | |
| (fun n => E.coldLabelAverage_integrable hs₀ hsmax hη hηmax hK hd₀.le hq k a n t | |
| (Ω₁ ×ˢ Ω₂) (hΩ₁.prod hΩ₂) hψ.measurable hψB) | |
| (E.coldLabel_actual_striped_L1_limit hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max | |
| hsmall hq k a hk ht htU Ω₁ hΩ₁ Ω₂ hΩ₂ hψ hψB) | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # The weak limit of the finite retained cold mesh -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open scoped ENNReal | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| def HotLimitExtraction.finiteColdLimitProfile (E : HotLimitExtraction S) (L U : ℤ) | |
| (t : ℝ) (ψ : Velocity → ℝ) (x : JetPrototype.Space) : ℝ := | |
| ∑ a : Bool, ∑ k ∈ Finset.Icc L U, if E.fraction < E.phase*Real.exp (η*(k:ℝ)) then | |
| E.coldLabelLimitProfile k a t ψ x else 0 | |
| theorem HotLimitExtraction.finite_cold_weak_limit (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) | |
| (hK : 0 ≤ K) (hα : 0 < α) (hαmax : α ≤ 1/4) (hγ : 0 < γ) | |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) | |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) | |
| (hq : q < 2) (L U : ℤ) {t : ℝ} (ht : 0 < t) (htU : ENNReal.ofReal t < E.horizon) | |
| (Ω₁ : Set VelocityWeight.Transverse) (hΩ₁ : IsCompact Ω₁) | |
| (Ω₂ : Set ℝ) (hΩ₂ : IsCompact Ω₂) | |
| {B : ℝ} {ψ : Velocity → ℝ} (hψ : Continuous ψ) (hψB : ∀ v, |ψ v| ≤ B) : | |
| Published.WeakL1Converges (JetPrototype.spaceVolume.restrict (Ω₁ ×ˢ Ω₂)) | |
| (fun n => E.finiteColdAverage L U n t ψ) (E.finiteColdLimitProfile L U t ψ) := by | |
| classical | |
| let ρ := JetPrototype.spaceVolume.restrict (Ω₁ ×ˢ Ω₂) | |
| let _ : IsFiniteMeasure ρ := isFiniteMeasure_restrict.mpr (hΩ₁.prod hΩ₂).measure_lt_top.ne | |
| let f : Bool → ℤ → ℕ → JetPrototype.Space → ℝ := fun a k n x => | |
| if E.fraction < E.phase*Real.exp (η*(k:ℝ)) then E.coldLabelAverage k a n t ψ x else 0 | |
| let g : Bool → ℤ → JetPrototype.Space → ℝ := fun a k x => | |
| if E.fraction < E.phase*Real.exp (η*(k:ℝ)) then E.coldLabelLimitProfile k a t ψ x else 0 | |
| have hi (a k n) : Integrable (f a k n) ρ := by | |
| by_cases hk : E.fraction < E.phase*Real.exp (η*(k:ℝ)) | |
| · simpa only [f,hk,ite_true] using E.coldLabelAverage_integrable hs₀ hsmax hη hηmax | |
| hK hd₀.le hq k a n t (Ω₁ ×ˢ Ω₂) (hΩ₁.prod hΩ₂) hψ.measurable hψB | |
| · simpa only [f,hk,ite_false] using (integrable_const (μ := ρ) (0:ℝ)) | |
| have hw (a k) : Published.WeakL1Converges ρ (f a k) (g a k) := by | |
| by_cases hk : E.fraction < E.phase*Real.exp (η*(k:ℝ)) | |
| · simpa only [f,g,hk,ite_true] using E.coldLabel_weak_limit hs₀ hsmax hη hηmax | |
| hK hα hαmax hγ hd₀ hd₀max hsmall hq k a hk ht htU Ω₁ hΩ₁ Ω₂ hΩ₂ hψ hψB | |
| · simp only [f,g,hk,ite_false] | |
| refine ⟨measurable_const,integrable_const 0,?_⟩ | |
| intro φ _ _ | |
| simp only [mul_zero,integral_zero] | |
| exact tendsto_const_nhds | |
| have hinner (a) := Published.WeakL1Converges.finset_sum (Finset.Icc L U) | |
| (fun k _ => hw a k) (fun k _ n => hi a k n) | |
| have houter := Published.WeakL1Converges.finset_sum (Finset.univ : Finset Bool) | |
| (fun a _ => hinner a) | |
| (fun a _ n => integrable_finsetSum (Finset.Icc L U) (fun k _ => hi a k n)) | |
| exact houter | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # Identifying the finite cold limit with the actual atomic background -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open BoltzmannNonuniqueness.VelocityWeight | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| theorem HotLimitExtraction.finiteColdLimitProfile_eq_background (E : HotLimitExtraction S) | |
| (hη : 0 < η) (hK : 0 ≤ K) (hα : 0 ≤ α) (hγ : 0 ≤ γ) | |
| {t δ R : ℝ} (ht : 0 ≤ t) (hδ : 0 < δ) (x : JetPrototype.Space) | |
| (hlo : δ ≤ ‖x.1‖) (hhi : ‖x.1‖ ≤ R) (ψ : Velocity → ℝ) : | |
| E.finiteColdLimitProfile (GeometricMesh.index (δ/Real.exp η) η) (GeometricMesh.index R η) | |
| t ψ x = ∫ v, ψ v ∂E.background t x := by | |
| convert! (GeometricBackground.integral_finite_window E.phase_mem.1 E.phase_mem.2 hη hδ | |
| hK hα hγ ht x hlo hhi ψ).symm using 1 | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # The finite cold mesh converges to the geometric background away from the axis -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open scoped ENNReal | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| theorem HotLimitExtraction.background_average_measurable (E : HotLimitExtraction S) | |
| (hK : 0 ≤ K) (hα : 0 ≤ α) (hγ : 0 ≤ γ) {t : ℝ} (ht : 0 ≤ t) | |
| {ψ : Velocity → ℝ} (hψ : Measurable ψ) : | |
| Measurable (fun x => ∫ v, ψ v ∂E.background t x) := by | |
| have hm := (GeometricBackground.clamped_background_test_measurable | |
| (zero_lt_one.trans_le E.phase_mem.1) hK hα hγ η E.fraction hψ).comp | |
| (measurable_const.prodMk measurable_id : Measurable (fun x : JetPrototype.Space => (t,x))) | |
| dsimp only [Function.comp_def] at hm | |
| simpa only [max_eq_right ht,background] using hm | |
| theorem HotLimitExtraction.finite_cold_background_limit (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) | |
| (hK : 0 ≤ K) (hα : 0 < α) (hαmax : α ≤ 1/4) (hγ : 0 < γ) | |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) | |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) | |
| (hq : q < 2) {t δ R : ℝ} (ht : 0 < t) (htU : ENNReal.ofReal t < E.horizon) (hδ : 0 < δ) | |
| (Ω₁ : Set VelocityWeight.Transverse) (hΩ₁ : IsCompact Ω₁) | |
| (hlo : ∀ y ∈ Ω₁, δ ≤ ‖y‖) (hhi : ∀ y ∈ Ω₁, ‖y‖ ≤ R) | |
| (Ω₂ : Set ℝ) (hΩ₂ : IsCompact Ω₂) | |
| {B : ℝ} {ψ : Velocity → ℝ} (hψ : Continuous ψ) (hψB : ∀ v, |ψ v| ≤ B) : | |
| Published.WeakL1Converges (JetPrototype.spaceVolume.restrict (Ω₁ ×ˢ Ω₂)) | |
| (fun n => E.finiteColdAverage (GeometricMesh.index (δ/Real.exp η) η) | |
| (GeometricMesh.index R η) n t ψ) (fun x => ∫ v, ψ v ∂E.background t x) := by | |
| have hw := E.finite_cold_weak_limit hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max hsmall hq | |
| (GeometricMesh.index (δ/Real.exp η) η) (GeometricMesh.index R η) ht htU Ω₁ hΩ₁ Ω₂ hΩ₂ hψ hψB | |
| apply hw.congr_limit (E.background_average_measurable hK hα.le hγ.le ht.le hψ.measurable) | |
| filter_upwards [ae_restrict_mem (hΩ₁.prod hΩ₂).measurableSet] with x hx | |
| exact E.finiteColdLimitProfile_eq_background hη hK hα.le hγ.le ht.le hδ x | |
| (hlo x.1 hx.1) (hhi x.1 hx.1) ψ | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| end OAI | |