openAI-math-dataset / lean /OAI /MathematicalPhysics /Boltzmann /Approximation /MildCharacteristics.lean
| import OAI.MathematicalPhysics.Boltzmann.Approximation.PositiveIntegralPasting | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.AttenuationGap | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.DampedBranchingBlocks | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.PeriodicMildApproximation | |
| import OAI.MathematicalPhysics.Boltzmann.Jets.SpatialDilationAE | |
| namespace OAI | |
| section | |
| /-! # The weak characteristic equation of the constructed mild states -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open BoltzmannNonuniqueness.WeightedLocal | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| theorem value_along_flight {T t : ℝ} (ht : t ∈ Icc 0 T) (L : ℝ) | |
| (f₀ : JetPrototype.Phase → ℝ) (g : ℝ × JetPrototype.Phase → ℝ) | |
| (p : JetPrototype.Phase) : | |
| value T L JetBarrier.flight f₀ g (t,JetBarrier.flight t p) = | |
| TransportPrimitive.damped L (f₀ p) (fun r => g (r,JetBarrier.flight r p)) t := by | |
| rw [TransportPrimitive.damped_eq] | |
| unfold value | |
| rw [GaussianLocal.time_eq ht,JetFreeTransport.neg_flight] | |
| congr 1 | |
| apply intervalIntegral.integral_congr | |
| intro r _ | |
| dsimp only | |
| rw [JetFreeTransport.flight_add,sub_add_cancel] | |
| /-- The integral form of the transport equation, along almost every characteristic. | |
| The source is only required to be measurable and bounded. -/ | |
| theorem weak_characteristic {T L S : ℝ} (hT : 0 ≤ T) | |
| {f₀ : JetPrototype.Phase → ℝ} (hf₀ : Measurable f₀) | |
| {F g : ℝ × JetPrototype.Phase → ℝ} (hFm : Measurable F) (hgm : Measurable g) | |
| (hg : ∀ z, |g z| ≤ S) | |
| (hmild : ∀ t ∈ Icc 0 T, (fun p => F (t,p)) =ᵐ[FlightMeasure.phaseVolume] | |
| (fun p => value T L JetBarrier.flight f₀ g (t,p))) | |
| {ψ ψ' : ℝ → ℝ} (hψ : ContinuousOn ψ (Icc 0 T)) | |
| (hψ' : ContinuousOn ψ' (Icc 0 T)) | |
| (hdψ : ∀ t ∈ Icc 0 T, HasDerivAt ψ (ψ' t) t) : | |
| ∀ᵐ p ∂FlightMeasure.phaseVolume, | |
| (∫ t in 0..T, ψ' t*F (t,JetBarrier.flight t p) + | |
| ψ t*(g (t,JetBarrier.flight t p)-L*F (t,JetBarrier.flight t p))) = | |
| ψ T*F (T,JetBarrier.flight T p)-ψ 0*f₀ p := by | |
| let A : ℝ × JetPrototype.Phase → ℝ := fun z => F (z.1,JetBarrier.flight z.1 z.2) | |
| let B : ℝ × JetPrototype.Phase → ℝ := fun z => | |
| value T L JetBarrier.flight f₀ g (z.1,JetBarrier.flight z.1 z.2) | |
| have hflow : Measurable (fun z : ℝ × JetPrototype.Phase => | |
| (z.1,JetBarrier.flight z.1 z.2)) := | |
| measurable_fst.prodMk GaussianLocal.measurable_flight | |
| have hAm : Measurable A := hFm.comp hflow | |
| have hBm : Measurable B := | |
| (measurable_value hT GaussianLocal.measurable_flight hf₀ hgm).comp hflow | |
| have hslice (t : ℝ) (ht : t ∈ Icc 0 T) : | |
| (fun p => A (t,p)) =ᵐ[FlightMeasure.phaseVolume] (fun p => B (t,p)) := | |
| (FlightMeasure.flight_measurePreserving t).quasiMeasurePreserving.ae (hmild t ht) | |
| have hall : A =ᵐ[(volume.restrict (Icc 0 T)).prod FlightMeasure.phaseVolume] B := by | |
| apply (Measure.ae_prod_iff_ae_ae (measurableSet_eq_fun hAm hBm)).mpr | |
| filter_upwards [ae_restrict_mem measurableSet_Icc] with t ht | |
| exact hslice t ht | |
| have hp := Measure.ae_ae_of_ae_prod | |
| ((Measure.measurePreserving_swap (μ := FlightMeasure.phaseVolume) | |
| (ν := volume.restrict (Icc 0 T))).quasiMeasurePreserving.ae hall) | |
| filter_upwards [hp,hslice T ⟨hT,le_rfl⟩] with p hpe hpend | |
| have hgi : IntervalIntegrable (fun t => g (t,JetBarrier.flight t p)) volume 0 T := by | |
| apply (intervalIntegrable_const (c := S)).mono_fun' | |
| · exact (hgm.comp (measurable_id.prodMk | |
| (GaussianLocal.measurable_flight.comp (measurable_id.prodMk measurable_const)))).aestronglyMeasurable | |
| · exact ae_of_all _ (fun t => by simpa only [Real.norm_eq_abs] using hg (t,JetBarrier.flight t p)) | |
| have H := TransportPrimitive.damped_integration_by_parts hT hgi hψ hψ' hdψ | |
| (L := L) (c := f₀ p) | |
| have he : (fun t => F (t,JetBarrier.flight t p)) =ᵐ[volume.restrict (Icc 0 T)] | |
| (fun t => TransportPrimitive.damped L (f₀ p) (fun r => g (r,JetBarrier.flight r p)) t) := by | |
| filter_upwards [hpe,ae_restrict_mem measurableSet_Icc] with t ht htm | |
| exact ht.trans (value_along_flight htm L f₀ g p) | |
| have hboundary : F (T,JetBarrier.flight T p) = | |
| TransportPrimitive.damped L (f₀ p) (fun r => g (r,JetBarrier.flight r p)) T := | |
| hpend.trans (value_along_flight ⟨hT,le_rfl⟩ L f₀ g p) | |
| rw [hboundary] | |
| rw [← H] | |
| rw [intervalIntegral.integral_of_le hT,intervalIntegral.integral_of_le hT] | |
| apply integral_congr_ae | |
| have he' := ae_restrict_of_ae_restrict_of_subset Ioc_subset_Icc_self he | |
| filter_upwards [he'] with t ht | |
| rw [ht] | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # Difference estimate for the positive mild iteration along a free path -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open BoltzmannNonuniqueness.JetPrototype | |
| namespace BoltzmannNonuniqueness.MildStability | |
| def value (f₀ : ℝ) (ν : ℝ → JetPrototype.Phase → ℝ) (g : ℝ → ℝ) | |
| (t : ℝ) (p : JetPrototype.Phase) : ℝ := | |
| f₀ * JetPicardComparison.attenuation ν 0 t p + | |
| ∫ r in 0..t, JetPicardComparison.attenuation ν r t p * g r | |
| private theorem product_difference {a b c d E M F : ℝ} | |
| (ha : |a| ≤ 1) (hcd : |c - d| ≤ E) (hd : |d| ≤ M) (hab : |a - b| ≤ F) | |
| (hF : 0 ≤ F) : |a * c - b * d| ≤ E + F * M := by | |
| calc | |
| _ = |a * (c - d) + (a - b) * d| := by congr 1; ring | |
| _ ≤ |a| * |c - d| + |a - b| * |d| := by simpa only [abs_mul] using abs_add_le (a * (c - d)) ((a - b) * d) | |
| _ ≤ 1 * E + F * M := add_le_add | |
| (mul_le_mul ha hcd (abs_nonneg _) (by norm_num)) | |
| (mul_le_mul hab hd (abs_nonneg _) hF) | |
| _ = _ := by ring | |
| theorem difference {ν μ : ℝ → JetPrototype.Phase → ℝ} {g h : ℝ → ℝ} | |
| {f₀ k₀ I A E M D t : ℝ} (ht : 0 ≤ t) (hD : 0 ≤ D) | |
| (p : JetPrototype.Phase) | |
| (hν : ∀ r ∈ Icc 0 t, 0 ≤ ν r (JetBarrier.flight r p)) | |
| (hμ : ∀ r ∈ Icc 0 t, 0 ≤ μ r (JetBarrier.flight r p)) | |
| (hνi : IntervalIntegrable (fun r => ν r (JetBarrier.flight r p)) volume 0 t) | |
| (hμi : IntervalIntegrable (fun r => μ r (JetBarrier.flight r p)) volume 0 t) | |
| (hνμ : ∀ r ∈ Icc 0 t, |ν r (JetBarrier.flight r p) - μ r (JetBarrier.flight r p)| ≤ D) | |
| (hfk : |f₀ - k₀| ≤ I) (hk : |k₀| ≤ A) | |
| (hgh : ∀ r ∈ Icc 0 t, |g r - h r| ≤ E) (hh : ∀ r ∈ Icc 0 t, |h r| ≤ M) | |
| (hgi : IntervalIntegrable (fun r => JetPicardComparison.attenuation ν r t p * g r) volume 0 t) | |
| (hhi : IntervalIntegrable (fun r => JetPicardComparison.attenuation μ r t p * h r) volume 0 t) : | |
| |value f₀ ν g t p - value k₀ μ h t p| ≤ I + D * t * A + (E + D * t * M) * t := by | |
| have hνsub (r : ℝ) (hr : r ∈ Icc 0 t) : | |
| IntervalIntegrable (fun τ => ν τ (JetBarrier.flight τ p)) volume r t := by | |
| apply hνi.mono_set | |
| rw [uIcc_of_le hr.2, uIcc_of_le ht] | |
| exact Icc_subset_Icc hr.1 le_rfl | |
| have hμsub (r : ℝ) (hr : r ∈ Icc 0 t) : | |
| IntervalIntegrable (fun τ => μ τ (JetBarrier.flight τ p)) volume r t := by | |
| apply hμi.mono_set | |
| rw [uIcc_of_le hr.2, uIcc_of_le ht] | |
| exact Icc_subset_Icc hr.1 le_rfl | |
| have had (r : ℝ) (hr : r ∈ Icc 0 t) : | |
| |JetPicardComparison.attenuation ν r t p - JetPicardComparison.attenuation μ r t p| ≤ D * t := by | |
| apply (AttenuationLipschitz.attenuation_difference_le hr.2 p | |
| (fun τ hτ => hν τ ⟨hr.1.trans hτ.1, hτ.2⟩) | |
| (fun τ hτ => hμ τ ⟨hr.1.trans hτ.1, hτ.2⟩) | |
| (hνsub r hr) (hμsub r hr) (fun τ hτ => hνμ τ ⟨hr.1.trans hτ.1, hτ.2⟩)).trans | |
| exact mul_le_mul_of_nonneg_left (sub_le_self t hr.1) hD | |
| have han (r : ℝ) (hr : r ∈ Icc 0 t) : |JetPicardComparison.attenuation ν r t p| ≤ 1 := by | |
| rw [abs_of_nonneg (JetPicardComparison.attenuation_nonneg _ _ _ _)] | |
| exact JetPicardComparison.attenuation_le_one hr.2 (fun τ hτ => hν τ ⟨hr.1.trans hτ.1, hτ.2⟩) | |
| have hinitial : |f₀ * JetPicardComparison.attenuation ν 0 t p - | |
| k₀ * JetPicardComparison.attenuation μ 0 t p| ≤ I + D * t * A := by | |
| simpa only [mul_comm f₀, mul_comm k₀] using product_difference (han 0 ⟨le_rfl, ht⟩) | |
| hfk hk (had 0 ⟨le_rfl, ht⟩) (mul_nonneg hD ht) | |
| have hpoint (r : ℝ) (hr : r ∈ Icc 0 t) : | |
| |JetPicardComparison.attenuation ν r t p * g r - | |
| JetPicardComparison.attenuation μ r t p * h r| ≤ E + D * t * M := | |
| product_difference (han r hr) (hgh r hr) (hh r hr) (had r hr) (mul_nonneg hD ht) | |
| have hint : |(∫ r in 0..t, JetPicardComparison.attenuation ν r t p * g r) - | |
| ∫ r in 0..t, JetPicardComparison.attenuation μ r t p * h r| ≤ (E + D * t * M) * t := by | |
| rw [← intervalIntegral.integral_sub hgi hhi] | |
| apply (intervalIntegral.abs_integral_le_integral_abs ht).trans | |
| calc | |
| _ ≤ ∫ _r in 0..t, E + D * t * M := | |
| intervalIntegral.integral_mono_on ht (hgi.sub hhi).abs intervalIntegrable_const hpoint | |
| _ = _ := by rw [intervalIntegral.integral_const]; simp only [sub_zero, smul_eq_mul]; ring | |
| calc | |
| _ = |(f₀ * JetPicardComparison.attenuation ν 0 t p - k₀ * JetPicardComparison.attenuation μ 0 t p) + | |
| ((∫ r in 0..t, JetPicardComparison.attenuation ν r t p * g r) - | |
| ∫ r in 0..t, JetPicardComparison.attenuation μ r t p * h r)| := by unfold value; congr 1; ring | |
| _ ≤ _ := (abs_add_le _ _).trans (add_le_add hinitial hint) | |
| end BoltzmannNonuniqueness.MildStability | |
| end | |
| end | |
| section | |
| /-! # Exact dilation of the damped characteristic integral -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| def scalePhase (r : ℝ) (p : JetPrototype.Phase) : JetPrototype.Phase := (r • p.1,p.2) | |
| theorem scalePhase_flight (r t : ℝ) (p : JetPrototype.Phase) : | |
| scalePhase r (JetBarrier.flight t p) = JetBarrier.flight (r*t) (scalePhase r p) := by | |
| apply Prod.ext | |
| · apply Prod.ext | |
| · change r • (p.1.1+t • VelocityWeight.transverse p.2) = | |
| r • p.1.1+(r*t) • VelocityWeight.transverse p.2 | |
| rw [smul_add,mul_smul] | |
| · change r*(p.1.2+t*VelocityWeight.axial p.2) = r*p.1.2+(r*t)*VelocityWeight.axial p.2 | |
| ring | |
| · rfl | |
| theorem value_dilation {r T t : ℝ} (hr : 0 < r) (ht : t ∈ Icc 0 T) | |
| (L : ℝ) (f₀ : JetPrototype.Phase → ℝ) (g : ℝ × JetPrototype.Phase → ℝ) | |
| (p : JetPrototype.Phase) : | |
| value (r*T) L JetBarrier.flight f₀ g (r*t,scalePhase r p)/r = | |
| value T (r*L) JetBarrier.flight (fun p => f₀ (scalePhase r p)/r) | |
| (fun u => g (r*u.1,scalePhase r u.2)) (t,p) := by | |
| have hrt : r*t ∈ Icc 0 (r*T) := | |
| ⟨mul_nonneg hr.le ht.1,mul_le_mul_of_nonneg_left ht.2 hr.le⟩ | |
| unfold value | |
| rw [GaussianLocal.time_eq hrt,GaussianLocal.time_eq ht] | |
| have hi := intervalIntegral.integral_comp_mul_left | |
| (fun s => Real.exp (-L*(r*t-s))*g (s,JetBarrier.flight (s-r*t) (scalePhase r p))) hr.ne' | |
| (a := 0) (b := t) | |
| simp only [mul_zero,smul_eq_mul,← div_eq_inv_mul] at hi | |
| rw [add_div,← hi] | |
| have he : -L*(r*t) = -(r*L)*t := by ring | |
| have hp : JetBarrier.flight (-(r*t)) (scalePhase r p) = scalePhase r (JetBarrier.flight (-t) p) := by | |
| rw [scalePhase_flight] | |
| congr 1 | |
| ring | |
| rw [he,hp] | |
| congr 1 | |
| · ring | |
| · apply intervalIntegral.integral_congr | |
| intro s _ | |
| have he : -L*(r*t-r*s) = -(r*L)*(t-s) := by ring | |
| have hp : JetBarrier.flight (r*s-r*t) (scalePhase r p) = scalePhase r (JetBarrier.flight (s-t) p) := by | |
| rw [scalePhase_flight] | |
| congr 1 | |
| ring | |
| dsimp only | |
| rw [he,hp] | |
| theorem mild_dilation {r U A L : ℝ} (hr : 0 < r) (hA : r*A ≤ U) | |
| {f₀ : JetPrototype.Phase → ℝ} {F g : ℝ × JetPrototype.Phase → ℝ} | |
| (hmild : ∀ t ∈ Icc 0 U, (fun p => F (t,p)) =ᵐ[FlightMeasure.phaseVolume] | |
| (fun p => value U L JetBarrier.flight f₀ g (t,p))) : | |
| ∀ t ∈ Icc 0 A, (fun p => F (r*t,scalePhase r p)/r) =ᵐ[FlightMeasure.phaseVolume] | |
| (fun p => value A (r*L) JetBarrier.flight (fun p => f₀ (scalePhase r p)/r) | |
| (fun u => g (r*u.1,scalePhase r u.2)) (t,p)) := by | |
| intro t ht | |
| have hrt : r*t ∈ Icc 0 (r*A) := | |
| ⟨mul_nonneg hr.le ht.1,mul_le_mul_of_nonneg_left ht.2 hr.le⟩ | |
| have htU : r*t ∈ Icc 0 U := ⟨hrt.1,hrt.2.trans hA⟩ | |
| have hae := (ColdDilationMeasure.spatial_dilation_quasiMeasurePreserving hr).ae (hmild (r*t) htU) | |
| filter_upwards [hae] with p hp | |
| calc | |
| F (r*t,scalePhase r p)/r = value U L JetBarrier.flight f₀ g (r*t,scalePhase r p)/r := | |
| congrArg (fun z : ℝ => z/r) hp | |
| _ = value (r*A) L JetBarrier.flight f₀ g (r*t,scalePhase r p)/r := | |
| congrArg (fun z : ℝ => z/r) (value_eq_at_time htU hrt.2 L f₀ (fun _ _ _ => rfl) _) | |
| _ = _ := value_dilation hr ht L f₀ g p | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # Characteristic localization of bounded measurable mild solutions -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| theorem characteristic_ae {T L : ℝ} (hT : 0 ≤ T) | |
| {f₀ : JetPrototype.Phase → ℝ} (hf₀ : Measurable f₀) | |
| {F g : ℝ × JetPrototype.Phase → ℝ} (hFm : Measurable F) (hgm : Measurable g) | |
| (hmild : ∀ t ∈ Icc 0 T, (fun p => F (t,p)) =ᵐ[FlightMeasure.phaseVolume] | |
| (fun p => value T L JetBarrier.flight f₀ g (t,p))) : | |
| ∀ᵐ p ∂FlightMeasure.phaseVolume, | |
| (fun t => F (t,JetBarrier.flight t p)) =ᵐ[volume.restrict (Icc 0 T)] | |
| (fun t => TransportPrimitive.damped L (f₀ p) | |
| (fun r => g (r,JetBarrier.flight r p)) t) := by | |
| let A : ℝ × JetPrototype.Phase → ℝ := fun z => F (z.1,JetBarrier.flight z.1 z.2) | |
| let B : ℝ × JetPrototype.Phase → ℝ := fun z => | |
| value T L JetBarrier.flight f₀ g (z.1,JetBarrier.flight z.1 z.2) | |
| have hflow : Measurable (fun z : ℝ × JetPrototype.Phase => | |
| (z.1,JetBarrier.flight z.1 z.2)) := | |
| measurable_fst.prodMk GaussianLocal.measurable_flight | |
| have hAm : Measurable A := hFm.comp hflow | |
| have hBm : Measurable B := | |
| (measurable_value hT GaussianLocal.measurable_flight hf₀ hgm).comp hflow | |
| have hall : A =ᵐ[(volume.restrict (Icc 0 T)).prod FlightMeasure.phaseVolume] B := by | |
| apply (Measure.ae_prod_iff_ae_ae (measurableSet_eq_fun hAm hBm)).mpr | |
| filter_upwards [ae_restrict_mem measurableSet_Icc] with t ht | |
| exact (FlightMeasure.flight_measurePreserving t).quasiMeasurePreserving.ae (hmild t ht) | |
| have hp := Measure.ae_ae_of_ae_prod | |
| ((Measure.measurePreserving_swap (μ := FlightMeasure.phaseVolume) | |
| (ν := volume.restrict (Icc 0 T))).quasiMeasurePreserving.ae hall) | |
| filter_upwards [hp] with p hpe | |
| filter_upwards [hpe,ae_restrict_mem measurableSet_Icc] with t ht htm | |
| exact ht.trans (value_along_flight htm L f₀ g p) | |
| /-- The damping parameter of the iteration cancels, leaving the physical | |
| source `g-L*F` plus the differentiated cutoff in a unit-damped formula. -/ | |
| theorem localized_characteristic {T L S : ℝ} (hT : 0 ≤ T) | |
| {f₀ : JetPrototype.Phase → ℝ} (hf₀ : Measurable f₀) | |
| {F g : ℝ × JetPrototype.Phase → ℝ} (hFm : Measurable F) (hgm : Measurable g) | |
| (hg : ∀ z, |g z| ≤ S) | |
| (hmild : ∀ t ∈ Icc 0 T, (fun p => F (t,p)) =ᵐ[FlightMeasure.phaseVolume] | |
| (fun p => value T L JetBarrier.flight f₀ g (t,p))) | |
| (χ χ' : 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 (T,JetBarrier.flight T p) = Real.exp (-T)*χ p 0*f₀ p + | |
| ∫ t in 0..T, Real.exp (-(T-t)) * | |
| (χ p t*(g (t,JetBarrier.flight t p)-L*F (t,JetBarrier.flight t p)) + | |
| (χ' p t+χ p t)*F (t,JetBarrier.flight t p)) := by | |
| have hp := characteristic_ae hT hf₀ hFm hgm hmild | |
| have ht := (FlightMeasure.flight_measurePreserving T).quasiMeasurePreserving.ae | |
| (hmild T ⟨hT,le_rfl⟩) | |
| filter_upwards [hp,ht] with p hpe hpend | |
| have hgi : IntervalIntegrable (fun t => g (t,JetBarrier.flight t p)) volume 0 T := by | |
| apply (intervalIntegrable_const (c := S)).mono_fun' | |
| · exact (hgm.comp (measurable_id.prodMk | |
| (GaussianLocal.measurable_flight.comp (measurable_id.prodMk measurable_const)))).aestronglyMeasurable | |
| · exact ae_of_all _ (fun t => by simpa only [Real.norm_eq_abs] using hg (t,JetBarrier.flight t p)) | |
| have H := TransportPrimitive.localized_damped hT hgi (hχ p) (hχ' p) (hdχ p) | |
| (L := L) (c := f₀ p) | |
| have hboundary := hpend.trans (value_along_flight ⟨hT,le_rfl⟩ L f₀ g p) | |
| rw [hboundary,H] | |
| congr 1 | |
| rw [intervalIntegral.integral_of_le hT,intervalIntegral.integral_of_le hT] | |
| apply integral_congr_ae | |
| have he := ae_restrict_of_ae_restrict_of_subset Ioc_subset_Icc_self hpe | |
| filter_upwards [he] with t ht | |
| rw [ht] | |
| congr 1 | |
| ring | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # Undamped test identities along bounded mild characteristics -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| theorem tested_characteristic {T L S : ℝ} (hT : 0 ≤ T) | |
| {f₀ : JetPrototype.Phase → ℝ} (hf₀ : Measurable f₀) | |
| {F g : ℝ × JetPrototype.Phase → ℝ} (hFm : Measurable F) (hgm : Measurable g) | |
| (hg : ∀ z, |g z| ≤ S) | |
| (hmild : ∀ t ∈ Icc 0 T, (fun p => F (t,p)) =ᵐ[FlightMeasure.phaseVolume] | |
| (fun p => value T L JetBarrier.flight f₀ g (t,p))) | |
| (χ χ' : 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, | |
| (∫ t in 0..T, χ' p t*F (t,JetBarrier.flight t p)+ | |
| χ p t*(g (t,JetBarrier.flight t p)-L*F (t,JetBarrier.flight t p))) = | |
| χ p T*F (T,JetBarrier.flight T p)-χ p 0*f₀ p := by | |
| have hp := characteristic_ae hT hf₀ hFm hgm hmild | |
| have ht := (FlightMeasure.flight_measurePreserving T).quasiMeasurePreserving.ae | |
| (hmild T ⟨hT,le_rfl⟩) | |
| filter_upwards [hp,ht] with p hpe hpend | |
| have hgi : IntervalIntegrable (fun t => g (t,JetBarrier.flight t p)) volume 0 T := by | |
| apply (intervalIntegrable_const (c := S)).mono_fun' | |
| · exact (hgm.comp (measurable_id.prodMk | |
| (GaussianLocal.measurable_flight.comp (measurable_id.prodMk measurable_const)))).aestronglyMeasurable | |
| · exact ae_of_all _ (fun t => by simpa only [Real.norm_eq_abs] using hg (t,JetBarrier.flight t p)) | |
| have H := TransportPrimitive.damped_integration_by_parts hT hgi (hχ p) (hχ' p) (hdχ p) | |
| (L := L) (c := f₀ p) | |
| have hb := hpend.trans (value_along_flight ⟨hT,le_rfl⟩ L f₀ g p) | |
| rw [hb] | |
| rw [← H] | |
| rw [intervalIntegral.integral_of_le hT,intervalIntegral.integral_of_le hT] | |
| apply integral_congr_ae | |
| have he := ae_restrict_of_ae_restrict_of_subset Ioc_subset_Icc_self hpe | |
| filter_upwards [he] with t ht | |
| rw [ht] | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # Survival of a positive datum under a bounded loss rate -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| theorem survival_characteristic {T L B : ℝ} (hT : 0 ≤ T) | |
| {f₀ : JetPrototype.Phase → ℝ} (hf₀ : Measurable f₀) | |
| {F g : ℝ × JetPrototype.Phase → ℝ} (hFm : Measurable F) (hgm : Measurable g) | |
| (hg : ∀ z, |g z| ≤ B) | |
| (hmild : ∀ t ∈ Icc 0 T, (fun p => F (t,p)) =ᵐ[FlightMeasure.phaseVolume] | |
| (fun p => value T L JetBarrier.flight f₀ g (t,p))) | |
| (C : JetPrototype.Phase → ℝ) | |
| (hlow : ∀ᵐ p ∂FlightMeasure.phaseVolume, ∀ᵐ t, t ∈ Ioc 0 T → | |
| -C p*F (t,JetBarrier.flight t p) ≤ | |
| g (t,JetBarrier.flight t p)-L*F (t,JetBarrier.flight t p)) : | |
| ∀ᵐ p ∂FlightMeasure.phaseVolume, | |
| Real.exp (-C p*T)*f₀ p ≤ F (T,JetBarrier.flight T p) := by | |
| have ht := tested_characteristic hT hf₀ hFm hgm hg hmild | |
| (fun p t => Real.exp (C p*t)) (fun p t => C p*Real.exp (C p*t)) | |
| (fun _ => (by fun_prop : Continuous _).continuousOn) | |
| (fun _ => (by fun_prop : Continuous _).continuousOn) | |
| (fun p t _ => by simpa [mul_comm] using ((hasDerivAt_id t).const_mul (C p)).exp) | |
| filter_upwards [ht,hlow] with p hp hpl | |
| have hi : 0 ≤ ∫ t in 0..T, C p*Real.exp (C p*t)*F (t,JetBarrier.flight t p)+ | |
| Real.exp (C p*t)*(g (t,JetBarrier.flight t p)-L*F (t,JetBarrier.flight t p)) := by | |
| apply intervalIntegral.integral_nonneg_of_ae_restrict hT | |
| rw [← Measure.restrict_congr_set (Ioc_ae_eq_Icc (μ := volume))] | |
| filter_upwards [ae_restrict_of_ae hpl,ae_restrict_mem measurableSet_Ioc] with t ht htm | |
| have h := mul_le_mul_of_nonneg_left (ht htm) (Real.exp_pos (C p*t)).le | |
| change 0 ≤ C p*Real.exp (C p*t)*F (t,JetBarrier.flight t p)+ | |
| Real.exp (C p*t)*(g (t,JetBarrier.flight t p)-L*F (t,JetBarrier.flight t p)) | |
| nlinarith only [h] | |
| rw [hp] at hi | |
| simp only [mul_zero,Real.exp_zero,one_mul] at hi | |
| have hm := mul_le_mul_of_nonneg_left (sub_nonneg.mp hi) (Real.exp_pos (-C p*T)).le | |
| have he : Real.exp (-C p*T)*Real.exp (C p*T) = 1 := by | |
| rw [← Real.exp_add]; ring_nf; simp | |
| simpa only [← mul_assoc,he,one_mul] using hm | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # Removing the auxiliary damping from an actual mild solution -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| theorem undamped_characteristic {T L S : ℝ} (hT : 0 ≤ T) | |
| {f₀ : JetPrototype.Phase → ℝ} (hf₀ : Measurable f₀) | |
| {F g : ℝ × JetPrototype.Phase → ℝ} (hFm : Measurable F) (hgm : Measurable g) | |
| (hg : ∀ z, |g z| ≤ S) | |
| (hmild : ∀ t ∈ Icc 0 T, (fun p => F (t,p)) =ᵐ[FlightMeasure.phaseVolume] | |
| (fun p => value T L JetBarrier.flight f₀ g (t,p))) : | |
| ∀ᵐ p ∂FlightMeasure.phaseVolume, | |
| F (T,JetBarrier.flight T p) = f₀ p+ | |
| ∫ t in 0..T, g (t,JetBarrier.flight t p)-L*F (t,JetBarrier.flight t p) := by | |
| have h := tested_characteristic hT hf₀ hFm hgm hg hmild | |
| (fun _ _ => 1) (fun _ _ => 0) | |
| (fun _ => continuous_const.continuousOn) (fun _ => continuous_const.continuousOn) | |
| (fun _ t _ => hasDerivAt_const t (1:ℝ)) | |
| filter_upwards [h] with p hp | |
| simp only [zero_mul,one_mul,zero_add] at hp | |
| linarith | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # The undamped source is integrable along almost every finite characteristic -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| theorem netSource_integrable_characteristic {T L S : ℝ} (hT : 0 ≤ T) | |
| {f₀ : JetPrototype.Phase → ℝ} (hf₀ : Measurable f₀) | |
| {F g : ℝ × JetPrototype.Phase → ℝ} (hFm : Measurable F) (hgm : Measurable g) | |
| (hg : ∀ z, |g z| ≤ S) | |
| (hmild : ∀ t ∈ Icc 0 T, (fun p => F (t,p)) =ᵐ[FlightMeasure.phaseVolume] | |
| (fun p => value T L JetBarrier.flight f₀ g (t,p))) : | |
| ∀ᵐ p ∂FlightMeasure.phaseVolume, | |
| IntervalIntegrable (fun t => g (t,JetBarrier.flight t p)-L*F (t,JetBarrier.flight t p)) | |
| volume 0 T := by | |
| filter_upwards [characteristic_ae hT hf₀ hFm hgm hmild] with p hp | |
| have hi : IntervalIntegrable (fun t => g (t,JetBarrier.flight t p)) volume 0 T := by | |
| apply (intervalIntegrable_const (c := S)).mono_fun' | |
| · exact (hgm.comp (measurable_id.prodMk | |
| (GaussianLocal.measurable_flight.comp (measurable_id.prodMk measurable_const)))).aestronglyMeasurable | |
| · exact ae_of_all _ (fun t => by simpa only [Real.norm_eq_abs] using hg (t,JetBarrier.flight t p)) | |
| have hd := TransportPrimitive.damped_continuousOn hT L (f₀ p) hi | |
| have hfi : IntervalIntegrable | |
| (TransportPrimitive.damped L (f₀ p) (fun t => g (t,JetBarrier.flight t p))) volume 0 T := by | |
| apply ContinuousOn.intervalIntegrable | |
| simpa only [uIcc_of_le hT] using hd | |
| have he : (fun t => F (t,JetBarrier.flight t p)) =ᵐ[volume.restrict (Ioc 0 T)] | |
| (TransportPrimitive.damped L (f₀ p) (fun t => g (t,JetBarrier.flight t p))) := | |
| ae_restrict_of_ae_restrict_of_subset Ioc_subset_Icc_self hp | |
| have he' : (fun t => F (t,JetBarrier.flight t p)) =ᵐ[volume.restrict (uIoc 0 T)] | |
| (TransportPrimitive.damped L (f₀ p) (fun t => g (t,JetBarrier.flight t p))) := by | |
| simpa only [uIoc_of_le hT] using he | |
| exact hi.sub ((hfi.congr_ae he'.symm).const_mul L) | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| end OAI | |