| import OAI.MathematicalPhysics.Boltzmann.Approximation.CapFiniteBackgroundLimit |
| import OAI.MathematicalPhysics.Boltzmann.Approximation.CapHotSourceIntegrability |
| import OAI.MathematicalPhysics.Boltzmann.Approximation.CapHotUndamped |
| import OAI.MathematicalPhysics.Boltzmann.Approximation.CapLabelFreeLimit |
| import OAI.MathematicalPhysics.Boltzmann.Branching.EuclideanKineticMap |
| import OAI.MathematicalPhysics.Boltzmann.Branching.MomentAverageBound |
| import OAI.MathematicalPhysics.Boltzmann.Branching.VanishingMajorant |
| import OAI.MathematicalPhysics.Boltzmann.Jets.GeometricDampedRetention |
| import OAI.MathematicalPhysics.Boltzmann.Jets.GeometricMesh |
| import OAI.MathematicalPhysics.Boltzmann.Jets.JetFiniteCap |
| import OAI.MathematicalPhysics.Boltzmann.Jets.JetFamilyBounds |
|
|
| namespace OAI |
|
|
| section |
|
|
| /-! |
|
|
| noncomputable section |
|
|
| open MeasureTheory Set |
| open scoped ENNReal |
| open BoltzmannNonuniqueness.WeightedLocal BoltzmannNonuniqueness.WeightedLocalControl |
| open BoltzmannNonuniqueness.WeightedTranslation BoltzmannNonuniqueness.VelocityWeight |
| open BoltzmannNonuniqueness.VelocityMoment |
|
|
| namespace BoltzmannNonuniqueness.JetCopyDatum |
|
|
| theorem CapApproximation.cold_envelope {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) (hα : 0 ≤ α) (hγ : 0 ≤ γ) (hd₀ : 0 < d₀) |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) |
| (hq : q < 2) (hT : 0 ≤ T) (hTmax : T ≤ 1/32) |
| (i : JetLattice.Label) {t : ℝ} (ht : t ∈ Ioc 0 T) (p : JetPrototype.Phase) : |
| H q p.2*F.cold i (t,p) ≤ |
| JetSupersolution.U η K α γ (JetGeometry.jetScale s₀ η i.annulus) |
| (d₀*JetGeometry.jetScale s₀ η i.annulus^10) t i.positive |
| (shift (displacement i.lattice) p) := by |
| have hδ := DatumBounds.scale_pos (η := η) hs₀ (N+1) |
| have hδone : DatumBounds.scale s₀ η (N+1) ≤ 1 := by |
| have h := JetGeometry.scale_antitone hs₀.le hη.le (Nat.zero_le (N+1)) |
| rw [show DatumBounds.scale s₀ η 0 = s₀ by simp [DatumBounds.scale]] at h |
| linarith |
| have hh₀ (p) : 0 ≤ F.coefficient*HotSeedProfile.normalized q (DatumBounds.scale s₀ η (N+1)) p := |
| mul_nonneg F.coefficient_mem.1 ((HotSeedProfile.normalized_bounds hδ hδone q).choose_spec.2 p).1 |
| exact rebuilt_envelope hs₀ hsmax hη hηmax hK hα hγ hd₀ hsmall hq (by positivity) |
| (bounds (by positivity) F.amplitude_pos).1 hT (by linarith [F.amplitude_pos]) |
| (hTmax.trans (by norm_num)) le_rfl N hh₀ F.solution.measurable_value |
| F.solution.value_bounds F.initial_bound i ht p |
|
|
| theorem CapApproximation.coldTotal_moment_bound {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) (hα : 0 < α) (hαmax : α ≤ 1) (hγ : 0 < γ) |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) |
| (hq : q < 2) (hT : 0 ≤ T) (hTmax : T ≤ 1/32) |
| {t : ℝ} (ht : t ∈ Ioc 0 T) (x : JetPrototype.Space) : |
| moment (fun v => H q v*F.coldTotal (t,(x,v))) ≤ ENNReal.ofReal |
| (escapedConstant s₀ η K α d₀*hotConstant q+JetEnvelopeGain.momentConstant K α γ/t) := by |
| have hc := F.cold_properties hs₀ hsmax hη hηmax hK hd₀.le hq hT |
| have hs := F.coldTotal_properties hs₀ hsmax hη hηmax hK hd₀.le hq hT |
| have hcell (y : Velocity) (hy : y ∈ TorusChart.cube) : |
| moment (fun v => H q v*F.coldTotal (t,(JetPeriodicDatum.spatialMap y,v))) ≤ |
| ENNReal.ofReal (escapedConstant s₀ η K α d₀*hotConstant q+ |
| JetEnvelopeGain.momentConstant K α γ/t) := by |
| have hm := cell_moment_bound (Z := 0) hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max |
| hq le_rfl ht.1 (ht.2.trans hTmax) hsmall N y hy |
| (fun v => F.coldTotal (t,(JetPeriodicDatum.spatialMap y,v))) |
| (fun i v => F.cold i (t,(JetPeriodicDatum.spatialMap y,v))) |
| (fun i => (hc.1 i).comp (measurable_const.prodMk (measurable_const.prodMk measurable_id))) |
| (fun i v => hc.2.1 i _) (fun v => (hs.2 _).1) |
| (fun i hi v => congrFun (rebuilt_zero s₀ η K α γ d₀ q (N+1) |
| (damping q (N+1) F.amplitude) T N (fun u => (F.solution.value_bounds u).1) i hi) _) |
| (fun i v => F.cold_envelope hs₀ hsmax hη hηmax hK hα.le hγ.le hd₀ hsmall hq hT hTmax |
| i ht (JetPeriodicDatum.spatialMap y,v)) (ae_of_all _ (fun _ => by simp [coldTotal])) |
| apply hm.trans (ENNReal.ofReal_le_ofReal ?_) |
| simpa only [zero_add,div_eq_mul_inv,one_mul] using |
| add_le_add (le_refl (escapedConstant s₀ η K α d₀*hotConstant q)) |
| (mul_le_mul_of_nonneg_left |
| (AnnularEnvelope.finiteEnvelope_le_inv_time hs₀.le hη.le ht.1 (Finset.range N) |
| (transverse y)) (JetEnvelopeGain.momentConstant_nonneg hK α γ)) |
| obtain ⟨n,y,hy,hxy⟩ := exists_shift_in_centered_cell x |
| have he (v : Velocity) : F.coldTotal (t,(JetPeriodicDatum.spatialMap y,v)) = |
| F.coldTotal (t,(x,v)) := by |
| have h := family_sum_pull (c := F.cold) (displacement n) (relabel n) |
| (fun i => rebuilt_shift n (F.solution.periodic n) i) (t,(x,v)) |
| change F.coldTotal (t,(x-displacement n,v)) = F.coldTotal (t,(x,v)) at h |
| rwa [hxy] at h |
| simpa only [he] using hcell y hy |
|
|
| end BoltzmannNonuniqueness.JetCopyDatum |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| /-! # Uniform cold moments on positive-time blow-up slabs -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology |
| open BoltzmannNonuniqueness.VelocityWeight |
|
|
| namespace BoltzmannNonuniqueness.VelocityMoment |
|
|
| theorem moment_const_mul {r : ℝ} (hr : 0 ≤ r) (f : Velocity → ℝ) : |
| moment (fun v => r*f v) = ENNReal.ofReal r*moment f := by |
| unfold moment |
| simp_rw [show ∀ v, weight v*(r*f v) = r*(weight v*f v) by intro v; ring, |
| ENNReal.ofReal_mul hr] |
| exact lintegral_const_mul' _ _ ENNReal.ofReal_ne_top |
| |
| end BoltzmannNonuniqueness.VelocityMoment |
| |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence |
| |
| open VelocityMoment |
| |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} |
|
|
| theorem rescaledColdDensity_moment (S : AttainedCapSequence F) |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) |
| (hK : 0 ≤ K) (hα : 0 < α) (hαmax : α ≤ 1) (hγ : 0 < γ) |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) |
| (hq : q < 2) (n : ℕ) {t : ℝ} (ht : 0 < t) |
| (hT : S.radius n*t ≤ shrinkingHorizon F.horizonScale n) (x : JetPrototype.Space) : |
| moment (fun v => S.rescaledColdDensity n ((t,x),v)) ≤ ENNReal.ofReal |
| (S.radius n*(escapedConstant s₀ η K α d₀*hotConstant q)+ |
| JetEnvelopeGain.momentConstant K α γ/t) := by |
| have hr := S.radius_pos hs₀ n |
| have hb := (F.approximation n).coldTotal_moment_bound hs₀ hsmax hη hηmax hK hα hαmax hγ |
| hd₀ hd₀max hsmall hq (shrinkingHorizon_pos F.horizonScale_pos n).le |
| ((shrinkingHorizon_le F.horizonScale_pos n).trans F.horizonScale_le) |
| ⟨mul_pos hr ht,hT⟩ (S.radius n • x) |
| have he : (fun v => S.rescaledColdDensity n ((t,x),v)) = |
| (fun v => S.radius n*(H q v*(F.approximation n).coldTotal |
| (S.radius n*t,(S.radius n • x,v)))) := by |
| funext v |
| exact mul_assoc _ _ _ |
| rw [he,moment_const_mul hr.le] |
| apply (mul_le_mul' le_rfl hb).trans |
| rw [← ENNReal.ofReal_mul hr.le] |
| apply le_of_eq |
| congr 1 |
| field_simp |
|
|
| theorem eventually_rescaledColdDensity_moment (S : AttainedCapSequence F) |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) |
| (hK : 0 ≤ K) (hα : 0 < α) (hαmax : α ≤ 1) (hγ : 0 < γ) |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) |
| (hq : q < 2) {κ : ℕ → ℕ} (hκ : StrictMono κ) {U : ℝ≥0∞} |
| (hU : Tendsto (fun n => S.normalizedHorizon (κ n)) atTop (𝓝 U)) |
| {a A : ℝ} (ha : 0 < a) (hA : ENNReal.ofReal A < U) : |
| ∀ᶠ n in atTop, ∀ t ∈ Icc a A, ∀ x : JetPrototype.Space, |
| moment (fun v => S.rescaledColdDensity (κ n) ((t,x),v)) ≤ ENNReal.ofReal |
| (escapedConstant s₀ η K α d₀*hotConstant q+JetEnvelopeGain.momentConstant K α γ/a) := by |
| have hC : 0 ≤ escapedConstant s₀ η K α d₀*hotConstant q := |
| mul_nonneg (JetEscapedEnvelope.constant_nonneg hs₀ hK hd₀ η α _) (hotConstant_nonneg q) |
| have hr := ((S.radius_tendsto_zero hs₀).comp hκ.tendsto_atTop).eventually |
| (gt_mem_nhds (show (0:ℝ) < 1 by norm_num)) |
| filter_upwards [hr,S.eventually_scaled_slab hs₀ hU hA] with n hn hslab |
| intro t ht x |
| have htpos := ha.trans_le ht.1 |
| apply (S.rescaledColdDensity_moment hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max hsmall hq |
| (κ n) htpos (hslab t ⟨htpos.le,ht.2⟩).2 x).trans |
| apply ENNReal.ofReal_le_ofReal |
| apply add_le_add |
| · simpa only [Function.comp_apply,one_mul] using mul_le_mul_of_nonneg_right hn.le hC |
| · exact div_le_div_of_nonneg_left (JetEnvelopeGain.momentConstant_nonneg hK α γ) ha ht.1 |
|
|
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| /-! # The actual escaped cold density in Euclidean coordinates -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory Set |
| open BoltzmannNonuniqueness.VelocityWeight |
|
|
| namespace BoltzmannNonuniqueness.JetLattice |
|
|
| theorem measurableSet_spatialEnlargement (s₀ η : ℝ) (i : Label) : |
| MeasurableSet {z : ℝ × Velocity | z.2 ∈ spatialEnlargement s₀ η z.1 i} := by |
| change MeasurableSet |
| ({z : ℝ × Velocity | transverse z.2-transverseShift i.lattice ∈ |
| JetGeometry.enlargement η (JetGeometry.jetScale s₀ η i.annulus) i.positive} ∩ |
| {z : ℝ × Velocity | |axial z.2-axialShift i.lattice| ≤ 1/8+2*z.1+1/16}) |
| apply MeasurableSet.inter |
| · exact (Metric.isClosed_cthickening.measurableSet).preimage (by |
| unfold transverse transverseShift |
| fun_prop) |
| · exact measurableSet_le (by unfold axial; fun_prop) (by fun_prop) |
| |
| end BoltzmannNonuniqueness.JetLattice |
| |
| namespace BoltzmannNonuniqueness.JetCopyDatum |
| |
| def CapApproximation.escapedTotal {s₀ η K α γ d₀ q T : ℝ} {N : ℕ} |
| (F : CapApproximation s₀ η K α γ d₀ q T N) (z : Published.KineticPhase) : ℝ := |
| ∑' i, escaped s₀ η z.1.1 N z.1.2 |
| (fun j => F.cold j (z.1.1,(JetPeriodicDatum.spatialMap z.1.2,z.2))) i |
|
|
| theorem CapApproximation.escapedTotal_measurable {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) : |
| Measurable F.escapedTotal := by |
| classical |
| have hc := (F.cold_properties hs₀ hsmax hη hηmax hK hd₀ hq hT).1 |
| apply Measurable.tsum |
| intro i |
| have hi : MeasurableSet {z : Published.KineticPhase | |
| z.1.2 ∉ JetLattice.spatialEnlargement s₀ η z.1.1 i} := |
| ((JetLattice.measurableSet_spatialEnlargement s₀ η i).preimage measurable_fst).compl |
| have hm : Measurable (fun z : Published.KineticPhase => |
| F.cold i (z.1.1,(JetPeriodicDatum.spatialMap z.1.2,z.2))) := by |
| apply (hc i).comp |
| unfold JetPeriodicDatum.spatialMap transverse axial |
| fun_prop |
| by_cases hN : i.annulus < N |
| · change Measurable (fun z : Published.KineticPhase => if i.annulus < N ∧ |
| JetLatticeTail.outside η (JetGeometry.jetScale s₀ η i.annulus) z.1.1 i.positive z.1.2 i.lattice |
| then F.cold i (z.1.1,(JetPeriodicDatum.spatialMap z.1.2,z.2)) else 0) |
| simp only [hN,true_and,outside_iff_not_mem] |
| exact hm.ite hi measurable_const |
| · change Measurable (fun z : Published.KineticPhase => if i.annulus < N ∧ |
| JetLatticeTail.outside η (JetGeometry.jetScale s₀ η i.annulus) z.1.1 i.positive z.1.2 i.lattice |
| then F.cold i (z.1.1,(JetPeriodicDatum.spatialMap z.1.2,z.2)) else 0) |
| simp only [hN,false_and,ite_false] |
| exact measurable_const |
|
|
| theorem CapApproximation.escapedTotal_nonneg {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) |
| (z : Published.KineticPhase) : 0 ≤ F.escapedTotal z := by |
| have hc := (F.cold_properties hs₀ hsmax hη hηmax hK hd₀ hq hT).2.1 |
| apply tsum_nonneg |
| intro i |
| unfold escaped |
| split_ifs |
| · exact hc i _ |
| · exact le_rfl |
|
|
| theorem CapApproximation.escapedTotal_bound {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) (hα : 0 ≤ α) (hαmax : α ≤ 1) (hγ : 0 ≤ γ) |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) |
| (hq : q < 2) (hT : 0 ≤ T) (hTmax : T ≤ 1/32) |
| (A : ℝ) {z : Published.KineticPhase} (ht : z.1.1 ∈ Ioc 0 T) |
| (hx : ∀ k, |z.1.2 k| ≤ 1) : |
| F.escapedTotal z ≤ JetEscapedEnvelope.constant s₀ η α K d₀ |
| (JetEscapedEnvelope.exponent A)*z.1.1^A := by |
| have hc := F.cold_properties hs₀ hsmax hη hηmax hK hd₀.le hq hT |
| let f : JetLattice.Label → ℝ := fun j => F.cold j (z.1.1,(JetPeriodicDatum.spatialMap z.1.2,z.2)) |
| have hfs : Summable f := |
| ((F.coldTotal_properties hs₀ hsmax hη hηmax hK hd₀.le hq hT).2 _).1 |
| have henv (i : JetLattice.Label) : H q z.2*f i ≤ |
| JetSupersolution.U η K α γ (JetGeometry.jetScale s₀ η i.annulus) |
| (d₀*JetGeometry.jetScale s₀ η i.annulus^10) z.1.1 i.positive |
| (JetSpatialBox.shifted z.1.2 i.lattice,z.2) := by |
| have he : (JetSpatialBox.shifted z.1.2 i.lattice,z.2) = |
| WeightedTranslation.shift (displacement i.lattice) (JetPeriodicDatum.spatialMap z.1.2,z.2) := rfl |
| rw [he] |
| exact F.cold_envelope hs₀ hsmax hη hηmax hK hα hγ hd₀ hsmall hq hT hTmax i ht |
| (JetPeriodicDatum.spatialMap z.1.2,z.2) |
| have hb := normalized_escaped_bound (γ := γ) hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max ht.1 |
| (ht.2.trans hTmax) hsmall A q N f z.1.2 z.2 hx |
| (fun i => hc.2.1 i _) hfs (fun i _ => henv i) |
| exact hb |
|
|
| end BoltzmannNonuniqueness.JetCopyDatum |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| /-! # Exact removal of the escaped colors from an actual cap approximation -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory Set |
| open BoltzmannNonuniqueness.VelocityWeight |
|
|
| namespace BoltzmannNonuniqueness.JetCopyDatum |
|
|
| def CapApproximation.centralTotal {s₀ η K α γ d₀ q T : ℝ} {N : ℕ} |
| (F : CapApproximation s₀ η K α γ d₀ q T N) (z : Published.KineticPhase) : ℝ := by |
| classical |
| exact ∑' i, if i.annulus < N ∧ z.1.2 ∈ JetLattice.spatialEnlargement s₀ η z.1.1 i |
| then F.cold i (z.1.1,(JetPeriodicDatum.spatialMap z.1.2,z.2)) else 0 |
|
|
| theorem CapApproximation.centralTotal_measurable {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) : |
| Measurable F.centralTotal := by |
| classical |
| have hc := (F.cold_properties hs₀ hsmax hη hηmax hK hd₀ hq hT).1 |
| apply Measurable.tsum |
| intro i |
| have hm : Measurable (fun z : Published.KineticPhase => |
| F.cold i (z.1.1,(JetPeriodicDatum.spatialMap z.1.2,z.2))) := by |
| apply (hc i).comp |
| unfold JetPeriodicDatum.spatialMap transverse axial |
| fun_prop |
| have hi : MeasurableSet {z : Published.KineticPhase | |
| z.1.2 ∈ JetLattice.spatialEnlargement s₀ η z.1.1 i} := |
| (JetLattice.measurableSet_spatialEnlargement s₀ η i).preimage measurable_fst |
| by_cases hN : i.annulus < N |
| · simpa only [hN,true_and] using hm.ite hi measurable_const |
| · simp only [hN,false_and,ite_false] |
| exact measurable_const |
|
|
| theorem CapApproximation.coldTotal_eq_central_add_escaped {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) |
| (z : Published.KineticPhase) : |
| F.coldTotal (z.1.1,(JetPeriodicDatum.spatialMap z.1.2,z.2)) = |
| F.centralTotal z+F.escapedTotal z := by |
| classical |
| let f : JetLattice.Label → ℝ := fun i => F.cold i (z.1.1,(JetPeriodicDatum.spatialMap z.1.2,z.2)) |
| let g : JetLattice.Label → ℝ := fun i => |
| if i.annulus < N ∧ z.1.2 ∈ JetLattice.spatialEnlargement s₀ η z.1.1 i then f i else 0 |
| let h : JetLattice.Label → ℝ := escaped s₀ η z.1.1 N z.1.2 f |
| have hc := F.cold_properties hs₀ hsmax hη hηmax hK hd₀ hq hT |
| have hfs : Summable f := (F.coldTotal_properties hs₀ hsmax hη hηmax hK hd₀ hq hT).2 _ |>.1 |
| have hfn (i) : 0 ≤ f i := hc.2.1 i _ |
| have hgn (i) : 0 ≤ g i := by |
| dsimp [g] |
| split_ifs |
| · exact hfn i |
| · exact le_rfl |
| have hgl (i) : g i ≤ f i := by dsimp [g]; split_ifs <;> simp only [le_refl,hfn] |
| have hhn (i) : 0 ≤ h i := by |
| dsimp [h,escaped] |
| split_ifs |
| · exact hfn i |
| · exact le_rfl |
| have hhl (i) : h i ≤ f i := by dsimp [h,escaped]; split_ifs <;> simp only [le_refl,hfn] |
| have hgs := Summable.of_nonneg_of_le hgn hgl hfs |
| have hhs := Summable.of_nonneg_of_le hhn hhl hfs |
| change (∑' i, f i) = (∑' i, g i)+(∑' i, h i) |
| rw [← hgs.tsum_add hhs] |
| apply tsum_congr |
| intro i |
| by_cases hN : i.annulus < N |
| · by_cases hi : z.1.2 ∈ JetLattice.spatialEnlargement s₀ η z.1.1 i |
| <;> simp [g,h,escaped,hN,hi,outside_iff_not_mem] |
| · have hz : f i = 0 := congrFun |
| (rebuilt_zero s₀ η K α γ d₀ q (N+1) (WeightedLocalControl.damping q (N+1) F.amplitude) |
| T N (fun u => (F.solution.value_bounds u).1) i hN) _ |
| simp [g,h,escaped,hN,hz] |
|
|
| theorem CapApproximation.centralTotal_single {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) |
| (z : Published.KineticPhase) (ht : z.1.1 ≤ 1/32) |
| (i : JetLattice.Label) (hN : i.annulus < N) |
| (hi : z.1.2 ∈ JetLattice.spatialEnlargement s₀ η z.1.1 i) : |
| F.centralTotal z = F.cold i (z.1.1,(JetPeriodicDatum.spatialMap z.1.2,z.2)) := by |
| classical |
| unfold centralTotal |
| rw [tsum_eq_single i] |
| · simp only [hN,hi,and_self,ite_true] |
| · intro j hji |
| have hj : ¬(j.annulus < N ∧ z.1.2 ∈ JetLattice.spatialEnlargement s₀ η z.1.1 j) := by |
| rintro ⟨_,hj⟩ |
| exact hji (JetLattice.common_point_label hs₀ hsmax hη hηmax ht hj hi) |
| simp only [hj,ite_false] |
|
|
| end BoltzmannNonuniqueness.JetCopyDatum |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| /-! # The actual cold density is bounded by the main free core and its remainder -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory Set |
| open BoltzmannNonuniqueness.Published BoltzmannNonuniqueness.JetLattice |
| open BoltzmannNonuniqueness.VelocityWeight |
|
|
| namespace BoltzmannNonuniqueness.JetCopyDatum |
|
|
| theorem CapApproximation.cold_free_majorant_at_main {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) (hα : 0 ≤ α) (hγ : 0 ≤ γ) (hd₀ : 0 < d₀) |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) |
| (hq : q < 2) (hT : 0 ≤ T) (hTmax : T ≤ 1/32) |
| (z : KineticPhase) (ht : z.1.1 ∈ Ioc 0 T) (i : Label) (hi : i.annulus < N) |
| (hx : z.1.2 ∈ spatialEnlargement s₀ η z.1.1 i) : |
| H q z.2*F.coldTotal (z.1.1,(JetPeriodicDatum.spatialMap z.1.2,z.2)) ≤ |
| JetFreeTransport.free η K α γ (JetGeometry.jetScale s₀ η i.annulus) |
| (d₀*JetGeometry.jetScale s₀ η i.annulus^10) z.1.1 i.positive |
| (WeightedTranslation.shift (displacement i.lattice) (JetPeriodicDatum.spatialMap z.1.2,z.2))+ |
| JetSupersolution.epsilon K (JetGeometry.jetScale s₀ η i.annulus) |
| (d₀*JetGeometry.jetScale s₀ η i.annulus^10)* |
| JetBarrier.barrier η K α γ (JetGeometry.jetScale s₀ η i.annulus) |
| (d₀*JetGeometry.jetScale s₀ η i.annulus^10) z.1.1 i.positive |
| (WeightedTranslation.shift (displacement i.lattice) (JetPeriodicDatum.spatialMap z.1.2,z.2))+ |
| H q z.2*F.escapedTotal z := by |
| rw [F.coldTotal_eq_central_add_escaped hs₀ hsmax hη hηmax hK hd₀.le hq hT z, |
| F.centralTotal_single hs₀ hsmax hη hηmax z (ht.2.trans hTmax) i hi hx,mul_add] |
| exact add_le_add (F.cold_envelope hs₀ hsmax hη hηmax hK hα hγ hd₀ hsmall hq hT hTmax |
| i ht (JetPeriodicDatum.spatialMap z.1.2,z.2)) le_rfl |
|
|
| theorem CapApproximation.coldTotal_eq_escaped_of_no_main {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) (z : KineticPhase) |
| (hx : ∀ i : Label, i.annulus < N → z.1.2 ∉ spatialEnlargement s₀ η z.1.1 i) : |
| F.coldTotal (z.1.1,(JetPeriodicDatum.spatialMap z.1.2,z.2)) = F.escapedTotal z := by |
| classical |
| rw [F.coldTotal_eq_central_add_escaped hs₀ hsmax hη hηmax hK hd₀ hq hT z] |
| have hz : F.centralTotal z = 0 := by |
| have hi : ∀ i : Label, ¬(i.annulus < N ∧ z.1.2 ∈ spatialEnlargement s₀ η z.1.1 i) := |
| fun i hi => hx i hi.1 hi.2 |
| simp only [CapApproximation.centralTotal,hi,ite_false,tsum_zero] |
| rw [hz,zero_add] |
|
|
| end BoltzmannNonuniqueness.JetCopyDatum |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| /-! # Only finitely many central colors remain in the centered cell -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory Set |
| open BoltzmannNonuniqueness.VelocityWeight |
|
|
| namespace BoltzmannNonuniqueness.JetCopyDatum |
|
|
| def centralLabels (N : ℕ) : Finset JetLattice.Label := |
| ((Finset.range N).product (Finset.univ : Finset Bool)).image |
| (fun p => ⟨p.1,p.2,0⟩) |
|
|
| theorem mem_centralLabels {N : ℕ} {i : JetLattice.Label} : |
| i ∈ centralLabels N ↔ i.annulus < N ∧ i.lattice = 0 := by |
| classical |
| constructor |
| · intro hi |
| obtain ⟨p,hp,rfl⟩ := Finset.mem_image.mp hi |
| exact ⟨Finset.mem_range.mp (Finset.mem_product.mp hp).1,rfl⟩ |
| · rintro ⟨hN,hl⟩ |
| apply Finset.mem_image.mpr |
| refine ⟨(i.annulus,i.positive),Finset.mem_product.mpr |
| ⟨Finset.mem_range.mpr hN,Finset.mem_univ _⟩,?_⟩ |
| cases i |
| simp_all |
|
|
| theorem CapApproximation.centralTotal_finite {s₀ η K α γ d₀ q T : ℝ} {N : ℕ} |
| (F : CapApproximation s₀ η K α γ d₀ q T N) |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) |
| (z : Published.KineticPhase) (ht : z.1.1 ≤ 1/32) (hx : z.1.2 ∈ TorusChart.cube) : |
| F.centralTotal z = ∑ i ∈ centralLabels N, |
| (JetLattice.spatialEnlargement s₀ η z.1.1 i).indicator |
| (fun _ => F.cold i (z.1.1,(JetPeriodicDatum.spatialMap z.1.2,z.2))) z.1.2 := by |
| classical |
| unfold centralTotal |
| rw [tsum_eq_sum (s := centralLabels N)] |
| · apply Finset.sum_congr rfl |
| intro i hi |
| simp only [(mem_centralLabels.mp hi).1,true_and,Set.indicator_apply] |
| · intro i hi |
| by_cases hm : i.annulus < N ∧ z.1.2 ∈ JetLattice.spatialEnlargement s₀ η z.1.1 i |
| · exact False.elim (hi (mem_centralLabels.mpr |
| ⟨hm.1,enlargement_central_lattice hs₀ hsmax hη ht hx hm.2⟩)) |
| · simp only [hm,ite_false] |
|
|
| theorem CapApproximation.centralTotal_finite_pairs {s₀ η K α γ d₀ q T : ℝ} {N : ℕ} |
| (F : CapApproximation s₀ η K α γ d₀ q T N) |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) |
| (z : Published.KineticPhase) (ht : z.1.1 ≤ 1/32) (hx : z.1.2 ∈ TorusChart.cube) : |
| F.centralTotal z = ∑ j ∈ Finset.range N, ∑ a : Bool, |
| (JetLattice.spatialEnlargement s₀ η z.1.1 ⟨j,a,0⟩).indicator |
| (fun _ => F.cold ⟨j,a,0⟩ (z.1.1,(JetPeriodicDatum.spatialMap z.1.2,z.2))) z.1.2 := by |
| rw [F.centralTotal_finite hs₀ hsmax hη z ht hx,centralLabels,Finset.sum_image] |
| · exact Finset.sum_product _ _ _ |
| · intro p _ q _ hpq |
| have h₁ := congrArg JetLattice.Label.annulus hpq |
| have h₂ := congrArg JetLattice.Label.positive hpq |
| exact Prod.ext h₁ h₂ |
|
|
| end BoltzmannNonuniqueness.JetCopyDatum |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| /-! # The central cold sum on a fixed radial window has fixed mesh indices -/ |
|
|
| 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.centralTotal_mesh_window (E : HotLimitExtraction S) |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) |
| {δ R : ℝ} (hδ : 0 < δ) (n : ℕ) (t : ℝ) (x v : Velocity) |
| (ht : S.radius (E.indices n)*t ≤ 1/32) |
| (hx : S.radius (E.indices n) • x ∈ TorusChart.cube) |
| (hlo : δ ≤ ‖transverse x‖) (hhi : ‖transverse x‖ ≤ R) |
| (hU : GeometricMesh.index R η < GeometricMesh.index (s₀/S.radius (E.indices n)) η) : |
| (F.approximation (E.indices n)).centralTotal |
| ((S.radius (E.indices n)*t,S.radius (E.indices n) • x),v) = |
| ∑ a : Bool, ∑ k ∈ Finset.Icc (GeometricMesh.index (δ/Real.exp η) η) (GeometricMesh.index R η), |
| if (E.coldLabel k a n).annulus < F.indices (E.indices n) then |
| (JetLattice.spatialEnlargement s₀ η (S.radius (E.indices n)*t) (E.coldLabel k a n)).indicator |
| (fun _ => (F.approximation (E.indices n)).cold (E.coldLabel k a n) |
| (S.radius (E.indices n)*t,(JetPeriodicDatum.spatialMap (S.radius (E.indices n) • x),v))) |
| (S.radius (E.indices n) • x) |
| else 0 := by |
| classical |
| let r := S.radius (E.indices n) |
| let N := F.indices (E.indices n) |
| rw [(F.approximation (E.indices n)).centralTotal_finite_pairs hs₀ hsmax hη _ ht hx, |
| Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro a _ |
| let f : ℕ → ℝ := fun j => |
| (JetLattice.spatialEnlargement s₀ η (r*t) ⟨j,a,0⟩).indicator |
| (fun _ => (F.approximation (E.indices n)).cold ⟨j,a,0⟩ |
| (r*t,(JetPeriodicDatum.spatialMap (r • x),v))) (r • x) |
| have hsupp (j : ℕ) (_hj : j < N) (hf : f j ≠ 0) : |
| GeometricMesh.jetMeshIndex s₀ η r j ∈ |
| Finset.Icc (GeometricMesh.index (δ/Real.exp η) η) (GeometricMesh.index R η) := by |
| have hy : r • x ∈ JetLattice.spatialEnlargement s₀ η (r*t) ⟨j,a,0⟩ := by |
| by_contra h |
| exact hf (indicator_of_notMem h _) |
| have hz : JetLattice.transverseShift (0 : JetLattice.Lattice) = 0 := by |
| ext i |
| simp [JetLattice.transverseShift] |
| have hy₁ : transverse (r • x)-JetLattice.transverseShift 0 ∈ |
| JetGeometry.enlargement η (JetGeometry.jetScale s₀ η j) a := hy.1 |
| rw [hz,sub_zero] at hy₁ |
| have hs : r • transverse x ∈ JetGeometry.enlargement η (JetGeometry.jetScale s₀ η j) a := hy₁ |
| exact Finset.mem_Icc.mpr (JetGeometry.enlargement_mesh_window hs₀ hη (S.radius_pos hs₀ _) |
| hδ j a hs hlo hhi) |
| exact GeometricMesh.finite_sum_on_window s₀ η (fun m => S.radius (E.indices m)) n N |
| (GeometricMesh.index (δ/Real.exp η) η) (GeometricMesh.index R η) hU f hsupp |
|
|
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| /-! # Escaped cold mass vanishes on bounded positive-time dilation windows -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory Filter Set |
| open scoped ENNReal Topology |
| open BoltzmannNonuniqueness.VelocityWeight |
|
|
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence |
|
|
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} |
|
|
| def rescaledEscapedDensity (S : AttainedCapSequence F) (n : ℕ) |
| (z : Published.KineticPhase) : ℝ := |
| S.radius n*H q z.2*(F.approximation n).escapedTotal |
| ((S.radius n*z.1.1,S.radius n • z.1.2),z.2) |
|
|
| theorem rescaledEscapedDensity_measurable (S : AttainedCapSequence F) |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) |
| (hK : 0 ≤ K) (hd₀ : 0 ≤ d₀) (hq : q < 2) (n : ℕ) : |
| Measurable (S.rescaledEscapedDensity n) := by |
| have hm := (F.approximation n).escapedTotal_measurable hs₀ hsmax hη hηmax hK hd₀ hq |
| (shrinkingHorizon_pos F.horizonScale_pos n).le |
| exact (((ChartKernel.measurable_H q).comp measurable_snd).const_mul _).mul |
| (hm.comp (by fun_prop)) |
|
|
| theorem rescaledEscapedDensity_nonneg (S : AttainedCapSequence F) |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) |
| (hK : 0 ≤ K) (hd₀ : 0 ≤ d₀) (hq : q < 2) (n : ℕ) (z : Published.KineticPhase) : |
| 0 ≤ S.rescaledEscapedDensity n z := |
| mul_nonneg (mul_nonneg (S.radius_pos hs₀ n).le (H_nonneg q z.2)) |
| ((F.approximation n).escapedTotal_nonneg hs₀ hsmax hη hηmax hK hd₀ hq |
| (shrinkingHorizon_pos F.horizonScale_pos n).le _) |
|
|
| theorem eventually_rescaledEscapedDensity_bound (S : AttainedCapSequence F) |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) |
| (hK : 0 ≤ K) (hα : 0 ≤ α) (hαmax : α ≤ 1) (hγ : 0 ≤ γ) |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) |
| (hq : q < 2) {κ : ℕ → ℕ} (hκ : StrictMono κ) {U : ℝ≥0∞} |
| (hU : Tendsto (fun n => S.normalizedHorizon (κ n)) atTop (𝓝 U)) |
| {a A : ℝ} (ha : 0 < a) (hA : ENNReal.ofReal A < U) (R : ℝ) : |
| ∀ᶠ n in atTop, ∀ z : Published.KineticPhase, z.1.1 ∈ Icc a A → ‖z.1.2‖ ≤ R → |
| |S.rescaledEscapedDensity (κ n) z| ≤ |
| (JetEscapedEnvelope.constant s₀ η α K d₀ (JetEscapedEnvelope.exponent 0)* |
| S.radius (κ n))*H q z.2 := by |
| have hrlim : Tendsto (fun n => S.radius (κ n)*R) atTop (𝓝 0) := by |
| simpa only [Function.comp_def,zero_mul] using |
| ((S.radius_tendsto_zero hs₀).comp hκ.tendsto_atTop).mul_const R |
| have hr := hrlim.eventually |
| (gt_mem_nhds (show (0:ℝ) < 1 by norm_num)) |
| filter_upwards [hr,S.eventually_scaled_slab hs₀ hU hA] with n hn hslab |
| intro z ht hx |
| have hrpos := S.radius_pos hs₀ (κ n) |
| have hbound := (F.approximation (κ n)).escapedTotal_bound hs₀ hsmax hη hηmax hK hα hαmax hγ |
| hd₀ hd₀max hsmall hq (shrinkingHorizon_pos F.horizonScale_pos _).le |
| ((shrinkingHorizon_le F.horizonScale_pos _).trans F.horizonScale_le) 0 |
| (z := ((S.radius (κ n)*z.1.1,S.radius (κ n) • z.1.2),z.2)) |
| ⟨mul_pos hrpos (ha.trans_le ht.1),(hslab z.1.1 ⟨(ha.trans_le ht.1).le,ht.2⟩).2⟩ |
| (fun k => ?_) |
| · simp only [Real.rpow_zero,mul_one] at hbound |
| rw [abs_of_nonneg (S.rescaledEscapedDensity_nonneg hs₀ hsmax hη hηmax hK hd₀.le hq _ _)] |
| exact (mul_le_mul_of_nonneg_left hbound (mul_nonneg hrpos.le (H_nonneg q z.2))).trans_eq |
| (by ring) |
| · calc |
| |(S.radius (κ n) • z.1.2) k| = S.radius (κ n)*|z.1.2 k| := by |
| change |S.radius (κ n)*z.1.2 k| = _ |
| rw [abs_mul,abs_of_pos hrpos] |
| _ ≤ S.radius (κ n)*‖z.1.2‖ := mul_le_mul_of_nonneg_left |
| (by simpa only [Real.norm_eq_abs] using PiLp.norm_apply_le z.1.2 k) hrpos.le |
| _ ≤ S.radius (κ n)*R := mul_le_mul_of_nonneg_left hx hrpos.le |
| _ ≤ 1 := hn.le |
|
|
| def coldSlabSet (a A R : ℝ) : Set Published.KineticPhase := |
| (Icc a A ×ˢ Metric.closedBall (0 : Velocity) R) ×ˢ univ |
|
|
| def coldSlabVolume (a A R : ℝ) : Measure Published.KineticPhase := |
| ((volume.restrict (Icc a A)).prod (volume.restrict (Metric.closedBall (0 : Velocity) R))).prod volume |
|
|
| theorem coldSlabVolume_eq (a A R : ℝ) : |
| coldSlabVolume a A R = volume.restrict (coldSlabSet a A R) := by |
| rw [coldSlabVolume,Measure.prod_restrict,← Measure.volume_eq_prod, |
| Measure.restrict_prod_eq_prod_univ,← Measure.volume_eq_prod] |
| rfl |
|
|
| theorem rescaledEscapedDensity_tendsto_zero (S : AttainedCapSequence F) |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) |
| (hK : 0 ≤ K) (hα : 0 ≤ α) (hαmax : α ≤ 1) (hγ : 0 ≤ γ) |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) |
| (hq : q < 2) {κ : ℕ → ℕ} (hκ : StrictMono κ) {U : ℝ≥0∞} |
| (hU : Tendsto (fun n => S.normalizedHorizon (κ n)) atTop (𝓝 U)) |
| {a A : ℝ} (ha : 0 < a) (hA : ENNReal.ofReal A < U) (R : ℝ) : |
| Tendsto (fun n => eLpNorm (S.rescaledEscapedDensity (κ n)) 1 (coldSlabVolume a A R)) |
| atTop (𝓝 0) := by |
| let C := JetEscapedEnvelope.constant s₀ η α K d₀ (JetEscapedEnvelope.exponent 0) |
| let _ : IsFiniteMeasure ((volume : Measure Velocity).restrict (Metric.closedBall 0 R)) := |
| isFiniteMeasure_restrict.mpr (isCompact_closedBall (0 : Velocity) R).measure_lt_top.ne |
| have hi : Integrable (fun z : Published.KineticPhase => H q z.2) (coldSlabVolume a A R) := |
| (integrable_H hq).comp_snd _ |
| apply Compactness.tendsto_L1_of_vanishing_majorant |
| (fun n => (S.rescaledEscapedDensity_measurable hs₀ hsmax hη hηmax hK hd₀.le hq _).aestronglyMeasurable) |
| ((ChartKernel.measurable_H q).comp measurable_snd) hi (ae_of_all _ (fun z => H_nonneg q z.2)) |
| (c := fun n => C*S.radius (κ n)) |
| · simpa only [Function.comp_def,mul_zero] using |
| ((S.radius_tendsto_zero hs₀).comp hκ.tendsto_atTop).const_mul C |
| · filter_upwards [S.eventually_rescaledEscapedDensity_bound hs₀ hsmax hη hηmax hK hα hαmax hγ |
| hd₀ hd₀max hsmall hq hκ hU ha hA R] with n hn |
| rw [coldSlabVolume_eq] |
| filter_upwards [ae_restrict_mem ((measurableSet_Icc.prod measurableSet_closedBall).prod |
| MeasurableSet.univ)] with z hz |
| exact hn z hz.1.1 (by simpa only [Metric.mem_closedBall,dist_zero_right] using hz.1.2) |
|
|
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| /-! # The actual cold dilation has the same local limit as its central colors -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory Filter Set |
| open scoped ENNReal Topology |
| open BoltzmannNonuniqueness.VelocityWeight |
|
|
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence |
|
|
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} |
|
|
| def rescaledCentralDensity (S : AttainedCapSequence F) (n : ℕ) |
| (z : Published.KineticPhase) : ℝ := |
| S.radius n*H q z.2*(F.approximation n).centralTotal |
| ((S.radius n*z.1.1,S.radius n • z.1.2),z.2) |
|
|
| theorem rescaledCentralDensity_measurable (S : AttainedCapSequence F) |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) |
| (hK : 0 ≤ K) (hd₀ : 0 ≤ d₀) (hq : q < 2) (n : ℕ) : |
| Measurable (S.rescaledCentralDensity n) := by |
| have hm := (F.approximation n).centralTotal_measurable hs₀ hsmax hη hηmax hK hd₀ hq |
| (shrinkingHorizon_pos F.horizonScale_pos n).le |
| exact (((ChartKernel.measurable_H q).comp measurable_snd).const_mul _).mul |
| (hm.comp (by fun_prop)) |
|
|
| theorem rescaledCold_sub_central (S : AttainedCapSequence F) |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) |
| (hK : 0 ≤ K) (hd₀ : 0 ≤ d₀) (hq : q < 2) (n : ℕ) (z : Published.KineticPhase) : |
| S.rescaledColdDensity n ((z.1.1,JetPeriodicDatum.spatialMap z.1.2),z.2)- |
| S.rescaledCentralDensity n z = S.rescaledEscapedDensity n z := by |
| have h := (F.approximation n).coldTotal_eq_central_add_escaped hs₀ hsmax hη hηmax hK hd₀ hq |
| (shrinkingHorizon_pos F.horizonScale_pos n).le ((S.radius n*z.1.1,S.radius n • z.1.2),z.2) |
| have hmap : JetPeriodicDatum.spatialMap (S.radius n • z.1.2) = |
| S.radius n • JetPeriodicDatum.spatialMap z.1.2 := rfl |
| change S.radius n*H q z.2*(F.approximation n).coldTotal |
| (S.radius n*z.1.1,(S.radius n • JetPeriodicDatum.spatialMap z.1.2,z.2))- |
| S.radius n*H q z.2*(F.approximation n).centralTotal |
| ((S.radius n*z.1.1,S.radius n • z.1.2),z.2) = |
| S.radius n*H q z.2*(F.approximation n).escapedTotal |
| ((S.radius n*z.1.1,S.radius n • z.1.2),z.2) |
| rw [← hmap,h] |
| ring |
|
|
| theorem cold_central_difference_tendsto_zero (S : AttainedCapSequence F) |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) |
| (hK : 0 ≤ K) (hα : 0 ≤ α) (hαmax : α ≤ 1) (hγ : 0 ≤ γ) |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) |
| (hq : q < 2) {κ : ℕ → ℕ} (hκ : StrictMono κ) {U : ℝ≥0∞} |
| (hU : Tendsto (fun n => S.normalizedHorizon (κ n)) atTop (𝓝 U)) |
| {a A : ℝ} (ha : 0 < a) (hA : ENNReal.ofReal A < U) (R : ℝ) : |
| Tendsto (fun n => eLpNorm (fun z : Published.KineticPhase => |
| S.rescaledColdDensity (κ n) ((z.1.1,JetPeriodicDatum.spatialMap z.1.2),z.2)- |
| S.rescaledCentralDensity (κ n) z) 1 (coldSlabVolume a A R)) atTop (𝓝 0) := by |
| simp_rw [S.rescaledCold_sub_central hs₀ hsmax hη hηmax hK hd₀.le hq] |
| exact S.rescaledEscapedDensity_tendsto_zero hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max |
| hsmall hq hκ hU ha hA R |
|
|
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| /-! # The actual escaped cold density is uniformly bounded in every cell -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory Set |
| open scoped ENNReal |
| open BoltzmannNonuniqueness.JetLattice BoltzmannNonuniqueness.JetGeometry |
| open BoltzmannNonuniqueness.JetPrototype BoltzmannNonuniqueness.VelocityWeight |
|
|
| namespace BoltzmannNonuniqueness.JetCopyDatum |
|
|
| theorem escaped_bound_global {s₀ η K α γ d₀ t : ℝ} (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) |
| (hη : 0 < η) (hηmax : η ≤ Real.log 2) (hK : 0 ≤ K) (hα : 0 ≤ α) (hαmax : α ≤ 1) |
| (hγ : 0 ≤ γ) (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) (ht : 0 < t) (htmax : t ≤ 1/32) |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) (A q : ℝ) (N : ℕ) |
| (f : Label → ℝ) (x v : Velocity) |
| (hf : ∀ i, 0 ≤ f i) (hfs : Summable f) |
| (hfU : ∀ i, i.annulus < N → f i ≤ JetSupersolution.U η K α γ |
| (jetScale s₀ η i.annulus) (d₀*jetScale s₀ η i.annulus^10) t i.positive |
| (JetSpatialBox.shifted x i.lattice,v)) : |
| (∑' i, escaped s₀ η t N x f i) ≤ |
| JetEscapedEnvelope.constant s₀ η α K d₀ (JetEscapedEnvelope.exponent A)*t^A*VelocityWeight.H q v := by |
| classical |
| have hnon (i) : 0 ≤ escaped s₀ η t N x f i := by |
| unfold escaped |
| split_ifs |
| · exact hf i |
| · exact le_rfl |
| have hle (i) : escaped s₀ η t N x f i ≤ f i := by |
| unfold escaped |
| split_ifs |
| · exact le_rfl |
| · exact hf i |
| have hsum : Summable (escaped s₀ η t N x f) := Summable.of_nonneg_of_le hnon hle hfs |
| have h := JetEscapedEnvelope.real_power_global hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max |
| ht htmax hsmall A q (fun j _ _ => j < N) (fun j a n => f ⟨j,a,n⟩) x v |
| (fun j a n hj => hfU ⟨j,a,n⟩ hj) |
| have he : (∑' i, ENNReal.ofReal (escaped s₀ η t N x f i)) = |
| JetEscapedEnvelope.escapedSum s₀ η t x (fun j _ _ => j < N) (fun j a n => f ⟨j,a,n⟩) := by |
| rw [tsum_labels] |
| unfold escaped JetEscapedEnvelope.escapedSum |
| simp only [Set.indicator_apply,Set.mem_ofPred_eq,apply_ite ENNReal.ofReal,ENNReal.ofReal_zero] |
| rw [← he, ← ENNReal.ofReal_tsum_of_nonneg hnon hsum] at h |
| have hB : 0 ≤ JetEscapedEnvelope.constant s₀ η α K d₀ (JetEscapedEnvelope.exponent A)* |
| t^A*VelocityWeight.H q v := by |
| have hc := JetEscapedEnvelope.constant_nonneg hs₀ hK hd₀ η α (JetEscapedEnvelope.exponent A) |
| exact mul_nonneg (mul_nonneg hc (Real.rpow_nonneg ht.le A)) (VelocityWeight.H_nonneg q v) |
| simpa only [ENNReal.toReal_ofReal (tsum_nonneg hnon),ENNReal.toReal_ofReal hB] using |
| ENNReal.toReal_mono ENNReal.ofReal_ne_top h |
|
|
| theorem normalized_escaped_bound_global {s₀ η K α γ d₀ t : ℝ} |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) |
| (hK : 0 ≤ K) (hα : 0 ≤ α) (hαmax : α ≤ 1) (hγ : 0 ≤ γ) |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) (ht : 0 < t) (htmax : t ≤ 1/32) |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) (A q : ℝ) (N : ℕ) |
| (f : Label → ℝ) (x v : Velocity) |
| (hf : ∀ i, 0 ≤ f i) (hfs : Summable f) |
| (hfU : ∀ i, i.annulus < N → VelocityWeight.H q v*f i ≤ JetSupersolution.U η K α γ |
| (jetScale s₀ η i.annulus) (d₀*jetScale s₀ η i.annulus^10) t i.positive |
| (JetSpatialBox.shifted x i.lattice,v)) : |
| (∑' i, escaped s₀ η t N x f i) ≤ |
| JetEscapedEnvelope.constant s₀ η α K d₀ (JetEscapedEnvelope.exponent A)*t^A := by |
| have h := escaped_bound_global hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max ht htmax hsmall A q N |
| (fun i => VelocityWeight.H q v*f i) x v |
| (fun i => mul_nonneg (VelocityWeight.H_nonneg q v) (hf i)) |
| (hfs.mul_left (VelocityWeight.H q v)) hfU |
| have he (i) : escaped s₀ η t N x (fun j => VelocityWeight.H q v*f j) i = |
| VelocityWeight.H q v*escaped s₀ η t N x f i := by |
| unfold escaped |
| split_ifs <;> simp only [mul_zero] |
| simp_rw [he] at h |
| rw [tsum_mul_left] at h |
| have hh : VelocityWeight.H q v*(∑' i, escaped s₀ η t N x f i) ≤ |
| VelocityWeight.H q v*(JetEscapedEnvelope.constant s₀ η α K d₀ (JetEscapedEnvelope.exponent A)*t^A) := |
| h.trans_eq (mul_comm _ _) |
| exact (mul_le_mul_iff_of_pos_left (VelocityWeight.H_pos q v)).mp hh |
|
|
| theorem CapApproximation.escapedTotal_bound_global {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) (hα : 0 ≤ α) (hαmax : α ≤ 1) (hγ : 0 ≤ γ) |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) |
| (hq : q < 2) (hT : 0 ≤ T) (hTmax : T ≤ 1/32) |
| (A : ℝ) {z : Published.KineticPhase} (ht : z.1.1 ∈ Ioc 0 T) : |
| F.escapedTotal z ≤ JetEscapedEnvelope.constant s₀ η α K d₀ |
| (JetEscapedEnvelope.exponent A)*z.1.1^A := by |
| have hc := F.cold_properties hs₀ hsmax hη hηmax hK hd₀.le hq hT |
| let f : JetLattice.Label → ℝ := fun j => F.cold j (z.1.1,(JetPeriodicDatum.spatialMap z.1.2,z.2)) |
| have hfs : Summable f := |
| ((F.coldTotal_properties hs₀ hsmax hη hηmax hK hd₀.le hq hT).2 _).1 |
| have henv (i : JetLattice.Label) : H q z.2*f i ≤ |
| JetSupersolution.U η K α γ (JetGeometry.jetScale s₀ η i.annulus) |
| (d₀*JetGeometry.jetScale s₀ η i.annulus^10) z.1.1 i.positive |
| (JetSpatialBox.shifted z.1.2 i.lattice,z.2) := by |
| have he : (JetSpatialBox.shifted z.1.2 i.lattice,z.2) = |
| WeightedTranslation.shift (displacement i.lattice) (JetPeriodicDatum.spatialMap z.1.2,z.2) := rfl |
| rw [he] |
| exact F.cold_envelope hs₀ hsmax hη hηmax hK hα hγ hd₀ hsmall hq hT hTmax i ht |
| (JetPeriodicDatum.spatialMap z.1.2,z.2) |
| have hb := normalized_escaped_bound_global (γ := γ) hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max ht.1 |
| (ht.2.trans hTmax) hsmall A q N f z.1.2 z.2 |
| (fun i => hc.2.1 i _) hfs (fun i _ => henv i) |
| exact hb |
|
|
| end BoltzmannNonuniqueness.JetCopyDatum |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| /-! # Global almost-everywhere majorants in the Euclidean averaging coordinates -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory Filter Set |
| open scoped Topology ENNReal |
| open BoltzmannNonuniqueness.WeightedLocal BoltzmannNonuniqueness.VelocityWeight |
|
|
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence |
|
|
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} |
|
|
| theorem euclideanHot_measurable (S : AttainedCapSequence F) |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) |
| (hK : 0 ≤ K) (hd₀ : 0 ≤ d₀) (hq : q < 2) (n : ℕ) : |
| Measurable (S.euclideanHot n) := |
| EuclideanFlight.density_measurable (S.normalizedHot_measurable hs₀ hsmax hη hηmax hK hd₀ hq n) q |
|
|
| theorem euclideanHotSource_measurable (S : AttainedCapSequence F) |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) |
| (hK : 0 ≤ K) (hd₀ : 0 ≤ d₀) (hq : q < 2) (n : ℕ) : |
| Measurable (S.euclideanHotSource n) := by |
| have hm := (F.approximation n).hotNetSource_measurable hs₀ hsmax hη hηmax hK hd₀ hq |
| (shrinkingHorizon_pos F.horizonScale_pos n).le |
| have hk : Measurable (fun z : Published.KineticPhase => |
| (S.radius n*z.1.1,PositiveIntegral.scalePhase (S.radius n) (EuclideanFlight.phaseEquiv (z.1.2,z.2)))) := by |
| have hp : Measurable (fun z : Published.KineticPhase => EuclideanFlight.phaseEquiv (z.1.2,z.2)) := |
| EuclideanFlight.phaseEquiv.measurable.comp (measurable_fst.snd.prodMk measurable_snd) |
| unfold PositiveIntegral.scalePhase |
| have hs : Measurable (fun z : Published.KineticPhase => |
| S.radius n • (EuclideanFlight.phaseEquiv (z.1.2,z.2)).1) := by |
| have hc : Measurable (fun _ : Published.KineticPhase => S.radius n) := measurable_const |
| exact hc.smul hp.fst |
| exact (measurable_fst.fst.const_mul _).prodMk (hs.prodMk hp.snd) |
| exact ((ChartKernel.measurable_H q).comp measurable_snd).mul (hm.comp hk) |
|
|
| theorem eventually_euclideanHot_bound (S : AttainedCapSequence F) |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) |
| (hK : 0 ≤ K) (hd₀ : 0 ≤ d₀) (hq : q < 2) {κ : ℕ → ℕ} {U : ℝ≥0∞} |
| (hU : Tendsto (fun n => S.normalizedHorizon (κ n)) atTop (𝓝 U)) |
| {A : ℝ} (hA : ENNReal.ofReal A < U) : |
| ∀ᶠ n in atTop, ∀ᵐ z ∂(volume : Measure Published.KineticPhase), z.1.1 ∈ Icc 0 A → |
| 0 ≤ S.euclideanHot (κ n) z ∧ S.euclideanHot (κ n) z ≤ (A+1)*H q z.2 := by |
| filter_upwards [S.eventually_scaled_slab hs₀ hU hA] with n hslab |
| let Fn := F.approximation (κ n) |
| have hr := S.radius_pos hs₀ (κ n) |
| have hcap := Fn.hot_spacetime_cap hs₀ hsmax hη hηmax hK hd₀ hq |
| (shrinkingHorizon_pos F.horizonScale_pos _).le |
| have hn := (Fn.hot_properties hs₀ hsmax hη hηmax hK hd₀ hq |
| (shrinkingHorizon_pos F.horizonScale_pos _).le).2.1 |
| have hp := (ColdDilationMeasure.spacetime_dilation_quasiMeasurePreserving hr).ae hcap |
| filter_upwards [EuclideanFlight.kineticMap_measurePreserving.quasiMeasurePreserving.ae hp] |
| with z hz ht |
| have hb := hz (hslab z.1.1 ht) |
| have hδ : DatumBounds.scale s₀ η (F.indices (κ n)+1) ≤ S.radius (κ n) := by |
| dsimp [radius] |
| linarith [(S.time_mem (κ n)).1] |
| have hu : S.normalizedHot (κ n) (EuclideanFlight.kineticMap z) ≤ A+1 := by |
| apply (div_le_iff₀ hr).mpr |
| have ht' := mul_le_mul_of_nonneg_left ht.2 hr.le |
| change Fn.hot (S.radius (κ n)*z.1.1, |
| (S.radius (κ n) • (EuclideanFlight.phaseEquiv (z.1.2,z.2)).1,z.2)) ≤ |
| S.radius (κ n)*z.1.1+DatumBounds.scale s₀ η (F.indices (κ n)+1) at hb |
| change Fn.hot (S.radius (κ n)*z.1.1, |
| (S.radius (κ n) • (EuclideanFlight.phaseEquiv (z.1.2,z.2)).1,z.2)) ≤ _ |
| nlinarith |
| have hl : 0 ≤ S.normalizedHot (κ n) (EuclideanFlight.kineticMap z) := div_nonneg (hn _) hr.le |
| change 0 ≤ H q z.2*S.normalizedHot (κ n) (EuclideanFlight.kineticMap z) ∧ |
| H q z.2*S.normalizedHot (κ n) (EuclideanFlight.kineticMap z) ≤ (A+1)*H q z.2 |
| exact ⟨mul_nonneg (H_nonneg q z.2) hl, |
| (mul_le_mul_of_nonneg_left hu (H_nonneg q z.2)).trans_eq (mul_comm _ _)⟩ |
|
|
| theorem eventually_euclideanHotSource_bound (hcarleman : Published.GPV2009CarlemanInput) |
| (S : AttainedCapSequence F) |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) |
| (hK : 0 ≤ K) (hα : 0 < α) (hαmax : α ≤ 1) (hγ : 0 < γ) |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) |
| (hq₁ : 1 < q) (hq₂ : q < 2) {κ : ℕ → ℕ} (hκ : StrictMono κ) {U : ℝ≥0∞} |
| (hU : Tendsto (fun n => S.normalizedHorizon (κ n)) atTop (𝓝 U)) |
| {a A : ℝ} (ha : 0 < a) (haA : a ≤ A) (hA : ENNReal.ofReal A < U) : |
| ∀ᶠ n in atTop, ∀ᵐ z ∂(volume : Measure Published.KineticPhase), z.1.1 ∈ Icc a A → |
| |S.euclideanHotSource (κ n) z| ≤ sourceEnvelope s₀ η K α γ d₀ q a A z.2*H q z.2 := by |
| filter_upwards [S.eventually_rescaledHotSource_abs hcarleman hs₀ hsmax hη hηmax hK hα |
| hαmax hγ hd₀ hd₀max hsmall hq₁ hq₂ hκ hU ha haA hA] with n hn |
| filter_upwards [EuclideanFlight.kineticMap_measurePreserving.quasiMeasurePreserving.ae hn] |
| with z hz ht |
| change |H q z.2*S.rescaledHotSource (κ n) (EuclideanFlight.kineticMap z)| ≤ _ |
| rw [abs_mul,abs_of_nonneg (H_nonneg q z.2)] |
| exact (mul_le_mul_of_nonneg_left (hz ht) (H_nonneg q z.2)).trans_eq (mul_comm _ _) |
|
|
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| /-! # Uniform positive-time bounds for the actual cold-label averages -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology |
| open BoltzmannNonuniqueness.VelocityWeight BoltzmannNonuniqueness.VelocityMoment |
|
|
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence |
|
|
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} |
| {S : AttainedCapSequence F} |
|
|
| theorem HotLimitExtraction.coldLabelDensity_le_total (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) (v : Velocity) : |
| E.coldLabelDensity k a n t (x,v) ≤ S.rescaledColdDensity (E.indices n) ((t,x),v) := by |
| have hc := (F.approximation (E.indices n)).cold_properties hs₀ hsmax hη hηmax hK hd₀ hq |
| (shrinkingHorizon_pos F.horizonScale_pos _).le |
| let u := (S.radius (E.indices n)*t,(S.radius (E.indices n) • x,v)) |
| have hs := ((F.approximation (E.indices n)).coldTotal_properties hs₀ hsmax hη hηmax hK hd₀ hq |
| (shrinkingHorizon_pos F.horizonScale_pos _).le).2 u |
| have hb := hs.1.le_tsum (E.coldLabel k a n) (fun i _ => hc.2.1 i u) |
| have hp := mul_le_mul_of_nonneg_left hb |
| (mul_nonneg (S.radius_pos hs₀ (E.indices n)).le (H_nonneg q v)) |
| convert! hp using 1 |
| · simp only [coldLabelDensity,mul_assoc,u] |
|
|
| theorem HotLimitExtraction.eventually_coldLabelAverage_bound (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) (hγ : 0 < γ) |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) (hq : q < 2) |
| {a A B : ℝ} (ha : 0 < a) (hA : ENNReal.ofReal A < E.horizon) (hB : 0 ≤ B) |
| {ψ : Velocity → ℝ} (hψB : ∀ v, |ψ v| ≤ B) : |
| ∀ᶠ n in atTop, ∀ t ∈ Icc a A, ∀ k σ x, |
| |E.coldLabelAverage k σ n t ψ x| ≤ B* |
| (escapedConstant s₀ η K α d₀*hotConstant q+JetEnvelopeGain.momentConstant K α γ/a) := by |
| have hM := S.eventually_rescaledColdDensity_moment hs₀ hsmax hη hηmax hK hα hαmax hγ |
| hd₀ hd₀max hsmall hq E.indices_strict E.horizon_limit ha hA |
| filter_upwards [hM] with n hn |
| intro t ht k σ x |
| have hnon (v) := (E.coldLabelDensity_bounds hs₀ hsmax hη hηmax hK hd₀.le hq k σ n t (x,v)).1 |
| have hm : Measurable (fun v => E.coldLabelDensity k σ n t (x,v)) := |
| (E.coldLabelDensity_measurable hs₀ hsmax hη hηmax hK hd₀.le hq k σ n t).comp |
| (measurable_const.prodMk measurable_id) |
| have hmom : VelocityMoment.moment (fun v => E.coldLabelDensity k σ n t (x,v)) ≤ |
| ENNReal.ofReal (escapedConstant s₀ η K α d₀*hotConstant q+ |
| JetEnvelopeGain.momentConstant K α γ/a) := by |
| apply le_trans _ (hn t ht x) |
| apply lintegral_mono |
| intro v |
| apply ENNReal.ofReal_le_ofReal |
| exact mul_le_mul_of_nonneg_left |
| (E.coldLabelDensity_le_total hs₀ hsmax hη hηmax hK hd₀.le hq k σ n t x v) |
| (VelocityMoment.weight_pos v).le |
| have hM0 : 0 ≤ escapedConstant s₀ η K α d₀*hotConstant q+ |
| JetEnvelopeGain.momentConstant K α γ/a := add_nonneg |
| (mul_nonneg (JetEscapedEnvelope.constant_nonneg hs₀ hK hd₀ η α _) (hotConstant_nonneg q)) |
| (div_nonneg (JetEnvelopeGain.momentConstant_nonneg hK α γ) ha.le) |
| exact VelocityMoment.average_le_of_moment_bound hm hnon hB hM0 hmom hψB |
|
|
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| /-! # Joint regularity and uniform bounds for the full cold velocity averages -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory Set Filter |
| open scoped ENNReal Topology |
| open BoltzmannNonuniqueness.VelocityWeight BoltzmannNonuniqueness.VelocityMoment |
|
|
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence |
|
|
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} |
|
|
| def coldAverage (S : AttainedCapSequence F) (n : ℕ) (ψ : Velocity → ℝ) |
| (x : ℝ × JetPrototype.Space) : ℝ := |
| ∫ v, ψ v*S.rescaledColdDensity n (x,v) |
|
|
| theorem coldAverage_measurable (S : AttainedCapSequence F) |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) |
| (hK : 0 ≤ K) (hd₀ : 0 ≤ d₀) (hq : q < 2) (n : ℕ) |
| {ψ : Velocity → ℝ} (hψ : Measurable ψ) : Measurable (S.coldAverage n ψ) := by |
| have hm := (hψ.comp measurable_snd).mul |
| (S.rescaledColdDensity_measurable hs₀ hsmax hη hηmax hK hd₀ hq n) |
| exact hm.stronglyMeasurable.integral_prod_right'.measurable |
|
|
| theorem coldAverage_global_bound (S : AttainedCapSequence F) |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) |
| (hK : 0 ≤ K) (hd₀ : 0 ≤ d₀) (hq : q < 2) (n : ℕ) |
| {B : ℝ} {ψ : Velocity → ℝ} (hψB : ∀ v, |ψ v| ≤ B) (x : ℝ × JetPrototype.Space) : |
| |S.coldAverage n ψ x| ≤ |
| (B*(S.radius n*(2*(F.approximation n).amplitude)))*(∫ v, H q v) := by |
| have hB : 0 ≤ B := (abs_nonneg (ψ 0)).trans (hψB 0) |
| have hb := norm_integral_le_of_norm_le |
| (f := fun v => ψ v*S.rescaledColdDensity n (x,v)) |
| ((integrable_H hq).const_mul (B*(S.radius n*(2*(F.approximation n).amplitude)))) ?_ |
| · simpa only [Real.norm_eq_abs,integral_const_mul,coldAverage] using hb |
| · filter_upwards [] with v |
| have hd := S.rescaledColdDensity_bounds hs₀ hsmax hη hηmax hK hd₀ hq n (x,v) |
| rw [Real.norm_eq_abs,abs_mul,abs_of_nonneg hd.1] |
| exact (mul_le_mul (hψB v) hd.2 hd.1 hB).trans_eq (by ring) |
|
|
| theorem coldAverage_integrable (S : AttainedCapSequence F) |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) |
| (hK : 0 ≤ K) (hd₀ : 0 ≤ d₀) (hq : q < 2) (n : ℕ) |
| {B : ℝ} {ψ : Velocity → ℝ} (hψ : Measurable ψ) (hψB : ∀ v, |ψ v| ≤ B) |
| (ρ : Measure (ℝ × JetPrototype.Space)) [IsFiniteMeasure ρ] : |
| Integrable (S.coldAverage n ψ) ρ := |
| Integrable.of_bound (S.coldAverage_measurable hs₀ hsmax hη hηmax hK hd₀ hq n hψ).aestronglyMeasurable |
| _ (ae_of_all _ (S.coldAverage_global_bound hs₀ hsmax hη hηmax hK hd₀ hq n hψB)) |
|
|
| theorem HotLimitExtraction.eventually_coldAverage_bound {S : AttainedCapSequence F} |
| (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) (hγ : 0 < γ) |
| (hd₀ : 0 < d₀) (hd₀max : d₀ ≤ 1) |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) (hq : q < 2) |
| {a A B : ℝ} (ha : 0 < a) (hA : ENNReal.ofReal A < E.horizon) (hB : 0 ≤ B) |
| {ψ : Velocity → ℝ} (hψB : ∀ v, |ψ v| ≤ B) : |
| ∀ᶠ n in atTop, ∀ t ∈ Icc a A, ∀ x, |
| |S.coldAverage (E.indices n) ψ (t,x)| ≤ B* |
| (escapedConstant s₀ η K α d₀*hotConstant q+JetEnvelopeGain.momentConstant K α γ/a) := by |
| filter_upwards [S.eventually_rescaledColdDensity_moment hs₀ hsmax hη hηmax hK hα hαmax hγ |
| hd₀ hd₀max hsmall hq E.indices_strict E.horizon_limit ha hA] with n hn |
| intro t ht x |
| have hm : Measurable (fun v => S.rescaledColdDensity (E.indices n) ((t,x),v)) := |
| (S.rescaledColdDensity_measurable hs₀ hsmax hη hηmax hK hd₀.le hq (E.indices n)).comp |
| (measurable_const.prodMk measurable_id) |
| have hM0 : 0 ≤ escapedConstant s₀ η K α d₀*hotConstant q+ |
| JetEnvelopeGain.momentConstant K α γ/a := add_nonneg |
| (mul_nonneg (JetEscapedEnvelope.constant_nonneg hs₀ hK hd₀ η α _) (hotConstant_nonneg q)) |
| (div_nonneg (JetEnvelopeGain.momentConstant_nonneg hK α γ) ha.le) |
| exact average_le_of_moment_bound hm |
| (fun v => (S.rescaledColdDensity_bounds hs₀ hsmax hη hηmax hK hd₀.le hq _ ((t,x),v)).1) |
| hB hM0 (hn t ht x) hψB |
|
|
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| /-! # Joint time-space regularity of actual cold-label velocity averages -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory |
| open BoltzmannNonuniqueness.VelocityWeight |
|
|
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence |
|
|
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} |
| {S : AttainedCapSequence F} |
|
|
| theorem HotLimitExtraction.coldLabelDensity_joint_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 : ℕ) : |
| Measurable (fun z : (ℝ × JetPrototype.Space) × Velocity => |
| E.coldLabelDensity k a n z.1.1 (z.1.2,z.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 hp : Measurable (fun z : (ℝ × JetPrototype.Space) × Velocity => |
| (S.radius (E.indices n)*z.1.1,(S.radius (E.indices n) • z.1.2,z.2))) := by fun_prop |
| exact (((ChartKernel.measurable_H q).comp measurable_snd).mul |
| ((hc.1 (E.coldLabel k a n)).comp hp)).const_mul _ |
|
|
| theorem HotLimitExtraction.coldLabelAverage_joint_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 : ℕ) |
| {ψ : Velocity → ℝ} (hψ : Measurable ψ) : |
| Measurable (fun z : ℝ × JetPrototype.Space => E.coldLabelAverage k a n z.1 ψ z.2) := by |
| have hm := (hψ.comp measurable_snd).mul |
| (E.coldLabelDensity_joint_measurable hs₀ hsmax hη hηmax hK hd₀ hq k a n) |
| exact hm.stronglyMeasurable.integral_prod_right'.measurable |
|
|
| theorem HotLimitExtraction.coldLabelAverage_global_bound (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 : ℕ) |
| {B : ℝ} {ψ : Velocity → ℝ} (hψB : ∀ v, |ψ v| ≤ B) |
| (t : ℝ) (x : JetPrototype.Space) : |
| |E.coldLabelAverage k a n t ψ x| ≤ |
| (B*(S.radius (E.indices n)*(2*(F.approximation (E.indices n)).amplitude)))*(∫ v, H q v) := by |
| have hB : 0 ≤ B := (abs_nonneg (ψ 0)).trans (hψB 0) |
| have hb := norm_integral_le_of_norm_le |
| (f := fun v => ψ v*E.coldLabelDensity k a n t (x,v)) |
| ((integrable_H hq).const_mul (B*(S.radius (E.indices n)*(2*(F.approximation (E.indices n)).amplitude)))) ?_ |
| · simpa only [Real.norm_eq_abs,integral_const_mul,coldLabelAverage] using hb |
| · filter_upwards [] with v |
| have hd := E.coldLabelDensity_bounds hs₀ hsmax hη hηmax hK hd₀ hq k a n t (x,v) |
| rw [Real.norm_eq_abs,abs_mul,abs_of_nonneg hd.1] |
| exact (mul_le_mul (hψB v) hd.2 hd.1 hB).trans_eq (by ring) |
|
|
| theorem HotLimitExtraction.coldLabelAverage_joint_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 : ℕ) |
| {B : ℝ} {ψ : Velocity → ℝ} (hψ : Measurable ψ) (hψB : ∀ v, |ψ v| ≤ B) |
| (ρ : Measure (ℝ × JetPrototype.Space)) [IsFiniteMeasure ρ] : |
| Integrable (fun z => E.coldLabelAverage k a n z.1 ψ z.2) ρ := |
| Integrable.of_bound |
| (E.coldLabelAverage_joint_measurable hs₀ hsmax hη hηmax hK hd₀ hq k a n hψ).aestronglyMeasurable |
| _ (ae_of_all _ (fun z => E.coldLabelAverage_global_bound hs₀ hsmax hη hηmax hK hd₀ hq k a n hψB z.1 z.2)) |
|
|
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| /-! # A finite window of actual cold labels -/ |
|
|
| 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.meshLabels (E : HotLimitExtraction S) (n : ℕ) (L U : ℤ) : Finset JetLattice.Label := |
| ((Finset.Icc L U).product (Finset.univ : Finset Bool)).image (fun p => E.coldLabel p.1 p.2 n) |
|
|
| def HotLimitExtraction.meshCold (E : HotLimitExtraction S) (n : ℕ) (L U : ℤ) |
| (u : ℝ × JetPrototype.Phase) : ℝ := |
| ∑ i ∈ E.meshLabels n L U, if i.annulus < F.indices (E.indices n) then |
| (F.approximation (E.indices n)).cold i u else 0 |
|
|
| theorem HotLimitExtraction.meshCold_sum (E : HotLimitExtraction S) (n : ℕ) (L U : ℤ) |
| (hU : U < GeometricMesh.index (s₀/S.radius (E.indices n)) η) (u : ℝ × JetPrototype.Phase) : |
| E.meshCold n L U u = ∑ a : Bool, ∑ k ∈ Finset.Icc L U, |
| if (E.coldLabel k a n).annulus < F.indices (E.indices n) then |
| (F.approximation (E.indices n)).cold (E.coldLabel k a n) u else 0 := by |
| classical |
| unfold meshCold meshLabels |
| rw [Finset.sum_image] |
| · exact (Finset.sum_product _ _ _).trans Finset.sum_comm |
| · intro p hp q hq he |
| have hj := congrArg JetLattice.Label.annulus he |
| have ha := congrArg JetLattice.Label.positive he |
| have hpU := (Finset.mem_Icc.mp (Finset.mem_product.mp hp).1).2.trans_lt hU |
| have hqU := (Finset.mem_Icc.mp (Finset.mem_product.mp hq).1).2.trans_lt hU |
| have hh := congrArg (GeometricMesh.jetMeshIndex s₀ η (S.radius (E.indices n))) hj |
| change GeometricMesh.jetMeshIndex s₀ η (S.radius (E.indices n)) |
| (GeometricMesh.jetIndex s₀ η (fun m => S.radius (E.indices m)) p.1 n) = |
| GeometricMesh.jetMeshIndex s₀ η (S.radius (E.indices n)) |
| (GeometricMesh.jetIndex s₀ η (fun m => S.radius (E.indices m)) q.1 n) at hh |
| rw [GeometricMesh.meshIndex_at_jetIndex s₀ η (fun m => S.radius (E.indices m)) n hpU, |
| GeometricMesh.meshIndex_at_jetIndex s₀ η (fun m => S.radius (E.indices m)) n hqU] at hh |
| exact Prod.ext hh ha |
|
|
| theorem HotLimitExtraction.meshCold_le_total (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) |
| (n : ℕ) (L U : ℤ) (u : ℝ × JetPrototype.Phase) : |
| E.meshCold n L U u ≤ (F.approximation (E.indices n)).coldTotal u := by |
| classical |
| have hc := (F.approximation (E.indices n)).cold_properties hs₀ hsmax hη hηmax hK hd₀ hq |
| (shrinkingHorizon_pos F.horizonScale_pos _).le |
| have hs := ((F.approximation (E.indices n)).coldTotal_properties hs₀ hsmax hη hηmax hK hd₀ hq |
| (shrinkingHorizon_pos F.horizonScale_pos _).le).2 u |
| apply (Finset.sum_le_sum (s := E.meshLabels n L U) (fun i _ => ?_)).trans |
| (hs.1.sum_le_tsum _ (fun i _ => hc.2.1 i u)) |
| by_cases hi : i.annulus < F.indices (E.indices n) |
| · exact (ite_eq_left hi).le |
| · rw [ite_eq_right hi] |
| exact hc.2.1 i u |
|
|
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence |
|
|
| end |
|
|
| end |
|
|
| end OAI |
|
|
