math / data /lean /OAI /MathematicalPhysics /Boltzmann /Approximation /PositiveIntegralFixedPoint.lean
Download data/lean/OAI/MathematicalPhysics/Boltzmann/Approximation/PositiveIntegralFixedPoint.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 20.3 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MathematicalPhysics/Boltzmann/Approximation/PositiveIntegralFixedPoint.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/MathematicalPhysics/Boltzmann/Approximation/PositiveIntegralFixedPoint.lean
-
curl -L -o PositiveIntegralFixedPoint.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MathematicalPhysics/Boltzmann/Approximation/PositiveIntegralFixedPoint.lean
20.3 kB
| import OAI.MathematicalPhysics.Boltzmann.Branching.BoundedCollisionBlocks | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.WeakL1ToWeakStar | |
| import Mathlib.MeasureTheory.Integral.Prod | |
| namespace OAI | |
| section | |
| /-! # Positive integral contraction along measurable characteristics | |
| This lemma constructs a fixed point of a bounded positive source map. | |
| The collision source and its quantitative estimates are supplied separately. | |
| -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open scoped Topology | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| variable {P : Type*} [MeasurableSpace P] | |
| abbrev Domain (P : Type*) := β Γ P | |
| def time (T t : β) : β := max 0 (min T t) | |
| theorem time_bounds {T : β} (hT : 0 β€ T) (t : β) : | |
| 0 β€ time T t β§ time T t β€ T := | |
| β¨le_max_left _ _, max_le hT (min_le_left _ _)β© | |
| def value (T L : β) (flow : β β P β P) (fβ : P β β) | |
| (g : Domain P β β) (z : Domain P) : β := | |
| Real.exp (-L * time T z.1) * fβ (flow (-time T z.1) z.2) + | |
| β« r in 0..time T z.1, | |
| Real.exp (-L * (time T z.1 - r)) * g (r, flow (r - time T z.1) z.2) | |
| theorem measurable_value {T L : β} (hT : 0 β€ T) {flow : β β P β P} | |
| (hflow : Measurable (fun z : β Γ P => flow z.1 z.2)) | |
| {fβ : P β β} (hfβ : Measurable fβ) {g : Domain P β β} (hg : Measurable g) : | |
| Measurable (value T L flow fβ g) := by | |
| have ht : Measurable (fun z : Domain P => time T z.1) := by unfold time; fun_prop | |
| have hm : Measurable (fun z : Domain P => | |
| β« r : β, if 0 < r β§ r β€ time T z.1 then | |
| Real.exp (-L * (time T z.1 - r)) * g (r, flow (r - time T z.1) z.2) else 0) := by | |
| apply StronglyMeasurable.measurable | |
| apply StronglyMeasurable.integral_prod_right | |
| apply Measurable.stronglyMeasurable | |
| have hfl : Measurable (fun q : Domain P Γ β => flow (q.2 - time T q.1.1) q.1.2) := | |
| hflow.comp ((measurable_snd.sub (ht.comp measurable_fst)).prodMk measurable_fst.snd) | |
| apply Measurable.ite | |
| Β· exact (measurableSet_lt measurable_const measurable_snd).inter | |
| (measurableSet_le measurable_snd (ht.comp measurable_fst)) | |
| Β· have he : Measurable (fun q : Domain P Γ β => Real.exp (-L * (time T q.1.1 - q.2))) := by | |
| unfold time | |
| fun_prop | |
| exact he.mul (hg.comp (measurable_snd.prodMk hfl)) | |
| Β· exact measurable_const | |
| have he (z : Domain P) : (β« r in 0..time T z.1, | |
| Real.exp (-L * (time T z.1 - r)) * g (r, flow (r - time T z.1) z.2)) = | |
| β« r : β, if 0 < r β§ r β€ time T z.1 then | |
| Real.exp (-L * (time T z.1 - r)) * g (r, flow (r - time T z.1) z.2) else 0 := by | |
| rw [intervalIntegral.integral_of_le (time_bounds hT z.1).1, β integral_indicator measurableSet_Ioc] | |
| apply integral_congr_ae | |
| exact ae_of_all _ (fun r => by simp only [Set.indicator_apply, Set.mem_Ioc]) | |
| unfold value | |
| simp_rw [he] | |
| have he : Measurable (fun z : Domain P => Real.exp (-L * time T z.1)) := by | |
| unfold time | |
| fun_prop | |
| exact (he.mul (hfβ.comp (hflow.comp ((ht.neg).prodMk measurable_snd)))).add hm | |
| omit [MeasurableSpace P] in | |
| theorem value_bounds {T L A S : β} (hT : 0 β€ T) (hL : 0 β€ L) (_hA : 0 β€ A) | |
| (hS : 0 β€ S) (flow : β β P β P) {fβ : P β β} | |
| (hfβ : β p, 0 β€ fβ p β§ fβ p β€ A) {g : Domain P β β} | |
| (hg : β z, 0 β€ g z β§ g z β€ S) | |
| (z : Domain P) : 0 β€ value T L flow fβ g z β§ value T L flow fβ g z β€ A + T * S := by | |
| have ht := time_bounds hT z.1 | |
| have he (r : β) (hr : r β Icc 0 (time T z.1)) : | |
| 0 β€ Real.exp (-L * (time T z.1 - r)) β§ Real.exp (-L * (time T z.1 - r)) β€ 1 := by | |
| exact β¨(Real.exp_pos _).le, Real.exp_le_one_iff.mpr (by nlinarith [hr.2])β© | |
| have hi : (β« r in 0..time T z.1, | |
| Real.exp (-L * (time T z.1 - r)) * g (r, flow (r - time T z.1) z.2)) β€ S * time T z.1 := by | |
| apply (le_abs_self _).trans | |
| have h := intervalIntegral.norm_integral_le_of_norm_le_const (a := 0) | |
| (b := time T z.1) (C := S) (f := fun r => | |
| Real.exp (-L * (time T z.1 - r)) * g (r, flow (r - time T z.1) z.2)) | |
| (fun r hr => by | |
| rw [uIoc_of_le ht.1] at hr | |
| rw [Real.norm_eq_abs, abs_of_nonneg (mul_nonneg (Real.exp_pos _).le (hg _).1)] | |
| exact (mul_le_mul_of_nonneg_right (he r β¨hr.1.le, hr.2β©).2 (hg _).1).trans | |
| (by simpa using (hg _).2)) | |
| simpa only [Real.norm_eq_abs, sub_zero, abs_of_nonneg ht.1] using h | |
| constructor | |
| Β· exact add_nonneg (mul_nonneg (Real.exp_pos _).le (hfβ _).1) | |
| (intervalIntegral.integral_nonneg ht.1 (fun r _ => mul_nonneg (Real.exp_pos _).le (hg _).1)) | |
| Β· have hinit : Real.exp (-L * time T z.1) * fβ (flow (-time T z.1) z.2) β€ A := | |
| (mul_le_mul_of_nonneg_right (Real.exp_le_one_iff.mpr (by nlinarith)) (hfβ _).1).trans | |
| (by simpa using (hfβ _).2) | |
| exact (add_le_add hinit hi).trans (by nlinarith) | |
| theorem damped_integrable {T L S : β} (hT : 0 β€ T) (hL : 0 β€ L) | |
| {flow : β β P β P} (hflow : Measurable (fun z : β Γ P => flow z.1 z.2)) | |
| {g : Domain P β β} (hgm : Measurable g) (hg : β z, |g z| β€ S) | |
| (z : Domain P) : IntervalIntegrable (fun r => | |
| Real.exp (-L * (time T z.1 - r)) * g (r, flow (r - time T z.1) z.2)) volume 0 (time T z.1) := by | |
| apply (intervalIntegrable_const (c := S)).mono_fun' | |
| Β· have hm : Measurable (fun r : β => flow (r - time T z.1) z.2) := | |
| hflow.comp ((measurable_id.sub measurable_const).prodMk measurable_const) | |
| have he : Measurable (fun r : β => Real.exp (-L * (time T z.1 - r))) := by fun_prop | |
| exact (he.mul (hgm.comp (measurable_id.prodMk hm))).aestronglyMeasurable | |
| Β· filter_upwards [ae_restrict_mem measurableSet_uIoc] with r hr | |
| rw [uIoc_of_le (time_bounds hT z.1).1] at hr | |
| rw [Real.norm_eq_abs, abs_mul, abs_of_pos (Real.exp_pos _)] | |
| have he : Real.exp (-L * (time T z.1 - r)) β€ 1 := | |
| Real.exp_le_one_iff.mpr (by nlinarith [hr.2]) | |
| exact (mul_le_mul_of_nonneg_right he (abs_nonneg _)).trans (by simpa using hg _) | |
| theorem value_difference {T L S D : β} (hT : 0 β€ T) (hL : 0 β€ L) (hD : 0 β€ D) | |
| {flow : β β P β P} (hflow : Measurable (fun z : β Γ P => flow z.1 z.2)) | |
| (fβ : P β β) {g h : Domain P β β} (hgm : Measurable g) (hhm : Measurable h) | |
| (hg : β z, |g z| β€ S) (hh : β z, |h z| β€ S) (hgh : β z, |g z - h z| β€ D) | |
| (z : Domain P) : |value T L flow fβ g z - value T L flow fβ h z| β€ T * D := by | |
| have ht := time_bounds hT z.1 | |
| have hgi := damped_integrable hT hL hflow hgm hg z | |
| have hhi := damped_integrable hT hL hflow hhm hh z | |
| unfold value | |
| rw [add_sub_add_left_eq_sub, β intervalIntegral.integral_sub hgi hhi] | |
| have hb := intervalIntegral.norm_integral_le_of_norm_le_const (a := 0) (b := time T z.1) | |
| (C := D) (f := fun r => | |
| Real.exp (-L * (time T z.1 - r)) * g (r, flow (r - time T z.1) z.2) - | |
| Real.exp (-L * (time T z.1 - r)) * h (r, flow (r - time T z.1) z.2)) | |
| (fun r hr => by | |
| rw [uIoc_of_le ht.1] at hr | |
| rw [β mul_sub, Real.norm_eq_abs, abs_mul, abs_of_pos (Real.exp_pos _)] | |
| have he : Real.exp (-L * (time T z.1 - r)) β€ 1 := | |
| Real.exp_le_one_iff.mpr (by nlinarith [hr.2]) | |
| exact (mul_le_mul_of_nonneg_right he (abs_nonneg _)).trans (by simpa using hgh _)) | |
| rw [Real.norm_eq_abs, sub_zero, abs_of_nonneg ht.1] at hb | |
| exact hb.trans (by nlinarith) | |
| /-- Positive Picard iteration converges in the complete sup-norm space. -/ | |
| theorem exists_fixed_point {T L A R S K : β} (hT : 0 β€ T) (hL : 0 β€ L) | |
| (hA : 0 β€ A) (hR : 0 β€ R) (hS : 0 β€ S) (hK : 0 β€ K) | |
| (hball : A + T * S β€ R) (hsmall : T * K < 1) | |
| {flow : β β P β P} (hflow : Measurable (fun z : β Γ P => flow z.1 z.2)) | |
| {fβ : P β β} (hfβm : Measurable fβ) (hfβ : β p, 0 β€ fβ p β§ fβ p β€ A) | |
| (source : BoundedMeasurable.PositiveBall (Domain P) R β Domain P β β) | |
| (hsm : β f, Measurable (source f)) | |
| (hsb : β f z, 0 β€ source f z β§ source f z β€ S) | |
| (hsl : β f g z, |source f z - source g z| β€ K * dist f g) : | |
| β f : BoundedMeasurable.PositiveBall (Domain P) R, | |
| β z, f.val z = value T L flow fβ (source f) z := by | |
| let step : BoundedMeasurable.PositiveBall (Domain P) R β | |
| BoundedMeasurable.PositiveBall (Domain P) R := fun f => | |
| β¨BoundedMeasurable.ofBounded (Domain P) (value T L flow fβ (source f)) | |
| (measurable_value hT hflow hfβm (hsm f)) (A + T * S) | |
| (fun z => by | |
| rw [abs_of_nonneg (value_bounds hT hL hA hS flow hfβ (hsb f) z).1] | |
| exact (value_bounds hT hL hA hS flow hfβ (hsb f) z).2), | |
| fun z => β¨(value_bounds hT hL hA hS flow hfβ (hsb f) z).1, | |
| (value_bounds hT hL hA hS flow hfβ (hsb f) z).2.trans hballβ©β© | |
| have hc : ContractingWith β¨T * K, mul_nonneg hT hKβ© step := by | |
| constructor | |
| Β· exact hsmall | |
| Β· apply LipschitzWith.of_dist_le_mul | |
| intro f g | |
| change dist (step f).val (step g).val β€ (T * K) * dist f g | |
| apply BoundedMeasurable.dist_le (Domain P) (by positivity) | |
| intro z | |
| have h := value_difference hT hL (mul_nonneg hK dist_nonneg) hflow fβ | |
| (hsm f) (hsm g) | |
| (fun z => by rw [abs_of_nonneg (hsb f z).1]; exact (hsb f z).2) | |
| (fun z => by rw [abs_of_nonneg (hsb g z).1]; exact (hsb g z).2) | |
| (hsl f g) z | |
| simpa only [step, BoundedMeasurable.ofBounded_apply, mul_assoc] using h | |
| let zero : BoundedMeasurable.PositiveBall (Domain P) R := | |
| β¨BoundedMeasurable.ofBounded (Domain P) (fun _ => 0) measurable_const 0 | |
| (fun _ => by simp), fun _ => β¨le_rfl, hRβ©β© | |
| let : Nonempty (BoundedMeasurable.PositiveBall (Domain P) R) := β¨zeroβ© | |
| refine β¨hc.fixedPoint, ?_β© | |
| intro z | |
| have he := congrArg (fun f : BoundedMeasurable.PositiveBall (Domain P) R => f.val z) | |
| hc.fixedPoint_isFixedPt | |
| exact he.symm | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # Order and dominated convergence for positive characteristic integrals -/ | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped Topology | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| variable {P : Type*} [MeasurableSpace P] | |
| theorem value_mono {T L S : β} (hT : 0 β€ T) (hL : 0 β€ L) | |
| {flow : β β P β P} (hflow : Measurable (fun z : β Γ P => flow z.1 z.2)) | |
| {fβ kβ : P β β} (hfk : β p, fβ p β€ kβ p) | |
| {g h : Domain P β β} (hgm : Measurable g) (hhm : Measurable h) | |
| (hg : β z, |g z| β€ S) (hh : β z, |h z| β€ S) (hgh : β z, g z β€ h z) | |
| (z : Domain P) : value T L flow fβ g z β€ value T L flow kβ h z := by | |
| apply add_le_add | |
| Β· exact mul_le_mul_of_nonneg_left (hfk _) (Real.exp_pos _).le | |
| Β· apply intervalIntegral.integral_mono_on (time_bounds hT z.1).1 | |
| (damped_integrable hT hL hflow hgm hg z) (damped_integrable hT hL hflow hhm hh z) | |
| intro r _ | |
| exact mul_le_mul_of_nonneg_left (hgh _) (Real.exp_pos _).le | |
| theorem value_tendsto {T L S : β} (hT : 0 β€ T) (hL : 0 β€ L) | |
| {flow : β β P β P} (hflow : Measurable (fun z : β Γ P => flow z.1 z.2)) | |
| (fβ : P β β) {g : β β Domain P β β} {h : Domain P β β} | |
| (hgm : β n, Measurable (g n)) (hg : β n z, |g n z| β€ S) | |
| (hlim : β z, Tendsto (fun n => g n z) atTop (π (h z))) | |
| (z : Domain P) : Tendsto (fun n => value T L flow fβ (g n) z) atTop | |
| (π (value T L flow fβ h z)) := by | |
| apply tendsto_const_nhds.add | |
| apply intervalIntegral.tendsto_integral_filter_of_dominated_convergence (fun _ => S) | |
| Β· exact .of_forall (fun n => (damped_integrable hT hL hflow (hgm n) (hg n) z).def'.aestronglyMeasurable) | |
| Β· apply Eventually.of_forall | |
| intro n | |
| apply ae_of_all | |
| intro r hr | |
| rw [uIoc_of_le (time_bounds hT z.1).1] at hr | |
| rw [Real.norm_eq_abs, abs_mul, abs_of_pos (Real.exp_pos _)] | |
| have he : Real.exp (-L * (time T z.1 - r)) β€ 1 := Real.exp_le_one_iff.mpr (by nlinarith [hr.2]) | |
| exact (mul_le_mul_of_nonneg_right he (abs_nonneg _)).trans (by simpa using hg n _) | |
| Β· exact intervalIntegrable_const | |
| Β· exact ae_of_all _ (fun r _ => tendsto_const_nhds.mul (hlim _)) | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # Removing the auxiliary exponential weight from a mild solution -/ | |
| noncomputable section | |
| open Set | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| variable {P : Type*} | |
| theorem value_rescale {T : β} (hT : 0 β€ T) (a L : β) (flow : β β P β P) | |
| (fβ : P β β) (g : Domain P β β) (z : Domain P) : | |
| Real.exp (a*time T z.1) * value T (a+L) flow fβ | |
| (fun w => Real.exp (-a*time T w.1)*g w) z = value T L flow fβ g z := by | |
| have ht := time_bounds hT z.1 | |
| have hi : Real.exp (a*time T z.1)*Real.exp (-(a+L)*time T z.1) = | |
| Real.exp (-L*time T z.1) := by | |
| rw [β Real.exp_add] | |
| congr 1 | |
| ring | |
| have he (r : β) : Real.exp (a*time T z.1)*Real.exp (-(a+L)*(time T z.1-r))*Real.exp (-a*r) = | |
| Real.exp (-L*(time T z.1-r)) := by | |
| rw [β Real.exp_add,β Real.exp_add] | |
| congr 1 | |
| ring | |
| unfold value | |
| rw [mul_add,β mul_assoc,hi,β intervalIntegral.integral_const_mul] | |
| congr 1 | |
| apply intervalIntegral.integral_congr | |
| intro r hr | |
| rw [uIcc_of_le ht.1] at hr | |
| have hrT : r β€ T := hr.2.trans ht.2 | |
| have hrt : time T r = r := by | |
| unfold time | |
| rw [min_eq_right hrT,max_eq_right hr.1] | |
| dsimp only | |
| rw [hrt] | |
| calc | |
| _ = (Real.exp (a*time T z.1)*Real.exp (-(a+L)*(time T z.1-r))*Real.exp (-a*r))* | |
| g (r,flow (r-time T z.1) z.2) := by ring | |
| _ = _ := by rw [he] | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # Uniqueness on a common bounded interval for the positive integral map -/ | |
| noncomputable section | |
| open MeasureTheory | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| variable {P : Type*} [MeasurableSpace P] | |
| theorem fixed_point_unique {T L R S K : β} (hT : 0 β€ T) (hL : 0 β€ L) (hK : 0 β€ K) | |
| (hsmall : T * K < 1) | |
| {flow : β β P β P} (hflow : Measurable (fun z : β Γ P => flow z.1 z.2)) | |
| (fβ : P β β) | |
| (source : BoundedMeasurable.PositiveBall (Domain P) R β Domain P β β) | |
| (hsm : β f, Measurable (source f)) | |
| (hsb : β f z, |source f z| β€ S) | |
| (hsl : β f g z, |source f z - source g z| β€ K * dist f g) | |
| {f g : BoundedMeasurable.PositiveBall (Domain P) R} | |
| (hf : β z, f.val z = value T L flow fβ (source f) z) | |
| (hg : β z, g.val z = value T L flow fβ (source g) z) : f = g := by | |
| have hd : dist f g β€ (T * K) * dist f g := by | |
| change dist f.val g.val β€ _ | |
| apply BoundedMeasurable.dist_le (Domain P) (by positivity) | |
| intro z | |
| rw [hf, hg] | |
| have h := value_difference hT hL (mul_nonneg hK dist_nonneg) hflow fβ | |
| (hsm f) (hsm g) (hsb f) (hsb g) (hsl f g) z | |
| simpa only [mul_assoc] using h | |
| have hz : dist f g = 0 := by nlinarith [dist_nonneg (x := f) (y := g)] | |
| exact dist_eq_zero.mp hz | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # Dependence of the characteristic map on its initial value -/ | |
| noncomputable section | |
| open MeasureTheory | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| variable {P : Type*} [MeasurableSpace P] | |
| theorem value_difference_initial {T L S D I : β} (hT : 0 β€ T) (hL : 0 β€ L) | |
| (hD : 0 β€ D) (_hI : 0 β€ I) | |
| {flow : β β P β P} (hflow : Measurable (fun z : β Γ P => flow z.1 z.2)) | |
| {fβ kβ : P β β} (hfk : β p, |fβ p-kβ p| β€ I) | |
| {g h : Domain P β β} (hgm : Measurable g) (hhm : Measurable h) | |
| (hg : β z, |g z| β€ S) (hh : β z, |h z| β€ S) (hgh : β z, |g z-h z| β€ D) | |
| (z : Domain P) : |value T L flow fβ g z-value T L flow kβ h z| β€ I+T*D := by | |
| have hsource := value_difference hT hL hD hflow fβ hgm hhm hg hh hgh z | |
| have hinitial : |value T L flow fβ h z-value T L flow kβ h z| β€ I := by | |
| have heq : value T L flow fβ h z-value T L flow kβ h z = | |
| Real.exp (-L*time T z.1) * (fβ (flow (-time T z.1) z.2)-kβ (flow (-time T z.1) z.2)) := by | |
| unfold value | |
| ring | |
| rw [heq, abs_mul, abs_of_pos (Real.exp_pos _)] | |
| have he : Real.exp (-L*time T z.1) β€ 1 := Real.exp_le_one_iff.mpr | |
| (mul_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr hL) (time_bounds hT z.1).1) | |
| exact (mul_le_mul he (hfk _) (abs_nonneg _) (by norm_num)).trans_eq (one_mul I) | |
| exact (abs_sub_le _ _ _).trans ((add_le_add hsource hinitial).trans_eq (add_comm _ _)) | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # Finite sums of positive characteristic integrals -/ | |
| noncomputable section | |
| open MeasureTheory | |
| open scoped BigOperators | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| variable {P I : Type*} [MeasurableSpace P] | |
| theorem value_finsetSum {T L S : β} (hT : 0 β€ T) (hL : 0 β€ L) | |
| {flow : β β P β P} (hflow : Measurable (fun z : β Γ P => flow z.1 z.2)) | |
| (s : Finset I) (fβ : I β P β β) (g : I β Domain P β β) | |
| (hgm : β i β s, Measurable (g i)) (hg : β i β s, β z, |g i z| β€ S) | |
| (z : Domain P) : | |
| β i β s, value T L flow (fβ i) (g i) z = | |
| value T L flow (fun p => β i β s, fβ i p) (fun q => β i β s, g i q) z := by | |
| unfold value | |
| rw [Finset.sum_add_distrib, Finset.mul_sum] | |
| congr 1 | |
| rw [β intervalIntegral.integral_finsetSum | |
| (fun i hi => damped_integrable hT hL hflow (hgm i hi) (hg i hi) z)] | |
| apply intervalIntegral.integral_congr | |
| intro r _ | |
| exact (Finset.mul_sum s _ _).symm | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # Countable positive sums in the characteristic equation -/ | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped Topology | |
| namespace BoltzmannNonuniqueness.PositiveIntegral | |
| variable {P I : Type*} [MeasurableSpace P] [Countable I] | |
| theorem hasSum_value {T L S : β} (hT : 0 β€ T) (hL : 0 β€ L) | |
| {flow : β β P β P} (hflow : Measurable (fun z : β Γ P => flow z.1 z.2)) | |
| (fβ : I β P β β) (hfβ : β p, Summable (fun i => fβ i p)) | |
| (g : I β Domain P β β) (hgm : β i, Measurable (g i)) | |
| (hg : β i z, 0 β€ g i z β§ g i z β€ S) | |
| (hgs : β z, Summable (fun i => g i z)) (hgb : β z, (β' i, g i z) β€ S) | |
| (z : Domain P) : HasSum (fun i => value T L flow (fβ i) (g i) z) | |
| (value T L flow (fun p => β' i, fβ i p) (fun q => β' i, g i q) z) := by | |
| have hsm : Measurable (fun q => β' i, g i q) := Measurable.tsum hgm | |
| have hsa (q) : |β' i, g i q| β€ S := by | |
| rw [abs_of_nonneg (tsum_nonneg (fun i => (hg i q).1))] | |
| exact hgb q | |
| have hgi (i) := damped_integrable hT hL hflow (hgm i) | |
| (fun q => by rw [abs_of_nonneg (hg i q).1]; exact (hg i q).2) z | |
| have hi := intervalIntegral.hasSum_integral_of_dominated_convergence | |
| (a := 0) (b := time T z.1) (ΞΌ := volume) | |
| (F := fun i r => Real.exp (-L * (time T z.1 - r)) * g i (r, flow (r - time T z.1) z.2)) | |
| (f := fun r => Real.exp (-L * (time T z.1 - r)) * | |
| β' i, g i (r, flow (r - time T z.1) z.2)) | |
| (fun i r => Real.exp (-L * (time T z.1 - r)) * g i (r, flow (r - time T z.1) z.2)) | |
| (fun i => (hgi i).def'.aestronglyMeasurable) | |
| (fun i => ae_of_all _ (fun r _ => by | |
| rw [Real.norm_eq_abs, abs_of_nonneg (mul_nonneg (Real.exp_pos _).le (hg i _).1)])) | |
| (ae_of_all _ (fun r _ => (hgs _).mul_left _)) | |
| (by | |
| simpa only [tsum_mul_left] using damped_integrable hT hL hflow hsm hsa z) | |
| (ae_of_all _ (fun r _ => (hgs _).hasSum.mul_left _)) | |
| exact ((hfβ _).hasSum.mul_left (Real.exp (-L * time T z.1))).add hi | |
| end BoltzmannNonuniqueness.PositiveIntegral | |
| end | |
| end | |
| section | |
| /-! # Positive mass of an integral is bounded by the integral of positive mass -/ | |
| noncomputable section | |
| open MeasureTheory | |
| open scoped ENNReal | |
| namespace BoltzmannNonuniqueness | |
| variable {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y] | |
| theorem positive_marginal_bound {ΞΌ : Measure X} {Ξ½ : Measure Y} [SFinite ΞΌ] [SFinite Ξ½] | |
| {f : X Γ Y β β} (hfm : Measurable f) (hfi : Integrable f (ΞΌ.prod Ξ½)) : | |
| (β«β» x, ENNReal.ofReal (β« y, f (x,y) βΞ½) βΞΌ) β€ | |
| β«β» z, ENNReal.ofReal (f z) βΞΌ.prod Ξ½ := by | |
| rw [lintegral_prod _ hfm.ennreal_ofReal.aemeasurable] | |
| exact lintegral_mono_ae (hfi.prod_right_ae.mono (fun x hx => Published.ofReal_integral_le_lintegral hx)) | |
| end BoltzmannNonuniqueness | |
| end | |
| end | |
| end OAI | |