openAI-math-dataset / lean /OAI /MathematicalPhysics /Boltzmann /Approximation /CapLabelFreeLimit.lean
| import OAI.MathematicalPhysics.Boltzmann.Approximation.CapDilationCompactness | |
| import OAI.MathematicalPhysics.Boltzmann.Approximation.CappedDensitySequence | |
| import OAI.MathematicalPhysics.Boltzmann.Approximation.MildCharacteristics | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.HotWindowInput | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.MarginalUniformIntegrability | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.WeakL1Operations | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.WeakTimeSurvival | |
| import OAI.MathematicalPhysics.Boltzmann.Jets.ColdMildRepresentative | |
| import OAI.MathematicalPhysics.Boltzmann.Jets.GeometricColdSource | |
| import OAI.MathematicalPhysics.Boltzmann.Jets.GeometricMesh | |
| import OAI.MathematicalPhysics.Boltzmann.Jets.JetCoreConvergence | |
| import OAI.MathematicalPhysics.Boltzmann.Jets.JetFamilyBounds | |
| import OAI.MathematicalPhysics.Boltzmann.Jets.JetContinuation | |
| namespace OAI | |
| section | |
| /-! # Actual weak hot limits on bounded spacetime windows -/ | |
| 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} | |
| theorem exists_hot_weak_limit (hDP : Published.DunfordPettis1940HotWindows) | |
| (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) (κ : ℕ → ℕ) | |
| {A R : ℝ} (hA : 0 ≤ A) (hR : 0 ≤ R) : | |
| ∃ (φ : ℕ → ℕ) (g : HotKineticPhase → ℝ), StrictMono φ ∧ | |
| Published.WeakL1Converges (hotWindowVolume A R) | |
| (fun n => S.hotDensity (κ (φ n))) g ∧ | |
| (∀ᵐ z ∂hotWindowVolume A R, 0 ≤ g z) ∧ | |
| (∀ᵐ z ∂hotWindowVolume A R, g z ≤ (A+1)*H q z.2) := by | |
| have hui := S.hotDensity_uniformIntegrable hs₀ hsmax hη hηmax hK hd₀ hq A R | |
| obtain ⟨φ,g,hφ,hg⟩ := hDP A R hA hR (fun n => S.hotDensity (κ n)) | |
| (fun n => S.hotDensity_measurable hs₀ hsmax hη hηmax hK hd₀ hq (κ n)) | |
| (Compactness.uniformIntegrable_comp hui κ) | |
| ((S.hotDensity_unifTight hs₀ hsmax hη hηmax hK hd₀ hq hA R).comp κ) | |
| refine ⟨φ,g,hφ,hg,?_,?_⟩ | |
| · exact hg.nonneg (fun n => ae_of_all _ | |
| (S.hotDensity_nonneg hs₀ hsmax hη hηmax hK hd₀ hq (κ (φ n)))) | |
| · exact hg.le (fun n => memLp_one_iff_integrable.mp (hui.memLp (κ (φ n)))) | |
| (((ChartKernel.measurable_H q).comp measurable_snd).const_mul _) | |
| (hot_majorant_integrable hq A R) | |
| (fun n => S.hotDensity_bound hs₀ hsmax hη hηmax hK hd₀ hq (κ (φ n)) A R) | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # The exact affine cap passes to the weak hot limit -/ | |
| 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} | |
| theorem hotWindow_time_mem (A R : ℝ) : | |
| ∀ᵐ z ∂hotWindowVolume A R, z.1.1 ∈ Icc (0:ℝ) A := by | |
| exact Measure.quasiMeasurePreserving_fst.ae | |
| (Measure.quasiMeasurePreserving_fst.ae (ae_restrict_mem measurableSet_Icc)) | |
| theorem hotDensity_cap_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 : ℕ) (A R : ℝ) : | |
| ∀ᵐ z ∂hotWindowVolume A R, S.hotDensity n z ≤ (z.1.1+S.coldFraction n)*H q z.2 := by | |
| let μt : Measure ℝ := volume.restrict (Icc (0:ℝ) A) | |
| let μx : Measure JetPrototype.Space := volume.restrict (Metric.closedBall 0 R) | |
| have hB : ∀ᵐ u ∂μt.prod (μx.prod volume), | |
| S.extendedHot n u ≤ (u.1+S.coldFraction n)*H q u.2.2 := by | |
| apply (Measure.ae_prod_iff_ae_ae (measurableSet_le | |
| (S.extendedHot_measurable hs₀ hsmax hη hηmax hK hd₀ hq n) | |
| ((measurable_fst.add_const _).mul | |
| ((ChartKernel.measurable_H q).comp measurable_snd.snd)))).mpr | |
| filter_upwards [ae_restrict_mem measurableSet_Icc] with t ht | |
| have hb := S.extendedHot_bound_at hs₀ hsmax hη hηmax hK hd₀ hq n ht.1 | |
| have hab : μx.prod (volume : Measure Velocity) ≤ FlightMeasure.phaseVolume := | |
| Measure.prod_mono Measure.restrict_le_self le_rfl | |
| exact hb.filter_mono (ae_mono hab) | |
| exact (measurePreserving_prodAssoc μt μx (volume : Measure Velocity)).quasiMeasurePreserving.ae hB | |
| theorem hot_velocity_integrable {q : ℝ} (hq : q < 2) (A R : ℝ) : | |
| Integrable (fun z : HotKineticPhase => H q z.2) (hotWindowVolume A R) := by | |
| unfold hotWindowVolume | |
| have : IsFiniteMeasure ((volume : Measure JetPrototype.Space).restrict | |
| (Metric.closedBall 0 R)) := | |
| isFiniteMeasure_restrict.mpr (isCompact_closedBall (0 : JetPrototype.Space) R).measure_lt_top.ne | |
| exact (integrable_H hq).comp_snd _ | |
| theorem hot_time_majorant_integrable {q : ℝ} (hq : q < 2) (A R : ℝ) : | |
| Integrable (fun z : HotKineticPhase => z.1.1*H q z.2) (hotWindowVolume A R) := by | |
| apply (hot_majorant_integrable hq A R).mono' | |
| (measurable_fst.fst.mul ((ChartKernel.measurable_H q).comp measurable_snd)).aestronglyMeasurable | |
| filter_upwards [hotWindow_time_mem A R] with z hz | |
| change ‖z.1.1*H q z.2‖ ≤ (A+1)*H q z.2 | |
| rw [Real.norm_of_nonneg (mul_nonneg hz.1 (H_nonneg q _))] | |
| exact mul_le_mul_of_nonneg_right (hz.2.trans (by linarith)) (H_nonneg q _) | |
| theorem hot_weak_limit_cap (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) {κ : ℕ → ℕ} {l A R : ℝ} | |
| (hl : Tendsto (fun n => S.coldFraction (κ n)) atTop (𝓝 l)) | |
| {g : HotKineticPhase → ℝ} | |
| (hg : Published.WeakL1Converges (hotWindowVolume A R) (fun n => S.hotDensity (κ n)) g) : | |
| ∀ᵐ z ∂hotWindowVolume A R, g z ≤ (z.1.1+l)*H q z.2 := by | |
| have hui := S.hotDensity_uniformIntegrable hs₀ hsmax hη hηmax hK hd₀ hq A R | |
| have hb (n) : ∀ᵐ z ∂hotWindowVolume A R, | |
| S.hotDensity (κ n) z ≤ z.1.1*H q z.2+S.coldFraction (κ n)*H q z.2 := by | |
| simpa only [add_mul] using S.hotDensity_cap_bound hs₀ hsmax hη hηmax hK hd₀ hq (κ n) A R | |
| simpa only [Pi.mul_apply,Function.comp_apply,add_mul] using hg.le_affine | |
| (fun n => memLp_one_iff_integrable.mp (hui.memLp (κ n))) | |
| (measurable_fst.fst.mul ((ChartKernel.measurable_H q).comp measurable_snd)) | |
| ((ChartKernel.measurable_H q).comp measurable_snd) | |
| (hot_time_majorant_integrable hq A R) (hot_velocity_integrable hq A R) hl hb | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # One subsequence for the hot density, mesh phase and limiting horizon -/ | |
| 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} | |
| structure HotLimitExtraction (S : AttainedCapSequence F) where | |
| fraction : ℝ | |
| fraction_mem : fraction ∈ Icc 0 1 | |
| phase : ℝ | |
| phase_mem : phase ∈ Icc 1 (Real.exp η) | |
| horizon : ℝ≥0∞ | |
| horizon_ge : 1 ≤ horizon | |
| indices : ℕ → ℕ | |
| indices_strict : StrictMono indices | |
| fraction_limit : Tendsto (fun n => S.coldFraction (indices n)) atTop (𝓝 fraction) | |
| phase_limit : Tendsto (fun n => GeometricMesh.phase (s₀/S.radius (indices n)) η) | |
| atTop (𝓝 phase) | |
| horizon_limit : Tendsto (fun n => S.normalizedHorizon (indices n)) atTop (𝓝 horizon) | |
| profile : ℕ → HotKineticPhase → ℝ | |
| weak : ∀ j : ℕ, Published.WeakL1Converges (hotWindowVolume (j+1) (j+1)) | |
| (fun n => S.hotDensity (indices n)) (profile j) | |
| nonneg : ∀ j : ℕ, ∀ᵐ z ∂hotWindowVolume (j+1) (j+1), 0 ≤ profile j z | |
| cap : ∀ j : ℕ, ∀ᵐ z ∂hotWindowVolume (j+1) (j+1), | |
| profile j z ≤ (z.1.1+fraction)*H q z.2 | |
| theorem exists_hot_limit_extraction (hDP : Published.DunfordPettis1940HotWindows) | |
| (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) : Nonempty (HotLimitExtraction S) := by | |
| obtain ⟨l,hl,θ,hθ,U,hU,a,ha,hla,hθa,hUa⟩ := S.joint_subsequence hs₀ hη | |
| let μ : ℕ → Measure HotKineticPhase := fun j => hotWindowVolume (j+1) (j+1) | |
| have hui (j) : UniformIntegrable (fun n => S.hotDensity (a n)) 1 (μ j) := | |
| Compactness.uniformIntegrable_comp | |
| (S.hotDensity_uniformIntegrable hs₀ hsmax hη hηmax hK hd₀ hq _ _) a | |
| have htight (j) : UnifTight (fun n => S.hotDensity (a n)) 1 (μ j) := | |
| (S.hotDensity_unifTight hs₀ hsmax hη hηmax hK hd₀ hq (by positivity) _).comp a | |
| obtain ⟨b,g,hb,hg⟩ := Published.L1WeakCompactnessInput.countable μ | |
| (fun j => hDP (j+1) (j+1) (by positivity) (by positivity)) | |
| (fun n => S.hotDensity_measurable hs₀ hsmax hη hηmax hK hd₀ hq (a n)) hui htight | |
| refine ⟨{ | |
| fraction := l | |
| fraction_mem := hl | |
| phase := θ | |
| phase_mem := hθ | |
| horizon := U | |
| horizon_ge := hU | |
| indices := a ∘ b | |
| indices_strict := ha.comp hb | |
| fraction_limit := hla.comp hb.tendsto_atTop | |
| phase_limit := hθa.comp hb.tendsto_atTop | |
| horizon_limit := hUa.comp hb.tendsto_atTop | |
| profile := g | |
| weak := hg | |
| nonneg := ?_ | |
| cap := ?_ }⟩ | |
| · intro j | |
| exact (hg j).nonneg (fun n => ae_of_all _ | |
| (S.hotDensity_nonneg hs₀ hsmax hη hηmax hK hd₀ hq (a (b n)))) | |
| · intro j | |
| exact S.hot_weak_limit_cap hs₀ hsmax hη hηmax hK hd₀ hq | |
| (hla.comp hb.tendsto_atTop) (hg j) | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # Actual cold labels approaching each point of the limiting geometric mesh -/ | |
| noncomputable section | |
| open Filter Set | |
| open scoped Topology | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| def HotLimitExtraction.coldLabel (E : HotLimitExtraction S) (k : ℤ) (a : Bool) (n : ℕ) : | |
| JetLattice.Label := | |
| ⟨GeometricMesh.jetIndex s₀ η (fun j => S.radius (E.indices j)) k n,a,0⟩ | |
| theorem HotLimitExtraction.coldLabel_scale_limit (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hη : 0 < η) (k : ℤ) (a : Bool) : | |
| Tendsto (fun n => JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus/S.radius (E.indices n)) | |
| atTop (𝓝 (E.phase*Real.exp (η*(k:ℝ)))) := | |
| GeometricMesh.jet_scale_approximation hs₀ hη (fun n => S.radius_pos hs₀ (E.indices n)) | |
| ((S.radius_tendsto_zero hs₀).comp E.indices_strict.tendsto_atTop) E.phase_limit k | |
| theorem HotLimitExtraction.coldLabel_retained (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hη : 0 < η) (k : ℤ) (a : Bool) | |
| (hk : E.fraction < E.phase*Real.exp (η*(k:ℝ))) : | |
| ∀ᶠ n in atTop, (E.coldLabel k a n).annulus < F.indices (E.indices n) := | |
| GeometricMesh.jetIndex_eventually_retained hs₀ hη (fun n => S.radius_pos hs₀ (E.indices n)) | |
| ((S.radius_tendsto_zero hs₀).comp E.indices_strict.tendsto_atTop) | |
| E.phase_limit E.fraction_limit k hk | |
| theorem HotLimitExtraction.coldLabel_scale_tendsto_zero (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hη : 0 < η) (k : ℤ) (a : Bool) : | |
| Tendsto (fun n => JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus) atTop (𝓝 0) := by | |
| have h := ((S.radius_tendsto_zero hs₀).comp E.indices_strict.tendsto_atTop).mul | |
| (E.coldLabel_scale_limit hs₀ hη k a) | |
| simpa only [Function.comp_def,zero_mul,mul_div_cancel₀ _ (S.radius_pos hs₀ _).ne'] using h | |
| theorem HotLimitExtraction.coldLabel_width_tendsto_zero (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hη : 0 < η) (k : ℤ) (a : Bool) : | |
| Tendsto (fun n => d₀*(JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus)^10) | |
| atTop (𝓝 0) := by | |
| simpa only [zero_pow (by decide : (10:ℕ) ≠ 0),mul_zero] using | |
| ((E.coldLabel_scale_tendsto_zero hs₀ hη k a).pow 10).const_mul d₀ | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # The quantitative free-flight error of the constructed cap approximations -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open BoltzmannNonuniqueness.JetLattice BoltzmannNonuniqueness.JetGeometry | |
| open BoltzmannNonuniqueness.VelocityWeight BoltzmannNonuniqueness.WeightedLocal | |
| open BoltzmannNonuniqueness.WeightedLocalControl BoltzmannNonuniqueness.WeightedTranslation | |
| namespace BoltzmannNonuniqueness.JetCopyDatum | |
| def CapApproximation.cold {s₀ η K α γ d₀ q T : ℝ} {N : ℕ} | |
| (F : CapApproximation s₀ η K α γ d₀ q T N) (i : Label) : ℝ × JetPrototype.Phase → ℝ := | |
| rebuilt s₀ η K α γ d₀ q (N+1) (damping q (N+1) F.amplitude) T N F.solution.value i | |
| theorem CapApproximation.local_free_error {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/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) | |
| (m : ℕ) (i : Label) (hi0 : i.lattice = 0) (hi : i.annulus < N) | |
| (hwidth : T*(d₀*jetScale s₀ η i.annulus^10) ≤ enlargementWidth η (jetScale s₀ η i.annulus)) | |
| (hdmax : d₀*jetScale s₀ η i.annulus^10 ≤ 1/64) | |
| (Ω : Set JetPrototype.Space) [IsFiniteMeasure (JetPrototype.spaceVolume.restrict Ω)] | |
| {t : ℝ} (ht : t ∈ Ioc 0 T) : | |
| let s := jetScale s₀ η i.annulus | |
| let E := coldOpticalDepth (4*JetBarrierCollision.frequencyConstant*K*d₀*s^9) | |
| (weightFrequencyConstant q 2) (DatumBounds.scale s₀ η (N+1)) | |
| (escapedFrequencyConstant s₀ η α K d₀ q m) m t | |
| let ε := JetSupersolution.epsilon K s (d₀*s^10) | |
| let μ := (JetPrototype.spaceVolume.restrict Ω).prod (volume : Measure Velocity) | |
| let error := fun p : JetPrototype.Phase => |H q p.2*F.cold i (t,p)- | |
| JetFreeTransport.free η K α γ s (d₀*s^10) t i.positive (shift (displacement i.lattice) p)| | |
| Integrable error μ ∧ (∫ p, error p ∂μ) ≤ | |
| (E+ε)*(JetPrototype.spaceVolume.restrict Ω).real univ*(JetBarrierLocalMass.massConstant*(K/s)) := 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_local_free_error hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max hTmax | |
| hq (by positivity) (bounds (by positivity) F.amplitude_pos).1 hT (by linarith [F.amplitude_pos]) | |
| hδ hsmall le_rfl m N i hi0 hwidth hdmax | |
| ((HotSeedProfile.normalized_measurable q _).const_mul F.coefficient) hh₀ F.initial_bound | |
| F.solution F.cap.le hi Ω ht | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| end | |
| end | |
| section | |
| /-! # The positive terminal cap scale is an excluded cold label -/ | |
| noncomputable section | |
| open Filter | |
| open scoped Topology | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| theorem HotLimitExtraction.coldLabel_at_endpoint (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hη : 0 < η) (hfrac : 0 < E.fraction) (k : ℤ) (a : Bool) | |
| (hk : E.phase*Real.exp (η*(k:ℝ)) = E.fraction) : | |
| ∀ᶠ n in atTop, (E.coldLabel k a n).annulus = F.indices (E.indices n) := by | |
| have hm := E.coldLabel_scale_limit hs₀ hη k a | |
| rw [hk] at hm | |
| have he := GeometricMesh.indices_eventually_eq_of_same_positive_limit hs₀.le hη hfrac | |
| (fun n => S.radius_pos hs₀ (E.indices n)) hm E.fraction_limit | |
| filter_upwards [he] with n hn | |
| exact Nat.add_right_cancel hn | |
| theorem HotLimitExtraction.coldLabel_below_endpoint (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hη : 0 < η) (k : ℤ) (a : Bool) | |
| (hk : E.phase*Real.exp (η*(k:ℝ)) < E.fraction) : | |
| ∀ᶠ n in atTop, F.indices (E.indices n) < (E.coldLabel k a n).annulus := by | |
| have he := (E.coldLabel_scale_limit hs₀ hη k a).eventually_lt E.fraction_limit hk | |
| filter_upwards [he] with n hn | |
| by_contra h | |
| have hb := JetGeometry.scale_antitone hs₀.le hη.le | |
| (Nat.add_le_add_right (le_of_not_gt h) 1) | |
| exact (not_lt_of_ge hb) | |
| ((div_lt_div_iff_of_pos_right (S.radius_pos hs₀ (E.indices n))).mp hn) | |
| theorem HotLimitExtraction.coldLabel_retained_iff (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hη : 0 < η) (k : ℤ) (a : Bool) : | |
| ∀ᶠ n in atTop, ((E.coldLabel k a n).annulus < F.indices (E.indices n) ↔ | |
| E.fraction < E.phase*Real.exp (η*(k:ℝ))) := by | |
| rcases lt_trichotomy E.fraction (E.phase*Real.exp (η*(k:ℝ))) with h | h | h | |
| · filter_upwards [E.coldLabel_retained hs₀ hη k a h] with n hn | |
| exact iff_of_true hn h | |
| · have hp : 0 < E.fraction := by | |
| rw [h] | |
| exact mul_pos (lt_of_lt_of_le zero_lt_one E.phase_mem.1) (Real.exp_pos _) | |
| filter_upwards [E.coldLabel_at_endpoint hs₀ hη hp k a h.symm] with n hn | |
| rw [hn,h] | |
| simp only [lt_self_iff_false] | |
| · filter_upwards [E.coldLabel_below_endpoint hs₀ hη k a h] with n hn | |
| exact iff_of_false (not_lt_of_ge hn.le) (not_lt_of_ge h.le) | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # Actual cold cap colors converge to their free flight on dilation windows -/ | |
| 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_free_error {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) | |
| (hwidth : ∀ n, T*(d₀*jetScale s₀ η (j n).annulus^10) ≤ | |
| enlargementWidth η (jetScale s₀ η (j n).annulus)) | |
| (hdmax : ∀ n, d₀*jetScale s₀ η (j n).annulus^10 ≤ 1/64) | |
| (Ω : 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 | |
| let s := fun n => jetScale s₀ η (j n).annulus | |
| let δ := fun n => DatumBounds.scale s₀ η (N n+1) | |
| let C := 4*JetBarrierCollision.frequencyConstant*K*d₀ | |
| let A := weightFrequencyConstant q 2 | |
| let D := escapedFrequencyConstant s₀ η α K d₀ q 0 | |
| let E := fun n => coldOpticalDepth (C*s n^9) A (δ n) D 0 (t n) | |
| let ε := fun n => JetSupersolution.epsilon K (s n) (d₀*(s n)^10) | |
| let err := fun n (p : JetPrototype.Phase) => | |
| H q p.2*(F n).cold (j n) (t n,p)- | |
| JetFreeTransport.free η K α γ (s n) (d₀*(s n)^10) (t n) (j n).positive | |
| (shift (displacement (j n).lattice) p) | |
| let I := fun n => ∫ p : JetPrototype.Phase, |err n p| | |
| ∂(JetPrototype.spaceVolume.restrict (r n • Ω)).prod volume | |
| have hs (n) : 0 < s n := DatumBounds.scale_pos (η := η) hs₀ _ | |
| have hC : 0 ≤ C := by | |
| dsimp [C] | |
| exact mul_nonneg | |
| (mul_nonneg (mul_nonneg (by norm_num) JetBarrierCollision.frequencyConstant_nonneg) hK) hd₀.le | |
| have hA : 0 ≤ A := weightFrequencyConstant_nonneg q (by norm_num) | |
| have hD : 0 ≤ D := escapedFrequencyConstant_nonneg hs₀ hK hd₀ η α q 0 | |
| have hEn (n) : 0 ≤ E n := coldOpticalDepth_nonneg | |
| (mul_nonneg hC (pow_nonneg (hs n).le _)) hA (DatumBounds.scale_pos hs₀ _).le hD (ht n).1.le 0 | |
| have hεn (n) : 0 ≤ ε n := JetSupersolution.epsilon_nonneg hK (hs n) | |
| (mul_pos hd₀ (pow_pos (hs n) _)) | |
| have hcomp (n) : IsCompact (r n • Ω) := hΩ.image (continuous_const_smul (r n)) | |
| have hfin (n) : IsFiniteMeasure (JetPrototype.spaceVolume.restrict (r n • Ω)) := | |
| isFiniteMeasure_restrict.mpr (hcomp n).measure_lt_top.ne | |
| have hbound (n) : Integrable (fun p => |err n p|) | |
| ((JetPrototype.spaceVolume.restrict (r n • Ω)).prod volume) ∧ | |
| I n ≤ (E n+ε n)*((r n)^3*JetPrototype.spaceVolume.real Ω)* | |
| (JetBarrierLocalMass.massConstant*(K/s n)) := by | |
| let _ := hfin n | |
| 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) (hwidth n) (hdmax n) (r n • Ω) (ht n) | |
| dsimp only at hb | |
| refine ⟨hb.1,?_⟩ | |
| simpa only [I,err,E,ε,C,A,D,s,δ,measureReal_restrict_apply_univ, | |
| ColdDilationMeasure.spaceVolume_real_smul Ω (hr n)] using hb.2 | |
| have hElim : Tendsto E atTop (𝓝 0) := | |
| coldOpticalDepth_tendsto_zero hC hA hD hS (fun n => (hr n).le) | |
| (fun n => (hs n).le) (fun n => (ht n).1.le) (fun n => (DatumBounds.scale_pos hs₀ _).le) | |
| hhi htime hδ hrlim | |
| have hεlim : Tendsto ε atTop (𝓝 0) := jet_epsilon_tendsto_zero hs hhi hrlim K d₀ | |
| have hlim : Tendsto (fun n => I n/(r n)^2) atTop (𝓝 0) := | |
| scaled_local_error_tendsto_zero hEn hεn measureReal_nonneg JetBarrierLocalMass.massConstant_nonneg | |
| hK hr hs ha hlo (fun n => integral_nonneg (fun _ => abs_nonneg _)) | |
| (fun n => (hbound n).2) hElim hεlim | |
| convert hlim using 1 | |
| funext n | |
| rw [ColdDilationMeasure.dilated_error_integral (err n) Ω (hr n)] | |
| rw [← integral_prod _ (hbound n).1] | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| end | |
| end | |
| section | |
| /-! # Cold dilation estimates for cap shots with varying horizons -/ | |
| 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_variable_cold_dilation_free_error {s₀ η K α γ d₀ q a S U : ℝ} {T : ℕ → ℝ} | |
| (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 : ∀ n, 0 ≤ T n) (hTmax : ∀ n, T n ≤ 1/32) | |
| (hq : q < 2) (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) | |
| (N : ℕ → ℕ) (F : ∀ n, CapApproximation s₀ η K α γ d₀ q (T n) (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 n)) (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) | |
| (hwidth : ∀ n, T n*(d₀*jetScale s₀ η (j n).annulus^10) ≤ | |
| enlargementWidth η (jetScale s₀ η (j n).annulus)) | |
| (hdmax : ∀ n, d₀*jetScale s₀ η (j n).annulus^10 ≤ 1/64) | |
| (Ω : 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 | |
| let s := fun n => jetScale s₀ η (j n).annulus | |
| let δ := fun n => DatumBounds.scale s₀ η (N n+1) | |
| let C := 4*JetBarrierCollision.frequencyConstant*K*d₀ | |
| let A := weightFrequencyConstant q 2 | |
| let D := escapedFrequencyConstant s₀ η α K d₀ q 0 | |
| let E := fun n => coldOpticalDepth (C*s n^9) A (δ n) D 0 (t n) | |
| let ε := fun n => JetSupersolution.epsilon K (s n) (d₀*(s n)^10) | |
| let err := fun n (p : JetPrototype.Phase) => | |
| H q p.2*(F n).cold (j n) (t n,p)- | |
| JetFreeTransport.free η K α γ (s n) (d₀*(s n)^10) (t n) (j n).positive | |
| (shift (displacement (j n).lattice) p) | |
| let I := fun n => ∫ p : JetPrototype.Phase, |err n p| | |
| ∂(JetPrototype.spaceVolume.restrict (r n • Ω)).prod volume | |
| have hs (n) : 0 < s n := DatumBounds.scale_pos (η := η) hs₀ _ | |
| have hC : 0 ≤ C := by | |
| dsimp [C] | |
| exact mul_nonneg | |
| (mul_nonneg (mul_nonneg (by norm_num) JetBarrierCollision.frequencyConstant_nonneg) hK) hd₀.le | |
| have hA : 0 ≤ A := weightFrequencyConstant_nonneg q (by norm_num) | |
| have hD : 0 ≤ D := escapedFrequencyConstant_nonneg hs₀ hK hd₀ η α q 0 | |
| have hEn (n) : 0 ≤ E n := coldOpticalDepth_nonneg | |
| (mul_nonneg hC (pow_nonneg (hs n).le _)) hA (DatumBounds.scale_pos hs₀ _).le hD (ht n).1.le 0 | |
| have hεn (n) : 0 ≤ ε n := JetSupersolution.epsilon_nonneg hK (hs n) | |
| (mul_pos hd₀ (pow_pos (hs n) _)) | |
| have hcomp (n) : IsCompact (r n • Ω) := hΩ.image (continuous_const_smul (r n)) | |
| have hfin (n) : IsFiniteMeasure (JetPrototype.spaceVolume.restrict (r n • Ω)) := | |
| isFiniteMeasure_restrict.mpr (hcomp n).measure_lt_top.ne | |
| have hbound (n) : Integrable (fun p => |err n p|) | |
| ((JetPrototype.spaceVolume.restrict (r n • Ω)).prod volume) ∧ | |
| I n ≤ (E n+ε n)*((r n)^3*JetPrototype.spaceVolume.real Ω)* | |
| (JetBarrierLocalMass.massConstant*(K/s n)) := by | |
| let _ := hfin n | |
| have hb := (F n).local_free_error hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max | |
| (hT n) (hTmax n) hq hsmall 0 (j n) (hj0 n) (hj n) (hwidth n) (hdmax n) (r n • Ω) (ht n) | |
| dsimp only at hb | |
| refine ⟨hb.1,?_⟩ | |
| simpa only [I,err,E,ε,C,A,D,s,δ,measureReal_restrict_apply_univ, | |
| ColdDilationMeasure.spaceVolume_real_smul Ω (hr n)] using hb.2 | |
| have hElim : Tendsto E atTop (𝓝 0) := | |
| coldOpticalDepth_tendsto_zero hC hA hD hS (fun n => (hr n).le) | |
| (fun n => (hs n).le) (fun n => (ht n).1.le) (fun n => (DatumBounds.scale_pos hs₀ _).le) | |
| hhi htime hδ hrlim | |
| have hεlim : Tendsto ε atTop (𝓝 0) := jet_epsilon_tendsto_zero hs hhi hrlim K d₀ | |
| have hlim : Tendsto (fun n => I n/(r n)^2) atTop (𝓝 0) := | |
| scaled_local_error_tendsto_zero hEn hεn measureReal_nonneg JetBarrierLocalMass.massConstant_nonneg | |
| hK hr hs ha hlo (fun n => integral_nonneg (fun _ => abs_nonneg _)) | |
| (fun n => (hbound n).2) hElim hεlim | |
| convert hlim using 1 | |
| funext n | |
| rw [ColdDilationMeasure.dilated_error_integral (err n) Ω (hr n)] | |
| rw [← integral_prod _ (hbound n).1] | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| end | |
| end | |
| section | |
| /-! # Thermal mask replacement on finite spatial cylinders -/ | |
| 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_average_limit (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hη : 0 < η) (k : ℤ) (a : Bool) (t : ℝ) | |
| (Ω : Set Transverse) (hΩ : volume Ω < ⊤) (ν : Measure ℝ) [IsFiniteMeasure ν] : | |
| 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 => ∫ x : JetPrototype.Space, | |
| |∫ w, JetGeometry.maskError (r n) η (s n) (d n) μ t a (x.1,w) | |
| ∂(volume : Measure Transverse).prod volume| ∂(volume.restrict Ω).prod ν) | |
| atTop (𝓝 0) := by | |
| intro r s d μ | |
| have hr (n) : 0 < r n := S.radius_pos hs₀ (E.indices n) | |
| have hrlim : Tendsto r atTop (𝓝 0) := | |
| (S.radius_tendsto_zero hs₀).comp E.indices_strict.tendsto_atTop | |
| have hb := JetGeometry.maskError_average_L1_tendsto hr hrlim | |
| (E.coldLabel_scale_limit hs₀ hη k a) (E.coldLabel_width_tendsto_zero hs₀ hη k a) | |
| η t a Ω hΩ | |
| change Tendsto (fun n => ∫ y, |∫ w, | |
| JetGeometry.maskError (r n) η (r n*(s n/r n)) (d n) μ t a (y,w) | |
| ∂(volume : Measure Transverse).prod volume| ∂volume.restrict Ω) atTop (𝓝 0) at hb | |
| simp only [mul_div_cancel₀ _ (hr _).ne'] at hb | |
| have h := hb.const_mul (ν.real univ) | |
| simp only [mul_zero] at h | |
| apply h.congr' | |
| filter_upwards [] with n | |
| exact (integral_fun_fst (μ := volume.restrict Ω) (ν := ν) | |
| (fun y => |∫ w, JetGeometry.maskError (r n) η (s n) (d n) μ t a (y,w) | |
| ∂(volume : Measure Transverse).prod volume|)).symm | |
| theorem HotLimitExtraction.coldLabel_mask_average_integrable (E : HotLimitExtraction S) | |
| (k : ℤ) (a : Bool) (n : ℕ) (t : ℝ) | |
| (Ω : Set Transverse) (hΩ : volume Ω < ⊤) (ν : Measure ℝ) [IsFiniteMeasure ν] : | |
| Integrable (fun x : JetPrototype.Space => ∫ w, | |
| JetGeometry.maskError (S.radius (E.indices n)) η | |
| (JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus) | |
| (d₀*(JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus)^10) | |
| (E.phase*Real.exp (η*(k:ℝ))) t a (x.1,w) | |
| ∂(volume : Measure Transverse).prod volume) ((volume.restrict Ω).prod ν) := by | |
| let _ : IsFiniteMeasure ((volume : Measure Transverse).restrict Ω) := | |
| ⟨by simpa only [Measure.restrict_apply_univ] using hΩ⟩ | |
| exact (JetGeometry.maskError_integrable _ _ _ _ _ _ _ | |
| ((volume : Measure Transverse).restrict Ω)).integral_prod_left.comp_fst ν | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # The rebuilt cold family of an actual cap shot -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open BoltzmannNonuniqueness.WeightedLocal BoltzmannNonuniqueness.WeightedLocalControl | |
| namespace BoltzmannNonuniqueness.JetCopyDatum | |
| theorem CapApproximation.cold_properties {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, Measurable (F.cold i)) ∧ (∀ i u, 0 ≤ F.cold i u) ∧ | |
| (∀ s : Finset JetLattice.Label, ∀ u, ∑ i ∈ s, F.cold i u ≤ F.solution.value u) ∧ | |
| (∀ i, ColdMildAE q (N+1) (damping q (N+1) F.amplitude) T F.solution.value | |
| (color s₀ η K α γ d₀ q N i) (F.cold i)) := 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 | |
| have hi := initial_color_bounds hs₀ hsmax hη hηmax hK hd₀ α γ q N hh₀ | |
| have hc₀ (i) (p) : 0 ≤ color s₀ η K α γ d₀ q N i p ∧ | |
| color s₀ η K α γ d₀ q N i p ≤ 2*F.amplitude := | |
| ⟨(hi.1 i p).1,(hi.1 i p).2.trans (F.initial_bound p)⟩ | |
| have hL : 0 ≤ damping q (N+1) F.amplitude := | |
| (bounds (q := q) (by positivity : 0 ≤ (N+1:ℝ)) F.amplitude_pos).1 | |
| have hR : 0 ≤ 2*F.amplitude := mul_nonneg (by norm_num) F.amplitude_pos.le | |
| have hp := rebuiltColdFamily_properties hq (by positivity : 0 ≤ (N+1:ℝ)) hL hT hR le_rfl | |
| F.solution.measurable_value (measurable_color s₀ η K α γ d₀ q N) | |
| F.solution.value_bounds hc₀ hi.2 (F.solution.all_mild hT) | |
| exact ⟨hp.1,fun i u => (hp.2.1 i u).1,hp.2.2.1,hp.2.2.2.2⟩ | |
| theorem CapApproximation.hotNetSource_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.hotNetSource := by | |
| have hc := F.cold_properties hs₀ hsmax hη hηmax hK hd₀ hq hT | |
| have hh := (F.hot_properties hs₀ hsmax hη hηmax hK hd₀ hq hT).1 | |
| exact ((measurable_forcing F.solution.measurable_value q (N+1) _).sub | |
| (Measurable.tsum (fun i => measurable_coldForcing F.solution.measurable_value (hc.1 i) q (N+1) _))).sub | |
| (hh.const_mul _) | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| end | |
| end | |
| section | |
| /-! # The actual hot remainder satisfies a bounded linear mild equation -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open BoltzmannNonuniqueness.WeightedLocal BoltzmannNonuniqueness.WeightedLocalControl | |
| namespace BoltzmannNonuniqueness.JetCopyDatum | |
| def CapApproximation.hotInitial {s₀ η K α γ d₀ q T : ℝ} {N : ℕ} | |
| (F : CapApproximation s₀ η K α γ d₀ q T N) (p : JetPrototype.Phase) : ℝ := | |
| initial s₀ η K α γ d₀ q N | |
| (fun p => F.coefficient*HotSeedProfile.normalized q (DatumBounds.scale s₀ η (N+1)) p) p- | |
| ∑' i, color s₀ η K α γ d₀ q N i p | |
| theorem CapApproximation.hot_mild {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) : | |
| ∀ t ∈ Icc 0 T, (fun p => F.hot (t,p)) =ᵐ[FlightMeasure.phaseVolume] | |
| (fun p => PositiveIntegral.value T (damping q (N+1) F.amplitude) JetBarrier.flight | |
| F.hotInitial (remainderForcing q (N+1) (damping q (N+1) F.amplitude) | |
| F.solution.value F.cold) (t,p)) := by | |
| have hc := F.cold_properties hs₀ hsmax hη hηmax hK hd₀ hq hT | |
| 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 | |
| have hi := initial_color_bounds hs₀ hsmax hη hηmax hK hd₀ α γ q N hh₀ | |
| exact family_hot_mildAE hq (by positivity : 0 ≤ (N+1:ℝ)) | |
| (bounds (by positivity) F.amplitude_pos).1 hT (mul_nonneg (by norm_num) F.amplitude_pos.le) le_rfl | |
| F.solution.measurable_value hc.1 F.solution.value_bounds hc.2.1 hc.2.2.1 | |
| (fun i p => (hi.1 i p).1) hi.2 F.solution.mild hc.2.2.2 | |
| theorem CapApproximation.hot_localized {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) | |
| (χ χ' : JetPrototype.Phase → ℝ → ℝ) | |
| (hχ : ∀ p, ContinuousOn (χ p) (Icc 0 T)) | |
| (hχ' : ∀ p, ContinuousOn (χ' p) (Icc 0 T)) | |
| (hdχ : ∀ p t, t ∈ Icc 0 T → HasDerivAt (χ p) (χ' p t) t) : | |
| ∀ᵐ p ∂FlightMeasure.phaseVolume, | |
| χ p T*F.hot (T,JetBarrier.flight T p) = Real.exp (-T)*χ p 0*F.hotInitial p+ | |
| ∫ t in 0..T, Real.exp (-(T-t)) * | |
| (χ p t*F.hotNetSource (t,JetBarrier.flight t p)+ | |
| (χ' p t+χ p t)*F.hot (t,JetBarrier.flight t p)) := by | |
| have hc := F.cold_properties hs₀ hsmax hη hηmax hK hd₀ hq hT | |
| have hb := family_hot_bounds hq (by positivity : 0 ≤ (N+1:ℝ)) (mul_nonneg (by norm_num : (0:ℝ) ≤ 2) F.amplitude_pos.le) | |
| le_rfl F.solution.measurable_value hc.1 F.solution.value_bounds hc.2.1 hc.2.2.1 | |
| have hm : Measurable F.hotInitial := by | |
| unfold hotInitial initial | |
| exact ((measurable_seed s₀ η K α γ d₀ q N).add | |
| ((HotSeedProfile.normalized_measurable q _).const_mul F.coefficient)).sub | |
| (Measurable.tsum (measurable_color s₀ η K α γ d₀ q N)) | |
| exact PositiveIntegral.localized_characteristic hT hm hb.1 hb.2.2.1 | |
| (fun u => by rw [abs_of_nonneg (hb.2.2.2 u).1]; exact (hb.2.2.2 u).2) | |
| (F.hot_mild hs₀ hsmax hη hηmax hK hd₀ hq hT) χ χ' hχ hχ' hdχ | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| end | |
| end | |
| section | |
| /-! # The mixed-cold source bound for the actual cap approximations -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open BoltzmannNonuniqueness.WeightedLocal BoltzmannNonuniqueness.WeightedLocalControl | |
| namespace BoltzmannNonuniqueness.JetCopyDatum | |
| def CapApproximation.coldSource {s₀ η K α γ d₀ q T : ℝ} {N : ℕ} | |
| (F : CapApproximation s₀ η K α γ d₀ q T N) : ℝ × JetPrototype.Phase → ℝ := | |
| coldFamilySource q (N+1) F.cold | |
| theorem CapApproximation.coldSource_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.coldSource := by | |
| have hc := F.cold_properties hs₀ hsmax hη hηmax hK hd₀ hq hT | |
| have hC : Measurable (fun u => ∑' i, F.cold i u) := Measurable.tsum hc.1 | |
| exact (measurable_forcing hC q (N+1) 0).sub | |
| (Measurable.tsum (fun i => measurable_coldForcing hC (hc.1 i) q (N+1) 0)) | |
| theorem CapApproximation.cold_source_bound (hcarleman : Published.GPV2009CarlemanInput) | |
| {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₁ : 1 < q) (hq₂ : q < 2) (hT : 0 ≤ T) (hTmax : T ≤ 1/32) (m : ℕ) | |
| (htail : JetEscapedEnvelope.constant s₀ η α K d₀ | |
| (JetEscapedEnvelope.exponent (m+1 : ℕ))*T^(m+1) ≤ 1) : | |
| ∀ᵐ u ∂spacetimeVolume, u.1 ∈ Ioc 0 T → 0 ≤ F.coldSource u ∧ | |
| F.coldSource u ≤ (2*JetMainGain.coefficient K α γ q+2*HotApplication.realBound q)* | |
| JetEscapedEnvelope.constant s₀ η α K d₀ | |
| (JetEscapedEnvelope.exponent (m+1 : ℕ))*u.1^m := 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 | |
| have hc := F.cold_properties hs₀ hsmax hη hηmax hK hd₀.le hq₂ hT | |
| have hL : 0 ≤ damping q (N+1) F.amplitude := | |
| (bounds (q := q) (by positivity : 0 ≤ (N+1:ℝ)) F.amplitude_pos).1 | |
| have hR : 0 ≤ 2*F.amplitude := mul_nonneg (by norm_num) F.amplitude_pos.le | |
| have hE := JetEscapedEnvelope.constant_nonneg hs₀ hK hd₀ η α | |
| (JetEscapedEnvelope.exponent (m+1 : ℕ)) | |
| have hb := geometric_cold_source (b := (N+1:ℝ)) hcarleman hs₀ hsmax hη hηmax hK hα hαmax hγ | |
| hd₀ hd₀max hsmall hq₁ hq₂ hTmax (m+1 : ℕ) N hc.1 | |
| (fun u => (F.solution.value_bounds u).2) hc.2.1 hc.2.2.1 | |
| (rebuilt_zero s₀ η K α γ d₀ q (N+1) (damping q (N+1) F.amplitude) T N | |
| (fun u => (F.solution.value_bounds u).1)) | |
| (fun t ht i x w => rebuilt_envelope hs₀ hsmax hη hηmax hK hα.le hγ.le hd₀ hsmall | |
| hq₂ (by positivity) hL hT hR (hTmax.trans (by norm_num)) le_rfl N hh₀ | |
| F.solution.measurable_value F.solution.value_bounds F.initial_bound i ht | |
| (JetPeriodicDatum.spatialMap x,w)) | |
| (fun n i => rebuilt_shift n (F.solution.periodic n) i) | |
| (fun t ht => by simpa only [Real.rpow_natCast] using tail_small hE ht.1.le ht.2 htail) | |
| filter_upwards [hb] with u hu hut | |
| refine ⟨(hu hut).1,?_⟩ | |
| have h := (hu hut).2 | |
| rw [scalarMajorant_eq_source s₀ η K α γ d₀ q N m hut.1 0] at h | |
| simpa only [CapApproximation.coldSource,ZeroProfile.source,mul_zero,zero_pow (by norm_num : (2:ℕ) ≠ 0), | |
| zero_add] using h | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| end | |
| end | |
| section | |
| /-! # Thermal concentration for the actual mesh labels -/ | |
| 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_thermal_limit (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hη : 0 < η) (hK : 0 ≤ K) (hα : 0 ≤ α) (hγ : 0 ≤ γ) (hd₀ : 0 < d₀) | |
| (k : ℤ) (a : Bool) {t : ℝ} (ht : 0 ≤ t) {B : ℝ} {ψ : Velocity → ℝ} | |
| (hψ : Continuous ψ) (hψB : ∀ v, |ψ v| ≤ B) (x : JetPrototype.Space) : | |
| 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 => (∫ v, r n*JetFreeTransport.free η K α γ (s n) (d n) | |
| (r n*t) a (r n • x,v)*ψ v)- | |
| (JetCoreDensity.compressed K α γ μ t (AxialFlow.foot (JetPrototype.sign a) α γ μ t x.2)* | |
| ψ (PlaneChart.join 0 (AxialFlow.velocity (JetPrototype.sign a) α γ μ t x.2)))* | |
| (∫ w, JetCoreDensity.dilatedMask (r n) η (s n/r n) (d n) t a x w* | |
| JetThermalKernel.J (SheetMeasures.join w) | |
| ∂(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 hs (n) : 0 < s n := DatumBounds.scale_pos hs₀ _ | |
| have hμ : 0 < μ := mul_pos (zero_lt_one.trans_le E.phase_mem.1) (Real.exp_pos _) | |
| have hrlim : Tendsto r atTop (𝓝 0) := | |
| (S.radius_tendsto_zero hs₀).comp E.indices_strict.tendsto_atTop | |
| have hslim : Tendsto (fun n => s n/r n) atTop (𝓝 μ) := E.coldLabel_scale_limit hs₀ hη k a | |
| have hdlim : Tendsto d atTop (𝓝 0) := E.coldLabel_width_tendsto_zero hs₀ hη k a | |
| have hclip : Tendsto (fun n => max (μ/2) (s n/r n)) atTop (𝓝 μ) := by | |
| have hm : Tendsto (fun n => max (μ/2) (s n/r n)) atTop (𝓝 (max (μ/2) μ)) := | |
| tendsto_const_nhds.max hslim | |
| simpa only [max_eq_right (show μ/2 ≤ μ by linarith)] using hm | |
| have hbase := JetCoreDensity.dilated_free_thermal_reduction hr hK hα hγ | |
| (by positivity : 0 < μ/2) (fun n => le_max_left (μ/2) (s n/r n)) | |
| (fun n => mul_pos hd₀ (pow_pos (hs n) 10)) hμ ht hrlim hclip hdlim hψ hψB η a x | |
| apply hbase.congr' | |
| filter_upwards [hslim.eventually (lt_mem_nhds (show μ/2 < μ by linarith))] with n hn | |
| rw [max_eq_right hn.le,mul_div_cancel₀ _ (hr n).ne'] | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # Spatial L1 thermal reduction for the actual retained-scale labels -/ | |
| 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_thermal_L1_limit (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hη : 0 < η) (hK : 0 ≤ K) (hα : 0 < α) (hγ : 0 < γ) (hd₀ : 0 < d₀) | |
| (k : ℤ) (a : Bool) {t : ℝ} (ht : 0 < t) {B : ℝ} {ψ : Velocity → ℝ} | |
| (hψ : Continuous ψ) (hψB : ∀ v, |ψ v| ≤ B) | |
| (ρ : Measure JetPrototype.Space) [IsFiniteMeasure ρ] : | |
| 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 => ∫ x, |(∫ v, r n*JetFreeTransport.free η K α γ (s n) (d n) | |
| (r n*t) a (r n • x,v)*ψ v)- | |
| JetCoreDensity.limitingCoefficient K α γ μ t (JetPrototype.sign a) ψ x* | |
| (∫ w, JetCoreDensity.dilatedMask (r n) η (s n/r n) (d n) t a x w* | |
| JetThermalKernel.J (SheetMeasures.join w) | |
| ∂(volume : Measure Transverse).prod volume)| ∂ρ) atTop (𝓝 0) := by | |
| intro r s d μ | |
| let f : ℕ → JetPrototype.Space → ℝ := fun n x => | |
| (∫ v, r n*JetFreeTransport.free η K α γ (s n) (d n) (r n*t) a (r n • x,v)*ψ v)- | |
| JetCoreDensity.limitingCoefficient K α γ μ t (JetPrototype.sign a) ψ x* | |
| (∫ w, JetCoreDensity.dilatedMask (r n) η (s n/r n) (d n) t a x w* | |
| JetThermalKernel.J (SheetMeasures.join w) | |
| ∂(volume : Measure Transverse).prod volume) | |
| have hr (n) : 0 < r n := S.radius_pos hs₀ (E.indices n) | |
| have hs (n) : 0 < s n := DatumBounds.scale_pos hs₀ _ | |
| have hd (n) : 0 < d n := mul_pos hd₀ (pow_pos (hs n) 10) | |
| have hμ : 0 < μ := mul_pos (zero_lt_one.trans_le E.phase_mem.1) (Real.exp_pos _) | |
| have hfm (n) : Measurable (f n) := | |
| (JetCoreDensity.free_average_measurable (r n) η K α γ (s n) (d n) t a hψ.measurable).sub | |
| ((JetCoreDensity.limitingCoefficient_measurable hα.le hγ.le hμ ht.le K | |
| (JetPrototype.sign a) hψ).mul | |
| (JetCoreDensity.mask_average_measurable (r n) η (s n/r n) (d n) t a)) | |
| have hl (x) : Tendsto (fun n => f n x) atTop (𝓝 0) := | |
| E.coldLabel_thermal_limit hs₀ hη hK hα.le hγ.le hd₀ k a ht.le hψ hψB x | |
| let C := ((K*max 1 (α*γ)⁻¹)/t)*B | |
| have hb (n x) : |f n x| ≤ 2*C := by | |
| have hfree := JetCoreDensity.dilated_free_average_bound (hr n) hK hα hγ | |
| (hs n) (hd n) ht η a x hψ hψB | |
| have hc := JetCoreDensity.limitingCoefficient_bound hK hα hγ hμ ht hψB | |
| (JetPrototype.sign a) x | |
| have hm := JetCoreDensity.masked_thermal_bound | |
| (JetCoreDensity.dilatedMask_abs_le (r n) η (s n/r n) (d n) t a x) | |
| have hp : |JetCoreDensity.limitingCoefficient K α γ μ t (JetPrototype.sign a) ψ x* | |
| (∫ w, JetCoreDensity.dilatedMask (r n) η (s n/r n) (d n) t a x w* | |
| JetThermalKernel.J (SheetMeasures.join w) | |
| ∂(volume : Measure Transverse).prod volume)| ≤ C := by | |
| rw [abs_mul] | |
| exact (mul_le_of_le_one_right (abs_nonneg _) hm).trans hc | |
| exact (abs_sub _ _).trans ((add_le_add hfree hp).trans_eq (by dsimp [C]; ring)) | |
| have h := tendsto_integral_of_dominated_convergence (μ := ρ) | |
| (F := fun n x => |f n x|) (f := fun _ => (0:ℝ)) (fun _ => 2*C) | |
| (fun n => (hfm n).abs.aestronglyMeasurable) (integrable_const _) | |
| (fun n => ae_of_all _ (fun x => by | |
| rw [Real.norm_of_nonneg (abs_nonneg _)] | |
| exact hb n x)) (ae_of_all _ (fun x => by simpa only [abs_zero] using (hl x).abs)) | |
| simpa only [integral_zero] using h | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # The actual free-core average reduces to its limiting shell and fine stripes -/ | |
| 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} | |
| def HotLimitExtraction.coldLabelFreeAverage (E : HotLimitExtraction S) (k : ℤ) (a : Bool) | |
| (n : ℕ) (t : ℝ) (ψ : Velocity → ℝ) (x : JetPrototype.Space) : ℝ := | |
| let r := S.radius (E.indices n) | |
| let s := JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus | |
| ∫ v, r*JetFreeTransport.free η K α γ s (d₀*s^10) (r*t) a (r • x,v)*ψ v | |
| def HotLimitExtraction.coldLabelStripeAverage (E : HotLimitExtraction S) (k : ℤ) (a : Bool) | |
| (n : ℕ) (t : ℝ) (y : Transverse) : ℝ := | |
| let r := S.radius (E.indices n) | |
| let s := JetGeometry.jetScale s₀ η (E.coldLabel k a n).annulus | |
| ∫ w, (JetGeometry.stripe s a).indicator (fun _ => (1:ℝ)) | |
| (r • (y-t • ((d₀*s^10) • w.1)))*JetThermalKernel.J (SheetMeasures.join w) | |
| ∂(volume : Measure Transverse).prod volume | |
| def HotLimitExtraction.coldLabelStripedProfile (E : HotLimitExtraction S) (k : ℤ) (a : Bool) | |
| (n : ℕ) (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* | |
| E.coldLabelStripeAverage k a n t x.1) | |
| theorem HotLimitExtraction.coldLabel_free_striped_L1_limit (E : HotLimitExtraction S) | |
| (hs₀ : 0 < s₀) (hη : 0 < η) (hK : 0 ≤ K) (hα : 0 < α) (hγ : 0 < γ) (hd₀ : 0 < d₀) | |
| (k : ℤ) (a : Bool) {t : ℝ} (ht : 0 < t) {B : ℝ} {ψ : Velocity → ℝ} | |
| (hψ : Continuous ψ) (hψB : ∀ v, |ψ v| ≤ B) | |
| (Ω : Set Transverse) (hΩ : volume Ω < ⊤) (ν : Measure ℝ) [IsFiniteMeasure ν] : | |
| Tendsto (fun n => ∫ x, |E.coldLabelFreeAverage k a n t ψ x- | |
| E.coldLabelStripedProfile k a n t ψ x| ∂(volume.restrict Ω).prod ν) atTop (𝓝 0) := by | |
| let _ : IsFiniteMeasure ((volume : Measure Transverse).restrict Ω) := | |
| ⟨by simpa only [Measure.restrict_apply_univ] using hΩ⟩ | |
| let ρ := (volume.restrict Ω).prod ν | |
| 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:ℝ)) | |
| let c := JetCoreDensity.limitingCoefficient K α γ μ t (JetPrototype.sign a) ψ | |
| let m := fun n x => ∫ w, JetCoreDensity.dilatedMask (r n) η (s n/r n) (d n) t a x w* | |
| JetThermalKernel.J (SheetMeasures.join w) ∂(volume : Measure Transverse).prod volume | |
| let e := fun n (x : JetPrototype.Space) => ∫ w, | |
| JetGeometry.maskError (r n) η (s n) (d n) μ t a (x.1,w) | |
| ∂(volume : Measure Transverse).prod volume | |
| let f := E.coldLabelFreeAverage k a | |
| let C := ((K*max 1 (α*γ)⁻¹)/t)*B | |
| have hr (n) : 0 < r n := S.radius_pos hs₀ (E.indices n) | |
| have hs (n) : 0 < s n := DatumBounds.scale_pos hs₀ _ | |
| have hd (n) : 0 < d n := mul_pos hd₀ (pow_pos (hs n) 10) | |
| have hμ : 0 < μ := mul_pos (zero_lt_one.trans_le E.phase_mem.1) (Real.exp_pos _) | |
| have htlim := E.coldLabel_thermal_L1_limit hs₀ hη hK hα hγ hd₀ k a ht hψ hψB ρ | |
| have hmlim := E.coldLabel_mask_average_limit hs₀ hη k a t Ω hΩ ν | |
| change Tendsto (fun n => ∫ x, |f n t ψ x-c x*m n x| ∂ρ) atTop (𝓝 0) at htlim | |
| change Tendsto (fun n => ∫ x, |e n x| ∂ρ) atTop (𝓝 0) at hmlim | |
| have hlim := htlim.add (hmlim.const_mul C) | |
| simp only [mul_zero,zero_add] at hlim | |
| apply squeeze_zero (fun _ => integral_nonneg (fun _ => abs_nonneg _)) _ hlim | |
| intro n | |
| have hi₁ : Integrable (fun x => f n t ψ x-c x*m n x) ρ := | |
| JetCoreDensity.thermal_error_integrable (hr n) hK hα hγ (hs n) (hd n) hμ ht η a hψ hψB ρ | |
| have hi₂ : Integrable (e n) ρ := E.coldLabel_mask_average_integrable k a n t Ω hΩ ν | |
| rw [← integral_const_mul,← integral_add hi₁.abs (hi₂.abs.const_mul C)] | |
| apply integral_mono_of_nonneg (ae_of_all _ (fun _ => abs_nonneg _)) | |
| (hi₁.abs.add (hi₂.abs.const_mul C)) | |
| filter_upwards [] with x | |
| have he : e n x = m n x-(JetGeometry.scaleShell η μ).indicator (fun _ => (1:ℝ)) x.1* | |
| E.coldLabelStripeAverage k a n t x.1 := by | |
| have hb := JetGeometry.maskError_average_eq (r n) η (s n/r n) (d n) μ t a x | |
| simp only [mul_div_cancel₀ _ (hr n).ne'] at hb | |
| simpa only [e,m,r,s,d,coldLabelStripeAverage] using hb | |
| have hid : f n t ψ x-E.coldLabelStripedProfile k a n t ψ x = | |
| (f n t ψ x-c x*m n x)+c x*e n x := by | |
| rw [he] | |
| change f n t ψ x-c x*((JetGeometry.scaleShell η μ).indicator (fun _ => (1:ℝ)) x.1* | |
| E.coldLabelStripeAverage k a n t x.1) = _ | |
| ring | |
| rw [hid] | |
| apply (abs_add_le _ _).trans | |
| apply add_le_add le_rfl | |
| rw [abs_mul] | |
| exact mul_le_mul_of_nonneg_right | |
| (JetCoreDensity.limitingCoefficient_bound hK hα hγ hμ ht hψB (JetPrototype.sign a) x) | |
| (abs_nonneg _) | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # Cold free-flight convergence on varying cap horizons -/ | |
| 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_variable_cold_dilation_limit {s₀ η K α γ d₀ q a S U : ℝ} {T : ℕ → ℝ} | |
| (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 : ∀ n, 0 ≤ T n) (hTmax : ∀ n, T n ≤ 1/32) | |
| (hq : q < 2) (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) | |
| (N : ℕ → ℕ) (F : ∀ n, CapApproximation s₀ η K α γ d₀ q (T n) (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 n)) (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 := (1/32:ℝ)) (d₀ := d₀) hη hslim) | |
| apply (tendsto_add_atTop_iff_nat n₀).mp | |
| exact cap_variable_cold_dilation_free_error hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max (fun n => hT (n+n₀)) (fun n => hTmax (n+n₀)) 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 => (mul_le_mul_of_nonneg_right (hTmax (n+n₀)) (by positivity)).trans | |
| (hn₀ (n+n₀) (by omega)).1) (fun n => (hn₀ (n+n₀) (by omega)).2) Ω hΩ | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| end | |
| end | |
| section | |
| /-! # Product-space cold dilation with varying cap horizons -/ | |
| 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_variable_cold_L1_dilation_limit {s₀ η K α γ d₀ q a S U : ℝ} {T : ℕ → ℝ} | |
| (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 : ∀ n, 0 ≤ T n) (hTmax : ∀ n, T n ≤ 1/32) | |
| (hq : q < 2) (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) | |
| (N : ℕ → ℕ) (F : ∀ n, CapApproximation s₀ η K α γ d₀ q (T n) (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 n)) (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_variable_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 := (1/32:ℝ)) (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 n) (hTmax n) hq hsmall 0 (j n) (hj0 n) (hj n) | |
| ((mul_le_mul_of_nonneg_right (hTmax n) (by positivity)).trans 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 | |
| /-! # Cold/free convergence for the actual retained mesh labels -/ | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped Topology ENNReal | |
| open BoltzmannNonuniqueness.VelocityWeight BoltzmannNonuniqueness.WeightedTranslation | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| {S : AttainedCapSequence F} | |
| theorem HotLimitExtraction.coldLabel_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 Ω) : | |
| let j := E.coldLabel k a | |
| let r := fun n => S.radius (E.indices n) | |
| Tendsto (fun n => ∫ p : JetPrototype.Phase, | |
| |r n*(H q p.2*(F.approximation (E.indices n)).cold (j n) (r n*t,(r n • p.1,p.2))- | |
| JetFreeTransport.free η K α γ (JetGeometry.jetScale s₀ η (j n).annulus) | |
| (d₀*(JetGeometry.jetScale s₀ η (j n).annulus)^10) (r n*t) (j n).positive | |
| (shift (displacement (j n).lattice) (r n • p.1,p.2)))| | |
| ∂(JetPrototype.spaceVolume.restrict Ω).prod volume) atTop (𝓝 0) := by | |
| intro j r | |
| let μ := E.phase*Real.exp (η*(k:ℝ)) | |
| have hμ : 0 < μ := mul_pos (zero_lt_one.trans_le E.phase_mem.1) (Real.exp_pos _) | |
| have hrlim : Tendsto r atTop (𝓝 0) := | |
| (S.radius_tendsto_zero hs₀).comp E.indices_strict.tendsto_atTop | |
| have hr (n) : 0 < r n := S.radius_pos hs₀ (E.indices n) | |
| have hs : Tendsto (fun n => JetGeometry.jetScale s₀ η (j n).annulus/r n) atTop (𝓝 μ) := | |
| E.coldLabel_scale_limit hs₀ hη k a | |
| have hlo := hs.eventually (lt_mem_nhds (show μ/2 < μ by linarith)) | |
| have hhi := hs.eventually (gt_mem_nhds (show μ < 2*μ by linarith)) | |
| have hgood : ∀ᶠ n in atTop, | |
| (j n).annulus < F.indices (E.indices n) ∧ | |
| r n*t ∈ Ioc 0 (shrinkingHorizon F.horizonScale (E.indices n)) ∧ | |
| (μ/2)*r n ≤ JetGeometry.jetScale s₀ η (j n).annulus ∧ | |
| JetGeometry.jetScale s₀ η (j n).annulus ≤ (2*μ)*r n := by | |
| filter_upwards [E.coldLabel_retained hs₀ hη k a hk, | |
| S.eventually_scaled_slab hs₀ E.horizon_limit htU,hlo,hhi] with n hj htime hl hu | |
| exact ⟨hj,⟨mul_pos (hr n) ht,(htime t ⟨ht.le,le_rfl⟩).2⟩, | |
| ((lt_div_iff₀ (hr n)).mp hl).le,((div_lt_iff₀ (hr n)).mp hu).le⟩ | |
| obtain ⟨n₀,hn₀⟩ := eventually_atTop.mp hgood | |
| apply (tendsto_add_atTop_iff_nat n₀).mp | |
| exact cap_variable_cold_L1_dilation_limit hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max | |
| (fun n => (shrinkingHorizon_pos F.horizonScale_pos (E.indices (n+n₀))).le) | |
| (fun n => (shrinkingHorizon_le F.horizonScale_pos _).trans F.horizonScale_le) | |
| hq hsmall (fun n => F.indices (E.indices (n+n₀))) | |
| (fun n => F.approximation (E.indices (n+n₀))) (fun n => j (n+n₀)) (fun _ => rfl) | |
| (fun n => (hn₀ (n+n₀) (by omega)).1) (fun n => r (n+n₀)) (fun n => r (n+n₀)*t) | |
| (fun n => hr (n+n₀)) (hrlim.comp (tendsto_add_atTop_nat n₀)) | |
| (fun n => (hn₀ (n+n₀) (by omega)).2.1) (by positivity : 0 < μ/2) | |
| (by positivity : 0 ≤ 2*μ) (fun n => (hn₀ (n+n₀) (by omega)).2.2.1) | |
| (fun n => (hn₀ (n+n₀) (by omega)).2.2.2) | |
| (U := t) (fun n => (mul_comm (r (n+n₀)) t).le) | |
| (fun n => (div_le_one (hr (n+n₀))).mp (S.coldFraction_mem hs₀ (E.indices (n+n₀))).2) | |
| Ω hΩ | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| end OAI | |