openAI-math-dataset / lean /OAI /MathematicalPhysics /Boltzmann /Approximation /CapDilationCompactness.lean
| import OAI.MathematicalPhysics.Boltzmann.Approximation.CapDilationScales | |
| import OAI.MathematicalPhysics.Boltzmann.Approximation.CappedDensitySequence | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.OuterTightness | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.RawPairCompactness | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.RebuiltHotCapBound | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.WeightedNetLoss | |
| import OAI.MathematicalPhysics.Boltzmann.Jets.GeometricColdSource | |
| import OAI.MathematicalPhysics.Boltzmann.Jets.GeometricMesh | |
| import OAI.MathematicalPhysics.Boltzmann.Jets.JetFamilyBounds | |
| import OAI.MathematicalPhysics.Boltzmann.Jets.SpatialDilationAE | |
| namespace OAI | |
| section | |
| /-! # Actual cap shots on horizons tending to zero -/ | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped Topology | |
| namespace BoltzmannNonuniqueness.JetCopyDatum | |
| def shrinkingHorizon (τ : ℝ) (n : ℕ) : ℝ := τ/((n:ℝ)+1) | |
| theorem shrinkingHorizon_pos {τ : ℝ} (hτ : 0 < τ) (n : ℕ) : 0 < shrinkingHorizon τ n := | |
| div_pos hτ (by positivity) | |
| theorem shrinkingHorizon_le {τ : ℝ} (hτ : 0 < τ) (n : ℕ) : shrinkingHorizon τ n ≤ τ := by | |
| apply (div_le_iff₀ (by positivity : 0 < (n:ℝ)+1)).mpr | |
| nlinarith [Nat.cast_nonneg (α := ℝ) n] | |
| theorem shrinkingHorizon_tendsto_zero (τ : ℝ) : | |
| Tendsto (shrinkingHorizon τ) atTop (𝓝 0) := by | |
| change Tendsto (fun n : ℕ => τ/((n:ℝ)+1)) atTop (𝓝 0) | |
| have h := (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)).const_mul τ | |
| simpa only [div_eq_mul_inv,one_mul,mul_zero] using h | |
| theorem exists_diagonal_cap_indices {s₀ η τ : ℝ} (hs₀ : 0 < s₀) (hη : 0 < η) | |
| (hτ : 0 < τ) : | |
| ∃ N : ℕ → ℕ, (∀ n, n ≤ N n) ∧ Tendsto N atTop atTop ∧ | |
| Tendsto (fun n => DatumBounds.scale s₀ η (N n+1)/shrinkingHorizon τ n) atTop (𝓝 0) := by | |
| have hex (n : ℕ) : ∃ N : ℕ, n ≤ N ∧ | |
| DatumBounds.scale s₀ η (N+1) ≤ (shrinkingHorizon τ n)^2 := by | |
| have hlim := (DatumBounds.scale_tendsto_zero s₀ hη).eventually | |
| (gt_mem_nhds (sq_pos_of_pos (shrinkingHorizon_pos hτ n))) | |
| obtain ⟨M,hM⟩ := eventually_atTop.mp hlim | |
| refine ⟨max n M,le_max_left _ _,?_⟩ | |
| exact (hM (max n M+1) ((le_max_right n M).trans (Nat.le_succ _))).le | |
| choose N hN hb using hex | |
| refine ⟨N,hN,tendsto_atTop_mono hN tendsto_id,?_⟩ | |
| apply squeeze_zero (fun n => div_nonneg (DatumBounds.scale_pos hs₀ _).le | |
| (shrinkingHorizon_pos hτ n).le) (fun n => ?_) (shrinkingHorizon_tendsto_zero τ) | |
| apply (div_le_iff₀ (shrinkingHorizon_pos hτ n)).mpr | |
| simpa only [pow_two] using hb n | |
| structure ShrinkingCapFamily (s₀ η K α γ d₀ q : ℝ) where | |
| horizonScale : ℝ | |
| horizonScale_pos : 0 < horizonScale | |
| horizonScale_le : horizonScale ≤ 1/32 | |
| indices : ℕ → ℕ | |
| indices_ge : ∀ n, n ≤ indices n | |
| indices_tendsto : Tendsto indices atTop atTop | |
| cold_ratio_tendsto : Tendsto (fun n => DatumBounds.scale s₀ η (indices n+1)/ | |
| shrinkingHorizon horizonScale n) atTop (𝓝 0) | |
| approximation : ∀ n, CapApproximation s₀ η K α γ d₀ q (shrinkingHorizon horizonScale n) (indices n) | |
| theorem exists_shrinking_cap_family (hcarleman : Published.GPV2009CarlemanInput) | |
| {s₀ η K α γ d₀ q : ℝ} | |
| (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) (hwidth : d₀*(1/8:ℝ)^10 ≤ 1/64) | |
| (hsmall : JetComparisonCoefficient.coefficient K*d₀*s₀^9 ≤ 1) | |
| (hq₁ : 1 < q) (hq₂ : q < 2) : Nonempty (ShrinkingCapFamily s₀ η K α γ d₀ q) := by | |
| obtain ⟨τ,hτ,hτmax,hcap⟩ := exists_uniform_cap_solution hcarleman hs₀ hsmax hη hηmax | |
| hK hα hαmax hγ hd₀ hd₀max hwidth hsmall hq₁ hq₂ | |
| obtain ⟨N,hN,hNlim,hratio⟩ := exists_diagonal_cap_indices hs₀ hη hτ | |
| have hex (n) : Nonempty (CapApproximation s₀ η K α γ d₀ q (shrinkingHorizon τ n) (N n)) := by | |
| obtain ⟨A,ell,hA,hell,hinit,F,hF⟩ := hcap (N n) (N n+1) (shrinkingHorizon τ n) | |
| (by positivity) (shrinkingHorizon_pos hτ n).le (shrinkingHorizon_le hτ n) | |
| exact ⟨⟨A,ell,hA,hell,hinit,F,hF⟩⟩ | |
| exact ⟨⟨τ,hτ,hτmax,N,hN,hNlim,hratio,fun n => Classical.choice (hex n)⟩⟩ | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| end | |
| end | |
| section | |
| /-! # An actual cap approximation has a time attaining its normalized hot size -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open BoltzmannNonuniqueness.WeightedLocal | |
| open BoltzmannNonuniqueness.WeightedLocalControl | |
| namespace BoltzmannNonuniqueness.JetCopyDatum | |
| theorem CapApproximation.cap_time {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, | |
| PhaseEssSup.size (fun p => F.solution.value (t,p)- | |
| ∑' i, rebuiltColdFamily q (N+1) (damping q (N+1) F.amplitude) T | |
| F.solution.value (color s₀ η K α γ d₀ q N) i (t,p)) = | |
| t+DatumBounds.scale s₀ η (N+1) := 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 hreg := rebuilt_hot_continuous 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 | |
| ((measurable_seed s₀ η K α γ d₀ q N).add | |
| ((HotSeedProfile.normalized_measurable q _).const_mul F.coefficient)) | |
| (measurable_color s₀ η K α γ d₀ q N) F.solution.value_bounds F.initial_bound hc₀ hi.2 | |
| (F.solution.all_mild hT) | |
| obtain ⟨t,ht,he,_⟩ := Cap.peak_attained hT hδ hreg | |
| refine ⟨t,ht,?_⟩ | |
| have hratio : PhaseEssSup.size (fun p => F.solution.value (t,p)- | |
| ∑' i, rebuiltColdFamily q (N+1) (damping q (N+1) F.amplitude) T | |
| F.solution.value (color s₀ η K α γ d₀ q N) i (t,p)) / | |
| (t+DatumBounds.scale s₀ η (N+1)) = 1 := he.symm.trans F.cap | |
| simpa only [one_mul] using | |
| (div_eq_iff (Cap.dilation_radius_pos ht.1 hδ).ne').mp hratio | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| end | |
| end | |
| section | |
| /-! # Attained times and dilation radii for the actual shrinking cap shots -/ | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped Topology | |
| open BoltzmannNonuniqueness.WeightedLocal | |
| open BoltzmannNonuniqueness.WeightedLocalControl | |
| namespace BoltzmannNonuniqueness.JetCopyDatum | |
| def CapApproximation.hotSize {s₀ η K α γ d₀ q T : ℝ} {N : ℕ} | |
| (F : CapApproximation s₀ η K α γ d₀ q T N) (t : ℝ) : ℝ := | |
| PhaseEssSup.size (fun p => F.solution.value (t,p)- | |
| ∑' i, rebuiltColdFamily q (N+1) (damping q (N+1) F.amplitude) T | |
| F.solution.value (color s₀ η K α γ d₀ q N) i (t,p)) | |
| structure AttainedCapSequence {s₀ η K α γ d₀ q : ℝ} | |
| (F : ShrinkingCapFamily s₀ η K α γ d₀ q) where | |
| time : ℕ → ℝ | |
| time_mem : ∀ n, time n ∈ Icc 0 (shrinkingHorizon F.horizonScale n) | |
| attained : ∀ n, (F.approximation n).hotSize (time n) = | |
| time n+DatumBounds.scale s₀ η (F.indices n+1) | |
| theorem exists_attained_cap_sequence {s₀ η K α γ d₀ q : ℝ} | |
| (F : ShrinkingCapFamily s₀ η K α γ d₀ q) | |
| (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) (hη : 0 < η) (hηmax : η ≤ Real.log 2) | |
| (hK : 0 ≤ K) (hd₀ : 0 ≤ d₀) (hq : q < 2) : Nonempty (AttainedCapSequence F) := by | |
| have hex (n : ℕ) : ∃ t ∈ Icc 0 (shrinkingHorizon F.horizonScale n), | |
| (F.approximation n).hotSize t = t+DatumBounds.scale s₀ η (F.indices n+1) := | |
| (F.approximation n).cap_time hs₀ hsmax hη hηmax hK hd₀ hq | |
| (shrinkingHorizon_pos F.horizonScale_pos n).le | |
| choose t ht he using hex | |
| exact ⟨⟨t,ht,he⟩⟩ | |
| namespace AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| def radius (S : AttainedCapSequence F) (n : ℕ) : ℝ := | |
| S.time n+DatumBounds.scale s₀ η (F.indices n+1) | |
| def coldFraction (S : AttainedCapSequence F) (n : ℕ) : ℝ := | |
| DatumBounds.scale s₀ η (F.indices n+1)/S.radius n | |
| theorem radius_pos (S : AttainedCapSequence F) (hs₀ : 0 < s₀) (n : ℕ) : 0 < S.radius n := | |
| Cap.dilation_radius_pos (S.time_mem n).1 (DatumBounds.scale_pos hs₀ _) | |
| theorem radius_tendsto_zero (S : AttainedCapSequence F) (hs₀ : 0 < s₀) : | |
| Tendsto S.radius atTop (𝓝 0) := | |
| Cap.dilation_radius_tendsto_zero (shrinkingHorizon_pos F.horizonScale_pos) S.time_mem | |
| (fun n => DatumBounds.scale_pos hs₀ (F.indices n+1)) | |
| (shrinkingHorizon_tendsto_zero F.horizonScale) F.cold_ratio_tendsto | |
| theorem coldFraction_mem (S : AttainedCapSequence F) (hs₀ : 0 < s₀) (n : ℕ) : | |
| S.coldFraction n ∈ Icc (0:ℝ) 1 := | |
| Cap.cold_fraction_mem (S.time_mem n).1 (DatumBounds.scale_pos hs₀ _) | |
| theorem normalized_time (S : AttainedCapSequence F) (hs₀ : 0 < s₀) (n : ℕ) : | |
| S.time n/S.radius n = 1-S.coldFraction n := | |
| Cap.normalized_cap_time (S.time_mem n).1 (DatumBounds.scale_pos hs₀ _) | |
| theorem fraction_subsequence (S : AttainedCapSequence F) (hs₀ : 0 < s₀) : | |
| ∃ l ∈ Icc (0:ℝ) 1, ∃ κ : ℕ → ℕ, StrictMono κ ∧ | |
| Tendsto (fun n => S.coldFraction (κ n)) atTop (𝓝 l) := | |
| isCompact_Icc.tendsto_subseq (fun n => S.coldFraction_mem hs₀ n) | |
| theorem horizon_limit_ge_one (S : AttainedCapSequence F) (hs₀ : 0 < s₀) {U : ℝ} | |
| (hU : Tendsto (fun n => shrinkingHorizon F.horizonScale n/S.radius n) atTop (𝓝 U)) : | |
| 1 ≤ U := | |
| Cap.normalized_horizon_limit_ge_one (shrinkingHorizon_pos F.horizonScale_pos) S.time_mem | |
| (fun n => DatumBounds.scale_pos hs₀ (F.indices n+1)) F.cold_ratio_tendsto hU | |
| end AttainedCapSequence | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| end | |
| end | |
| section | |
| /-! # A common subsequence for the cold scale, mesh phase and time domain -/ | |
| noncomputable section | |
| open Filter Set | |
| open scoped Topology ENNReal | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| def normalizedHorizon (S : AttainedCapSequence F) (n : ℕ) : ℝ≥0∞ := | |
| ENNReal.ofReal (shrinkingHorizon F.horizonScale n/S.radius n) | |
| private theorem lower_horizon_tendsto {ε : ℕ → ℝ} (hε : Tendsto ε atTop (𝓝 0)) : | |
| Tendsto (fun n => ENNReal.ofReal (1/(1+ε n))) atTop (𝓝 (1:ℝ≥0∞)) := by | |
| have hden : Tendsto (fun n => 1+ε n) atTop (𝓝 (1:ℝ)) := by | |
| simpa only [add_zero] using tendsto_const_nhds.add hε | |
| have h := (tendsto_const_nhds (x := (1:ℝ))).div hden one_ne_zero | |
| change Tendsto (fun n => 1/(1+ε n)) atTop (𝓝 ((1:ℝ)/1)) at h | |
| have hr : Tendsto (fun n => 1/(1+ε n)) atTop (𝓝 (1:ℝ)) := by simpa only [one_div_one] using h | |
| have hE := (ENNReal.continuous_ofReal.tendsto 1).comp hr | |
| change Tendsto (fun n => ENNReal.ofReal (1/(1+ε n))) atTop (𝓝 (ENNReal.ofReal 1)) at hE | |
| simpa only [ENNReal.ofReal_one] using hE | |
| theorem joint_subsequence (S : AttainedCapSequence F) (hs₀ : 0 < s₀) (hη : 0 < η) : | |
| ∃ l ∈ Icc (0:ℝ) 1, ∃ θ ∈ Icc 1 (Real.exp η), ∃ U : ℝ≥0∞, 1 ≤ U ∧ | |
| ∃ κ : ℕ → ℕ, StrictMono κ ∧ | |
| Tendsto (fun n => S.coldFraction (κ n)) atTop (𝓝 l) ∧ | |
| Tendsto (fun n => GeometricMesh.phase (s₀/S.radius (κ n)) η) atTop (𝓝 θ) ∧ | |
| Tendsto (fun n => S.normalizedHorizon (κ n)) atTop (𝓝 U) := by | |
| let A : Set (ℝ × (ℝ × ℝ≥0∞)) := (Icc (0:ℝ) 1).prod ((Icc 1 (Real.exp η)).prod univ) | |
| have hA : IsCompact A := isCompact_Icc.prod (isCompact_Icc.prod isCompact_univ) | |
| have hmem (n) : (S.coldFraction n,(GeometricMesh.phase (s₀/S.radius n) η,S.normalizedHorizon n)) ∈ A := | |
| ⟨S.coldFraction_mem hs₀ n,GeometricMesh.phase_bounds hη _,mem_univ _⟩ | |
| obtain ⟨p,hp,κ,hκ,hlim⟩ := hA.tendsto_subseq hmem | |
| change Tendsto (fun n => (S.coldFraction (κ n), | |
| (GeometricMesh.phase (s₀/S.radius (κ n)) η,S.normalizedHorizon (κ n)))) atTop (𝓝 p) at hlim | |
| have hl : Tendsto (fun n => S.coldFraction (κ n)) atTop (𝓝 p.1) := hlim.fst_nhds | |
| have hθ : Tendsto (fun n => GeometricMesh.phase (s₀/S.radius (κ n)) η) atTop (𝓝 p.2.1) := | |
| hlim.snd_nhds.fst_nhds | |
| have hU : Tendsto (fun n => S.normalizedHorizon (κ n)) atTop (𝓝 p.2.2) := hlim.snd_nhds.snd_nhds | |
| refine ⟨p.1,hp.1,p.2.1,hp.2.1,p.2.2,?_,κ,hκ,hl,hθ,hU⟩ | |
| have hlo := (lower_horizon_tendsto F.cold_ratio_tendsto).comp hκ.tendsto_atTop | |
| apply le_of_tendsto_of_tendsto' hlo hU | |
| intro n | |
| exact ENNReal.ofReal_le_ofReal (Cap.normalized_horizon_lower | |
| (shrinkingHorizon_pos F.horizonScale_pos (κ n)) (S.time_mem (κ n)) | |
| (DatumBounds.scale_pos hs₀ (F.indices (κ n)+1))) | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # Positivity, measurability and cap bounds of the actual hot remainder -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open BoltzmannNonuniqueness.WeightedLocal | |
| open BoltzmannNonuniqueness.WeightedLocalControl | |
| namespace BoltzmannNonuniqueness.JetCopyDatum | |
| def CapApproximation.hot {s₀ η K α γ d₀ q T : ℝ} {N : ℕ} | |
| (F : CapApproximation s₀ η K α γ d₀ q T N) (u : ℝ × JetPrototype.Phase) : ℝ := | |
| F.solution.value u-∑' i, rebuiltColdFamily q (N+1) (damping q (N+1) F.amplitude) T | |
| F.solution.value (color s₀ η K α γ d₀ q N) i u | |
| theorem CapApproximation.hot_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) : | |
| Measurable F.hot ∧ (∀ u, 0 ≤ F.hot u) ∧ | |
| ∀ t ∈ Icc 0 T, ∀ᵐ p ∂FlightMeasure.phaseVolume, | |
| F.hot (t,p) ≤ t+DatumBounds.scale s₀ η (N+1) := 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) | |
| have hhot := family_hot_bounds hq (by positivity : 0 ≤ (N+1:ℝ)) hR le_rfl | |
| F.solution.measurable_value hp.1 F.solution.value_bounds | |
| (fun i u => (hp.2.1 i u).1) hp.2.2.1 | |
| refine ⟨hhot.1,fun u => (hhot.2.1 u).1,?_⟩ | |
| exact PeriodicMildState.hot_bound_of_cap hq (by positivity : 0 ≤ (N+1:ℝ)) hL hT hR hδ le_rfl | |
| ((measurable_seed s₀ η K α γ d₀ q N).add | |
| ((HotSeedProfile.normalized_measurable q _).const_mul F.coefficient)) | |
| F.initial_bound (measurable_color s₀ η K α γ d₀ q N) hc₀ hi.2 F.solution F.cap.le | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| end | |
| end | |
| section | |
| /-! # Continuous essential size and the exact cap of a finite hot profile -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open BoltzmannNonuniqueness.WeightedLocal BoltzmannNonuniqueness.WeightedLocalControl | |
| namespace BoltzmannNonuniqueness.JetCopyDatum | |
| theorem CapApproximation.hot_regular {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) : | |
| Continuous (fun t => PhaseEssSup.size (fun p => F.hot (t,p))) ∧ | |
| ∀ t ∈ Icc 0 T, PhaseEssSup.size (fun p => F.hot (t,p)) ≤ | |
| t+DatumBounds.scale s₀ η (N+1) := 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 hreg := rebuilt_hot_continuous hq (by positivity : 0 ≤ (N+1:ℝ)) hL hT hR le_rfl | |
| F.solution.measurable_value | |
| ((measurable_seed s₀ η K α γ d₀ q N).add | |
| ((HotSeedProfile.normalized_measurable q _).const_mul F.coefficient)) | |
| (measurable_color s₀ η K α γ d₀ q N) F.solution.value_bounds F.initial_bound hc₀ hi.2 | |
| (F.solution.all_mild hT) | |
| have hclamp (t : ℝ) : (fun p => F.hot (PositiveIntegral.time T t,p)) = | |
| (fun p => F.hot (t,p)) := by | |
| funext p | |
| unfold CapApproximation.hot | |
| rw [F.solution.clamped (t,p)] | |
| congr 1 | |
| apply tsum_congr | |
| intro i | |
| exact rebuiltColdFamily_time_clamp hT q (N+1) (damping q (N+1) F.amplitude) | |
| F.solution.clamped (color s₀ η K α γ d₀ q N) i (t,p) | |
| have hcont := hreg.comp_continuous | |
| (show Continuous (PositiveIntegral.time T) by unfold PositiveIntegral.time; fun_prop) | |
| (fun t => PositiveIntegral.time_bounds hT t) | |
| change Continuous (fun t => PhaseEssSup.size (fun p => F.hot (PositiveIntegral.time T t,p))) at hcont | |
| refine ⟨?_,?_⟩ | |
| · simpa only [hclamp] using hcont | |
| · obtain ⟨_,_,_,hpeak⟩ := Cap.peak_attained hT hδ hreg | |
| intro t ht | |
| exact (div_le_one (by linarith [ht.1] : 0 < t+DatumBounds.scale s₀ η (N+1))).mp | |
| ((hpeak t ht).trans F.cap.le) | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| end | |
| end | |
| section | |
| /-! # Damping-free source bound for the actual finite cap solution -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open BoltzmannNonuniqueness.WeightedLocal BoltzmannNonuniqueness.WeightedLocalControl | |
| namespace BoltzmannNonuniqueness.JetCopyDatum | |
| def CapApproximation.hotNetSource {s₀ η K α γ d₀ q T : ℝ} {N : ℕ} | |
| (F : CapApproximation s₀ η K α γ d₀ q T N) (u : ℝ × JetPrototype.Phase) : ℝ := | |
| remainderForcing q (N+1) (damping q (N+1) F.amplitude) F.solution.value | |
| (rebuilt s₀ η K α γ d₀ q (N+1) (damping q (N+1) F.amplitude) T N F.solution.value) u- | |
| damping q (N+1) F.amplitude*F.hot u | |
| theorem CapApproximation.hot_net_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) (A : ℝ) | |
| (htail : ∀ t ∈ Ioc 0 T, | |
| JetEscapedEnvelope.constant s₀ η α K d₀ (JetEscapedEnvelope.exponent A)*t^A ≤ 1) : | |
| ∀ᵐ u ∂spacetimeVolume, u.1 ∈ Ioc 0 T → F.hotNetSource u ≤ | |
| scalarMajorant s₀ η K α γ d₀ q A N u.1 (PhaseEssSup.size (fun p => F.hot (u.1,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 | |
| have hi := initial_color_bounds hs₀ hsmax hη hηmax hK hd₀.le α γ 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 geometric_hot_net_source hcarleman hs₀ hsmax hη hηmax hK hα hαmax hγ hd₀ hd₀max | |
| hsmall hq₁ hq₂ hTmax A N F.solution.measurable_value hp.1 F.solution.value_bounds | |
| (fun i u => (hp.2.1 i u).1) hp.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)) | |
| F.solution.periodic (fun n i => rebuilt_shift n (F.solution.periodic n) i) | |
| (F.hot_regular hs₀ hsmax hη hηmax hK hd₀.le hq₂ hT).1.measurable htail | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| end | |
| end | |
| section | |
| /-! # A cutoff-independent upper bound for the actual hot net source -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| namespace BoltzmannNonuniqueness.JetCopyDatum | |
| theorem CapApproximation.hot_net_source_cap (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 ∂WeightedLocal.spacetimeVolume, u.1 ∈ Ioc 0 T → F.hotNetSource u ≤ | |
| 2*JetMainGain.coefficient K α γ q+ | |
| 2*HotApplication.realBound q*(u.1+DatumBounds.scale s₀ η (N+1))^2+ | |
| (2*JetMainGain.coefficient K α γ q+2*HotApplication.realBound q)* | |
| JetEscapedEnvelope.constant s₀ η α K d₀ | |
| (JetEscapedEnvelope.exponent (m+1 : ℕ))*u.1^m := by | |
| have he := JetEscapedEnvelope.constant_nonneg hs₀ hK hd₀ η α | |
| (JetEscapedEnvelope.exponent (m+1 : ℕ)) | |
| have htail' (t : ℝ) (ht : t ∈ Ioc 0 T) : | |
| JetEscapedEnvelope.constant s₀ η α K d₀ | |
| (JetEscapedEnvelope.exponent (m+1 : ℕ))*t^(m+1 : ℕ) ≤ 1 := | |
| tail_small he ht.1.le ht.2 htail | |
| have hb := F.hot_net_source_bound hcarleman hs₀ hsmax hη hηmax hK hα hαmax hγ | |
| hd₀ hd₀max hsmall hq₁ hq₂ hT hTmax (m+1 : ℕ) | |
| (by simpa only [Real.rpow_natCast] using htail') | |
| have hc := (F.hot_regular hs₀ hsmax hη hηmax hK hd₀.le hq₂ hT).2 | |
| filter_upwards [hb] with u hu hut | |
| apply (hu hut).trans | |
| rw [scalarMajorant_eq_source s₀ η K α γ d₀ q N m hut.1] | |
| simpa only [JetGeometry.jetScale] using ZeroProfile.source_le_cap | |
| (mul_nonneg (by norm_num) (JetMainGain.coefficient_nonneg hK α γ q)) | |
| (mul_nonneg (by norm_num) (HotApplication.realBound_pos q).le) | |
| (DatumBounds.scale_pos hs₀ (N+1)) hut.1.le (PhaseEssSup.size_nonneg _) | |
| (hc u.1 ⟨hut.1.le,hut.2⟩) m | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| end | |
| end | |
| section | |
| /-! # Every compact subinterval of the limiting horizon is eventually available -/ | |
| noncomputable section | |
| open Filter Set | |
| open scoped Topology ENNReal | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| theorem eventually_scaled_slab (S : AttainedCapSequence F) (hs₀ : 0 < s₀) | |
| {κ : ℕ → ℕ} {U : ℝ≥0∞} | |
| (hU : Tendsto (fun n => S.normalizedHorizon (κ n)) atTop (𝓝 U)) | |
| {A : ℝ} (hA : ENNReal.ofReal A < U) : | |
| ∀ᶠ n in atTop, ∀ t ∈ Icc (0:ℝ) A, | |
| S.radius (κ n)*t ∈ Icc 0 (shrinkingHorizon F.horizonScale (κ n)) := by | |
| filter_upwards [hU.eventually (lt_mem_nhds hA)] with n hn | |
| have hR := S.radius_pos hs₀ (κ n) | |
| have hT := shrinkingHorizon_pos F.horizonScale_pos (κ n) | |
| have hquot : A < shrinkingHorizon F.horizonScale (κ n)/S.radius (κ n) := | |
| (ENNReal.ofReal_lt_ofReal_iff (div_pos hT hR)).mp hn | |
| have htime : S.radius (κ n)*A < shrinkingHorizon F.horizonScale (κ n) := by | |
| have h := (lt_div_iff₀ hR).mp hquot | |
| simpa only [mul_comm] using h | |
| intro t ht | |
| exact ⟨mul_nonneg hR.le ht.1, | |
| (mul_le_mul_of_nonneg_left ht.2 hR.le).trans htime.le⟩ | |
| theorem eventually_scaled_time (S : AttainedCapSequence F) (hs₀ : 0 < s₀) | |
| {κ : ℕ → ℕ} {U : ℝ≥0∞} | |
| (hU : Tendsto (fun n => S.normalizedHorizon (κ n)) atTop (𝓝 U)) | |
| {t : ℝ} (ht : 0 < t) (htU : ENNReal.ofReal t < U) : | |
| ∀ᶠ n in atTop, S.radius (κ n)*t ∈ Ioc 0 (shrinkingHorizon F.horizonScale (κ n)) := by | |
| filter_upwards [S.eventually_scaled_slab hs₀ hU htU] with n hn | |
| exact ⟨mul_pos (S.radius_pos hs₀ _) ht,(hn t ⟨ht.le,le_rfl⟩).2⟩ | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # Physical hot densities under the attained cap dilation -/ | |
| 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} | |
| def rescaledHot (S : AttainedCapSequence F) (n : ℕ) (u : ℝ × JetPrototype.Phase) : ℝ := | |
| H q u.2.2 * (F.approximation n).hot | |
| (S.radius n*u.1,(S.radius n • u.2.1,u.2.2)) / S.radius n | |
| theorem rescaledHot_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.rescaledHot n) := by | |
| have hm := ((F.approximation n).hot_properties hs₀ hsmax hη hηmax hK hd₀ hq | |
| (shrinkingHorizon_pos F.horizonScale_pos n).le).1 | |
| have hc : Measurable (fun u : ℝ × JetPrototype.Phase => | |
| (S.radius n*u.1,(S.radius n • u.2.1,u.2.2))) := by fun_prop | |
| exact (((ChartKernel.measurable_H q).comp measurable_snd.snd).mul (hm.comp hc)).div_const _ | |
| theorem rescaledHot_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 : ℕ) (u : ℝ × JetPrototype.Phase) : | |
| 0 ≤ S.rescaledHot n u := by | |
| have hp := ((F.approximation n).hot_properties hs₀ hsmax hη hηmax hK hd₀ hq | |
| (shrinkingHorizon_pos F.horizonScale_pos n).le).2.1 | |
| exact div_nonneg (mul_nonneg (H_nonneg q _) (hp _)) (S.radius_pos hs₀ n).le | |
| theorem rescaledHot_bound_at (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 : ℕ) {t : ℝ} | |
| (ht : S.radius n*t ∈ Icc 0 (shrinkingHorizon F.horizonScale n)) : | |
| ∀ᵐ p ∂FlightMeasure.phaseVolume, | |
| S.rescaledHot n (t,p) ≤ (t+S.coldFraction n)*H q p.2 := by | |
| have hb := ((F.approximation n).hot_properties hs₀ hsmax hη hηmax hK hd₀ hq | |
| (shrinkingHorizon_pos F.horizonScale_pos n).le).2.2 _ ht | |
| have hr := S.radius_pos hs₀ n | |
| filter_upwards [(ColdDilationMeasure.spatial_dilation_quasiMeasurePreserving hr).ae hb] | |
| with p hp | |
| calc | |
| S.rescaledHot n (t,p) ≤ H q p.2 * | |
| (S.radius n*t+DatumBounds.scale s₀ η (F.indices n+1))/S.radius n := | |
| div_le_div_of_nonneg_right (mul_le_mul_of_nonneg_left hp (H_nonneg q _)) hr.le | |
| _ = (t+S.coldFraction n)*H q p.2 := by | |
| unfold coldFraction | |
| field_simp | |
| theorem eventually_rescaledHot_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, ∀ t ∈ Icc (0:ℝ) A, ∀ᵐ p ∂FlightMeasure.phaseVolume, | |
| S.rescaledHot (κ n) (t,p) ≤ (A+1)*H q p.2 := by | |
| filter_upwards [S.eventually_scaled_slab hs₀ hU hA] with n hn | |
| intro t ht | |
| filter_upwards [S.rescaledHot_bound_at hs₀ hsmax hη hηmax hK hd₀ hq (κ n) (hn t ht)] | |
| with p hp | |
| exact hp.trans (mul_le_mul_of_nonneg_right | |
| (add_le_add ht.2 (S.coldFraction_mem hs₀ _).2) (H_nonneg q _)) | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # Zero extension of rescaled hot densities beyond their physical horizons -/ | |
| 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} | |
| def hotTimeDomain (S : AttainedCapSequence F) (n : ℕ) : Set (ℝ × JetPrototype.Phase) := | |
| {u | S.radius n*u.1 ∈ Icc 0 (shrinkingHorizon F.horizonScale n)} | |
| theorem hotTimeDomain_measurable (S : AttainedCapSequence F) (n : ℕ) : | |
| MeasurableSet (S.hotTimeDomain n) := | |
| measurableSet_Icc.preimage (measurable_const.mul measurable_fst) | |
| def extendedHot (S : AttainedCapSequence F) (n : ℕ) : ℝ × JetPrototype.Phase → ℝ := | |
| (S.hotTimeDomain n).indicator (S.rescaledHot n) | |
| theorem extendedHot_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.extendedHot n) := | |
| (S.rescaledHot_measurable hs₀ hsmax hη hηmax hK hd₀ hq n).indicator | |
| (S.hotTimeDomain_measurable n) | |
| theorem extendedHot_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 : ℕ) (u : ℝ × JetPrototype.Phase) : | |
| 0 ≤ S.extendedHot n u := | |
| indicator_nonneg (fun u _ => S.rescaledHot_nonneg hs₀ hsmax hη hηmax hK hd₀ hq n u) u | |
| theorem extendedHot_bound_at (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 : ℕ) {t : ℝ} (ht : 0 ≤ t) : | |
| ∀ᵐ p ∂FlightMeasure.phaseVolume, | |
| S.extendedHot n (t,p) ≤ (t+S.coldFraction n)*H q p.2 := by | |
| by_cases hmem : S.radius n*t ∈ Icc 0 (shrinkingHorizon F.horizonScale n) | |
| · simpa only [extendedHot,indicator_of_mem (show (t,_) ∈ S.hotTimeDomain n from hmem)] | |
| using S.rescaledHot_bound_at hs₀ hsmax hη hηmax hK hd₀ hq n hmem | |
| · filter_upwards [] with p | |
| rw [extendedHot,indicator_of_notMem (show (t,p) ∉ S.hotTimeDomain n from hmem)] | |
| exact mul_nonneg (add_nonneg ht (S.coldFraction_mem hs₀ n).1) (H_nonneg q _) | |
| theorem extendedHot_uniform_bound_at (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 t : ℝ} | |
| (ht : t ∈ Icc (0:ℝ) A) : | |
| ∀ᵐ p ∂FlightMeasure.phaseVolume, S.extendedHot n (t,p) ≤ (A+1)*H q p.2 := by | |
| filter_upwards [S.extendedHot_bound_at hs₀ hsmax hη hηmax hK hd₀ hq n ht.1] with p hp | |
| exact hp.trans (mul_le_mul_of_nonneg_right | |
| (add_le_add ht.2 (S.coldFraction_mem hs₀ n).2) (H_nonneg q _)) | |
| theorem eventually_extendedHot_eq (S : AttainedCapSequence F) (hs₀ : 0 < s₀) | |
| {κ : ℕ → ℕ} {U : ℝ≥0∞} | |
| (hU : Tendsto (fun n => S.normalizedHorizon (κ n)) atTop (𝓝 U)) | |
| {A : ℝ} (hA : ENNReal.ofReal A < U) : | |
| ∀ᶠ n in atTop, ∀ t ∈ Icc (0:ℝ) A, ∀ p, | |
| S.extendedHot (κ n) (t,p) = S.rescaledHot (κ n) (t,p) := by | |
| filter_upwards [S.eventually_scaled_slab hs₀ hU hA] with n hn | |
| intro t ht p | |
| exact indicator_of_mem (show (t,p) ∈ S.hotTimeDomain (κ n) from hn t ht) _ | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # Local uniform integrability of the actual dilated hot sequence -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open scoped ENNReal | |
| open BoltzmannNonuniqueness.VelocityWeight | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| abbrev HotKineticPhase := (ℝ × JetPrototype.Space) × Velocity | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| def hotDensity (S : AttainedCapSequence F) (n : ℕ) (z : HotKineticPhase) : ℝ := | |
| S.extendedHot n (z.1.1,(z.1.2,z.2)) | |
| def hotWindowVolume (A R : ℝ) : Measure HotKineticPhase := | |
| ((volume.restrict (Icc (0:ℝ) A)).prod | |
| (volume.restrict (Metric.closedBall (0 : JetPrototype.Space) R))).prod volume | |
| theorem hotDensity_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.hotDensity n) := | |
| (S.extendedHot_measurable hs₀ hsmax hη hηmax hK hd₀ hq n).comp | |
| (by fun_prop) | |
| theorem hotDensity_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 : HotKineticPhase) : | |
| 0 ≤ S.hotDensity n z := | |
| S.extendedHot_nonneg hs₀ hsmax hη hηmax hK hd₀ hq n _ | |
| theorem hotDensity_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 ≤ (A+1)*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 ≤ (A+1)*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) | |
| (((ChartKernel.measurable_H q).comp measurable_snd.snd).const_mul _))).mpr | |
| filter_upwards [ae_restrict_mem measurableSet_Icc] with t ht | |
| have hb := S.extendedHot_uniform_bound_at hs₀ hsmax hη hηmax hK hd₀ hq n ht | |
| 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_majorant_integrable {q : ℝ} (hq : q < 2) (A R : ℝ) : | |
| Integrable (fun z : HotKineticPhase => (A+1)*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).const_mul (A+1)).comp_snd _ | |
| theorem hotDensity_uniformIntegrable (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 : ℝ) : | |
| UniformIntegrable S.hotDensity 1 (hotWindowVolume A R) := by | |
| apply CollisionCompactness.uniformIntegrable_mono_nonneg | |
| (uniformIntegrable_const (by norm_num) (by norm_num) | |
| (memLp_one_iff_integrable.mpr (hot_majorant_integrable hq A R))) | |
| (fun n => (S.hotDensity_measurable hs₀ hsmax hη hηmax hK hd₀ hq n).aestronglyMeasurable) | |
| (fun n => ae_of_all _ (S.hotDensity_nonneg hs₀ hsmax hη hηmax hK hd₀ hq n)) | |
| exact fun n => S.hotDensity_bound hs₀ hsmax hη hηmax hK hd₀ hq n A R | |
| theorem hotDensity_unifTight (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 : ℝ} (hA : 0 ≤ A) (R : ℝ) : | |
| UnifTight S.hotDensity 1 (hotWindowVolume A R) := by | |
| apply Compactness.unifTight_of_integrable_majorant (hot_majorant_integrable hq A R) | |
| (fun n => (S.hotDensity_measurable hs₀ hsmax hη hηmax hK hd₀ hq n).aestronglyMeasurable) | |
| intro n | |
| filter_upwards [S.hotDensity_bound hs₀ hsmax hη hηmax hK hd₀ hq n A R] with z hz | |
| apply enorm_le_iff_norm_le.mpr | |
| rw [Real.norm_of_nonneg (S.hotDensity_nonneg hs₀ hsmax hη hηmax hK hd₀ hq n z), | |
| Real.norm_of_nonneg (mul_nonneg (by linarith) (H_nonneg q _))] | |
| exact hz | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # Uniform integrability and tightness of the actual dilated hot pairs -/ | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped ENNReal | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| abbrev HotPairPhase := (ℝ × JetPrototype.Space) × (Velocity × Velocity) | |
| def hotBaseWindowVolume (A R : ℝ) : Measure (ℝ × JetPrototype.Space) := | |
| (volume.restrict (Icc (0:ℝ) A)).prod | |
| (volume.restrict (Metric.closedBall (0 : JetPrototype.Space) R)) | |
| def hotPairWindowVolume (A R : ℝ) : Measure HotPairPhase := | |
| (hotBaseWindowVolume A R).prod volume | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| theorem hotPair_bounds (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 : ℝ} (hA : 0 ≤ A) (R : ℝ) : | |
| UniformIntegrable (fun n => CollisionCompactness.pairProduct (S.hotDensity n)) 1 | |
| (hotPairWindowVolume A R) ∧ | |
| UnifTight (fun n => CollisionCompactness.pairProduct (S.hotDensity n)) 1 | |
| (hotPairWindowVolume A R) := by | |
| have : IsFiniteMeasure ((volume : Measure JetPrototype.Space).restrict | |
| (Metric.closedBall 0 R)) := | |
| isFiniteMeasure_restrict.mpr (isCompact_closedBall (0 : JetPrototype.Space) R).measure_lt_top.ne | |
| have : IsFiniteMeasure (hotBaseWindowVolume A R) := by | |
| unfold hotBaseWindowVolume | |
| infer_instance | |
| have hm n := S.hotDensity_measurable hs₀ hsmax hη hηmax hK hd₀ hq n | |
| have hn n := S.hotDensity_nonneg hs₀ hsmax hη hηmax hK hd₀ hq n | |
| have hb n : ∀ᵐ x ∂hotBaseWindowVolume A R, ∀ᵐ v : Velocity, | |
| x ∉ (∅ : Set (ℝ × JetPrototype.Space)) → | |
| S.hotDensity n (x,v) ≤ (A+1)*VelocityWeight.H q v := by | |
| have ht := Measure.ae_ae_of_ae_prod | |
| (S.hotDensity_bound hs₀ hsmax hη hηmax hK hd₀ hq n A R) | |
| filter_upwards [ht] with x hx | |
| exact hx.mono (fun _ h _ => h) | |
| have hui := CollisionCompactness.outer_pairs_uniformIntegrable hq | |
| (by linarith : 0 ≤ A+1) MeasurableSet.empty hm hn hb | |
| have ht := CollisionCompactness.outer_pairs_unifTight hq | |
| (by linarith : 0 ≤ A+1) hm hn MeasurableSet.empty hb | |
| simp only [Compactness.outerCutoff,compl_empty,preimage_univ,indicator_univ] at hui ht | |
| exact ⟨CollisionCompactness.pairProduct_uniformIntegrable hm hn hui, | |
| CollisionCompactness.pairProduct_unifTight hm hn ht⟩ | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # Compactness bounds for the hard-sphere weighted hot pair density -/ | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped ENNReal | |
| namespace BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| variable {s₀ η K α γ d₀ q : ℝ} {F : ShrinkingCapFamily s₀ η K α γ d₀ q} | |
| theorem hotWeightedPair_bounds (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 : ℝ} (hA : 0 ≤ A) (R : ℝ) : | |
| UniformIntegrable (fun n => CollisionCompactness.pairDensity (S.hotDensity n)) 1 | |
| (hotPairWindowVolume A R) ∧ | |
| UnifTight (fun n => CollisionCompactness.pairDensity (S.hotDensity n)) 1 | |
| (hotPairWindowVolume A R) := by | |
| have : IsFiniteMeasure ((volume : Measure JetPrototype.Space).restrict | |
| (Metric.closedBall 0 R)) := | |
| isFiniteMeasure_restrict.mpr (isCompact_closedBall (0 : JetPrototype.Space) R).measure_lt_top.ne | |
| have : IsFiniteMeasure (hotBaseWindowVolume A R) := by | |
| unfold hotBaseWindowVolume | |
| infer_instance | |
| have hm n := S.hotDensity_measurable hs₀ hsmax hη hηmax hK hd₀ hq n | |
| have hn n := S.hotDensity_nonneg hs₀ hsmax hη hηmax hK hd₀ hq n | |
| have hb n : ∀ᵐ x ∂hotBaseWindowVolume A R, ∀ᵐ v : Velocity, | |
| x ∉ (∅ : Set (ℝ × JetPrototype.Space)) → | |
| S.hotDensity n (x,v) ≤ (A+1)*VelocityWeight.H q v := by | |
| have ht := Measure.ae_ae_of_ae_prod | |
| (S.hotDensity_bound hs₀ hsmax hη hηmax hK hd₀ hq n A R) | |
| filter_upwards [ht] with x hx | |
| exact hx.mono (fun _ h _ => h) | |
| have hui := CollisionCompactness.outer_pairs_uniformIntegrable hq | |
| (by linarith : 0 ≤ A+1) MeasurableSet.empty hm hn hb | |
| have ht := CollisionCompactness.outer_pairs_unifTight hq | |
| (by linarith : 0 ≤ A+1) hm hn MeasurableSet.empty hb | |
| simp only [Compactness.outerCutoff,compl_empty,preimage_univ,indicator_univ] at hui ht | |
| exact ⟨hui,ht⟩ | |
| end BoltzmannNonuniqueness.JetCopyDatum.AttainedCapSequence | |
| end | |
| end | |
| section | |
| /-! # The actual hot cap as a spacetime almost-everywhere estimate -/ | |
| noncomputable section | |
| open MeasureTheory MeasureTheory.Measure Set | |
| open BoltzmannNonuniqueness.WeightedLocal | |
| namespace BoltzmannNonuniqueness.JetCopyDatum | |
| theorem CapApproximation.hot_spacetime_cap {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) : | |
| ∀ᵐ u ∂spacetimeVolume, u.1 ∈ Icc 0 T → | |
| F.hot u ≤ u.1+DatumBounds.scale s₀ η (N+1) := by | |
| have hp := F.hot_properties hs₀ hsmax hη hηmax hK hd₀ hq hT | |
| have hm : MeasurableSet {u : ℝ × JetPrototype.Phase | u.1 ∈ Icc 0 T → | |
| F.hot u ≤ u.1+DatumBounds.scale s₀ η (N+1)} := by | |
| simp only [imp_iff_not_or] | |
| exact (measurableSet_Icc.preimage measurable_fst).compl.union | |
| (measurableSet_le hp.1 (measurable_fst.add measurable_const)) | |
| apply (ae_prod_iff_ae_ae hm).mpr | |
| apply ae_of_all | |
| intro t | |
| by_cases ht : t ∈ Icc 0 T | |
| · exact (hp.2.2 t ht).mono (fun _ h _ => h) | |
| · exact ae_of_all _ (fun _ h => (ht h).elim) | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| end | |
| end | |
| end OAI | |