Download data/lean/OAI/MathematicalPhysics/Boltzmann/Compactness/LocalL1ApproximationLimit.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 22.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MathematicalPhysics/Boltzmann/Compactness/LocalL1ApproximationLimit.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/MathematicalPhysics/Boltzmann/Compactness/LocalL1ApproximationLimit.lean
-
curl -L -o LocalL1ApproximationLimit.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MathematicalPhysics/Boltzmann/Compactness/LocalL1ApproximationLimit.lean
22.4 kB
| import OAI.MathematicalPhysics.Boltzmann.Branching.AveragingTailSources | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.CompactCapFamily | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.ComplexWeakL2Diagonal | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.RationalUniformApproximation | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.PeriodicRenormalizedCompactness | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.RenormalizedIntegrability | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.WeakL1ToWeakStar | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.WeakL1Operations | |
| namespace OAI | |
| section | |
| /-! # The actual gain divided by one plus density is uniformly integrable locally -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| namespace BoltzmannNonuniqueness.PeriodicApproximation | |
| open Compactness | |
| variable {X : Type*} [MeasurableSpace X] {ΞΌ : Measure X} [SFinite ΞΌ] | |
| theorem gain_unit_uniformIntegrable_local | |
| {f : β β X Γ Velocity β β} {N : β β β} {R : β} (hR : 0 β€ R) | |
| (hfm : β n, Measurable (f n)) (hf : β n p, 0 β€ f n p) (hN : β n, 0 < N n) | |
| (hi : UniformIntegrable (fun n p => gain (N n) (f n) p/normalizer (f n) p) | |
| 1 (ΞΌ.prod volume)) : | |
| UniformIntegrable (fun n p => gain (N n) (f n) p/(1+f n p)) 1 | |
| (ΞΌ.prod ((volume : Measure Velocity).restrict (Metric.closedBall 0 R))) := by | |
| have hres := uniformIntegrable_restrict hi (univ ΓΛ’ Metric.closedBall (0:Velocity) R) | |
| rw [β Measure.prod_restrict,Measure.restrict_univ] at hres | |
| have hvel : βα΅ p βΞΌ.prod ((volume : Measure Velocity).restrict (Metric.closedBall 0 R)), | |
| p.2 β Metric.closedBall (0:Velocity) R := | |
| Measure.quasiMeasurePreserving_snd.ae (ae_restrict_mem measurableSet_closedBall) | |
| apply uniformIntegrable_change_normalizer | |
| (fun n => gain_measurable (N n) (hfm n)) hfm | |
| (fun n p => (gain_bounds (hN n) (hfm n) (hf n) p).1) hf (maxwellianLower_pos R) _ hres | |
| filter_upwards [hvel] with p hp | |
| exact maxwellianLower_le hR (by simpa only [Metric.mem_closedBall,dist_zero_right] using hp) | |
| theorem approximatingSolution_gain_unit_uniformIntegrable_local | |
| (f : Density) (hfm : Measurable f) (hf : β p, 0 β€ f p) | |
| (hi : Integrable (entropyMoment f)) {T R : β} (hT : 0 β€ T) (hR : 0 β€ R) : | |
| let F := fun n => (approximatingSolution f hfm (n+Nat.ceil T)).kineticProfile | |
| let N := fun n : β => ((n+Nat.ceil T:β):β)+1 | |
| UniformIntegrable (fun n p => gain (N n) (F n) p/(1+F n p)) 1 | |
| (((volume.restrict (Icc 0 T)).prod (volume : Measure Position)).prod | |
| ((volume : Measure Velocity).restrict (Metric.closedBall 0 R))) := by | |
| apply gain_unit_uniformIntegrable_local hR | |
| (fun n => (approximatingSolution f hfm (n+Nat.ceil T)).kineticProfile_measurable) | |
| (fun n p => (approximatingSolution f hfm (n+Nat.ceil T)).nonnegative _) | |
| (fun n => by positivity) | |
| exact (approximatingSolution_normalizedSources_uniformIntegrable f hfm hf hi hT).1 | |
| end BoltzmannNonuniqueness.PeriodicApproximation | |
| end | |
| end | |
| section | |
| /-! # Local strong L2 convergence controls the local L1 seminorm -/ | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped Topology ENNReal | |
| namespace BoltzmannNonuniqueness.Published | |
| theorem localL2_L1_bound (K : Set FourierSpace) | |
| (a : Lp β 2 (volume : Measure FourierSpace)) : | |
| eLpNorm (a : FourierSpace β β) 1 (volume.restrict K) β€ | |
| ENNReal.ofReal βcomplexL2Restriction K aβ * volume K ^ (1/2 : β) := by | |
| have h := eLpNorm_le_eLpNorm_mul_rpow_measure_univ (ΞΌ := volume.restrict K) (f := (a : FourierSpace β β)) (p := 1) (q := 2) | |
| (by norm_num) (Lp.aestronglyMeasurable a).restrict | |
| have he : eLpNorm (a : FourierSpace β β) 2 (volume.restrict K) = | |
| ENNReal.ofReal βcomplexL2Restriction K aβ := by | |
| rw [ofReal_norm,complexL2Restriction,Lp.enorm_toLp] | |
| rw [he] at h | |
| convert h using 1; norm_num | |
| theorem localL2_L1_tendsto {u : β β Lp β 2 (volume : Measure FourierSpace)} | |
| (K : Set FourierSpace) (hK : volume K < β€) | |
| (hu : Tendsto (fun n => βcomplexL2Restriction K (u n)β) atTop (π 0)) : | |
| Tendsto (fun n => eLpNorm (u n : FourierSpace β β) 1 (volume.restrict K)) atTop (π 0) := by | |
| have h := ENNReal.continuous_ofReal.continuousAt.tendsto.comp hu | |
| have hb := ENNReal.Tendsto.mul_const h | |
| (Or.inr (ENNReal.rpow_ne_top_of_nonneg (by positivity : (0:β) β€ 1/2) hK.ne)) | |
| have hb' : Tendsto (fun n => ENNReal.ofReal βcomplexL2Restriction K (u n)β * | |
| volume K ^ (1/2 : β)) atTop (π 0) := by | |
| simpa only [Function.comp_apply,ENNReal.ofReal_zero,zero_mul] using hb | |
| exact tendsto_of_tendsto_of_tendsto_of_le_of_le tendsto_const_nhds hb' | |
| (fun _ => bot_le) (fun n => localL2_L1_bound K (u n)) | |
| end BoltzmannNonuniqueness.Published | |
| end | |
| end | |
| section | |
| /-! # Uniform integrability of the physical loss with a unit density normalizer -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| namespace BoltzmannNonuniqueness.CollisionCompactness | |
| open Compactness PeriodicApproximation | |
| variable {X : Type*} [MeasurableSpace X] {ΞΌ : Measure X} [IsFiniteMeasure ΞΌ] | |
| theorem physicalLoss_unit_uniformIntegrable_local | |
| {f : β β X Γ Velocity β β} {R C : β} (hR : 0 β€ R) | |
| (hfm : β n, Measurable (f n)) (hf : β n p, 0 β€ f n p) | |
| (hi : β n, Integrable (entropyGauge (f n)) (ΞΌ.prod volume)) | |
| (hb : β n, (β« p, entropyGauge (f n) p βΞΌ.prod volume) β€ C) : | |
| UniformIntegrable (fun n p => lossDensity (f n) p/(1+f n p)) 1 | |
| (ΞΌ.prod ((volume : Measure Velocity).restrict (Metric.closedBall 0 R))) := by | |
| have hres := uniformIntegrable_restrict (renormalized_loss_uniformIntegrable hfm hf hi hb) | |
| (univ ΓΛ’ Metric.closedBall (0:Velocity) R) | |
| rw [β Measure.prod_restrict,Measure.restrict_univ] at hres | |
| have hvel : βα΅ p βΞΌ.prod ((volume : Measure Velocity).restrict (Metric.closedBall 0 R)), | |
| p.2 β Metric.closedBall (0:Velocity) R := | |
| Measure.quasiMeasurePreserving_snd.ae (ae_restrict_mem measurableSet_closedBall) | |
| apply uniformIntegrable_change_normalizer | |
| (fun n => lossDensity_measurable (hfm n)) hfm | |
| (fun n p => lossDensity_nonneg (hf n) p) hf (maxwellianLower_pos R) _ hres | |
| filter_upwards [hvel] with p hp | |
| exact maxwellianLower_le hR (by simpa only [Metric.mem_closedBall,dist_zero_right] using hp) | |
| end BoltzmannNonuniqueness.CollisionCompactness | |
| end | |
| end | |
| section | |
| /-! # Local factorization of pair moments along the actual averaging subsequence -/ | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped ENNReal Topology | |
| namespace BoltzmannNonuniqueness.Published | |
| theorem local_pair_moment_factorization {T : β} {ΞΌ : Measure SpaceTime} [SFinite ΞΌ] | |
| (hΞΌ : ΞΌ β€ timeSpaceVolume T) | |
| {f : β β KineticPhase β β} {g : KineticPhase β β} | |
| {W : SpaceTime Γ (Velocity Γ Velocity) β β} | |
| (hfm : β n, Measurable (f n)) | |
| (hfi : β n, Integrable (f n) (ΞΌ.prod volume)) | |
| (hpUI : UniformIntegrable (fun (n : β) (z : SpaceTime Γ (Velocity Γ Velocity)) => | |
| f n (z.1,z.2.1)*f n (z.1,z.2.2)) 1 (ΞΌ.prod volume)) | |
| (hg : WeakL1Converges (ΞΌ.prod volume) f g) | |
| (hW : WeakL1Converges (ΞΌ.prod volume) | |
| (fun n z => f n (z.1,z.2.1)*f n (z.1,z.2.2)) W) | |
| {k l : KineticPhase β β} (hk : Continuous k) (hl : Continuous l) | |
| (hkc : HasCompactSupport k) (hlc : HasCompactSupport l) | |
| {A B : SpaceTime β β} | |
| (hA : TimeLocalL1Converges T (fun n x => β« v, k (x,v)*f n (x,v)) A) | |
| (hB : TimeLocalL1Converges T (fun n x => β« v, l (x,v)*f n (x,v)) B) | |
| {K : Set SpaceTime} (hK : IsCompact K) [IsFiniteMeasure (ΞΌ.restrict K)] : | |
| (fun x => β« y : Velocity Γ Velocity, (k (x,y.1)*l (x,y.2))*W (x,y)) =α΅[ΞΌ.restrict K] | |
| (fun x => (β« v, k (x,v)*g (x,v))*(β« w, l (x,w)*g (x,w))) := by | |
| have hΞΌv : ΞΌ β€ (volume : Measure SpaceTime) := hΞΌ.trans | |
| (Measure.prod_mono Measure.restrict_le_self le_rfl) | |
| have hmK := Measure.restrict_mono_measure hΞΌ K | |
| have hAi := (hA.1.integrableOn_isCompact hK).mono_measure hΞΌv | |
| have hBi := (hB.1.integrableOn_isCompact hK).mono_measure hΞΌv | |
| have hA' : Tendsto (fun n => eLpNorm (fun x => (β« v, k (x,v)*f n (x,v))-A x) 1 | |
| (ΞΌ.restrict K)) atTop (π 0) := | |
| tendsto_of_tendsto_of_tendsto_of_le_of_le tendsto_const_nhds (hA.2 K hK) | |
| (fun _ => zero_le) (fun _ => eLpNorm_mono_measure _ hmK) | |
| have hB' : Tendsto (fun n => eLpNorm (fun x => (β« v, l (x,v)*f n (x,v))-B x) 1 | |
| (ΞΌ.restrict K)) atTop (π 0) := | |
| tendsto_of_tendsto_of_tendsto_of_le_of_le tendsto_const_nhds (hB.2 K hK) | |
| (fun _ => zero_le) (fun _ => eLpNorm_mono_measure _ hmK) | |
| have hfK (n) : Integrable (f n) ((ΞΌ.restrict K).prod volume) := by | |
| exact (hfi n).mono_measure (Measure.prod_mono Measure.restrict_le_self le_rfl) | |
| have hpK (n) : Integrable (fun z : SpaceTime Γ (Velocity Γ Velocity) => | |
| f n (z.1,z.2.1)*f n (z.1,z.2.2)) ((ΞΌ.restrict K).prod (volume.prod volume)) := by | |
| have hi : Integrable (fun z : SpaceTime Γ (Velocity Γ Velocity) => | |
| f n (z.1,z.2.1)*f n (z.1,z.2.2)) | |
| ((ΞΌ.restrict K).prod (volume : Measure (Velocity Γ Velocity))) := | |
| (memLp_one_iff_integrable.mp (hpUI.memLp n)).mono_measure | |
| (Measure.prod_mono Measure.restrict_le_self le_rfl) | |
| simpa only [Measure.volume_eq_prod] using hi | |
| have hgK := hg.restrict_base hK.measurableSet | |
| have hWK := hW.restrict_base hK.measurableSet | |
| rw [Measure.volume_eq_prod] at hWK | |
| obtain β¨C,hCβ© := hk.bounded_above_of_compact_support hkc | |
| obtain β¨D,hDβ© := hl.bounded_above_of_compact_support hlc | |
| have hui := Compactness.uniformIntegrable_restrict | |
| (Compactness.uniformIntegrable_compact_average_product hfm hpUI hk hl hkc hlc) K | |
| have he := weak_pair_moment_factorization hfm hfK hpK hgK hWK hk.measurable hl.measurable | |
| C D hC hD hAi hBi hA' hB' hui | |
| simpa only [β Measure.volume_eq_prod] using he | |
| end BoltzmannNonuniqueness.Published | |
| end | |
| end | |
| section | |
| /-! # Uniform integral bounds on finite balls give a global integral bound -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open scoped ENNReal | |
| namespace BoltzmannNonuniqueness.Published | |
| theorem lintegral_le_of_closedBall_bounds (f : FourierSpace β ββ₯0β) (B : ββ₯0β) | |
| (h : β n : β, (β«β» x in Metric.closedBall (0 : FourierSpace) n, f x) β€ B) : | |
| (β«β» x, f x) β€ B := by | |
| let ΞΌ := (volume : Measure FourierSpace).withDensity f | |
| have hm : Monotone (fun n : β => Metric.closedBall (0 : FourierSpace) n) := by | |
| intro n m hnm | |
| exact Metric.closedBall_subset_closedBall (by exact_mod_cast hnm) | |
| have he : (β«β» x, f x) = ΞΌ (Set.univ : Set FourierSpace) := by | |
| rw [withDensity_apply _ MeasurableSet.univ,Measure.restrict_univ] | |
| rw [he,β Metric.iUnion_closedBall_nat (0 : FourierSpace),hm.measure_iUnion] | |
| exact iSup_le (fun n => by simpa only [ΞΌ,withDensity_apply _ measurableSet_closedBall] using h n) | |
| end BoltzmannNonuniqueness.Published | |
| end | |
| end | |
| section | |
| /-! # Global L1 bounds pass through local L1 convergence -/ | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped Topology ENNReal | |
| namespace BoltzmannNonuniqueness.Published | |
| theorem localL1_global_bound {u : β β FourierSpace β β} {g : FourierSpace β β} | |
| (hg : AEStronglyMeasurable g volume) (B : ββ₯0β) | |
| (hu : β n, eLpNorm (u n) 1 volume β€ B) | |
| (hc : β K : Set FourierSpace, volume K < β€ β | |
| Tendsto (fun n => eLpNorm (u n-g) 1 (volume.restrict K)) atTop (π 0)) : | |
| eLpNorm g 1 volume β€ B := by | |
| rw [eLpNorm_one_eq_lintegral_enorm hg] | |
| apply lintegral_le_of_closedBall_bounds | |
| intro m | |
| let K := Metric.closedBall (0 : FourierSpace) (m : β) | |
| have hK : volume K < β€ := measure_closedBall_lt_top | |
| have he n : eLpNorm g 1 (volume.restrict K) β€ | |
| eLpNorm (u n-g) 1 (volume.restrict K)+B := by | |
| have hid : g = (g-u n)+u n := by funext x; simp | |
| calc | |
| _ = eLpNorm ((g-u n)+u n) 1 (volume.restrict K) := by rw [β hid] | |
| _ β€ eLpNorm (g-u n) 1 (volume.restrict K)+eLpNorm (u n) 1 (volume.restrict K) := | |
| eLpNorm_add_le (by norm_num) | |
| _ β€ eLpNorm (u n-g) 1 (volume.restrict K)+B := by | |
| rw [eLpNorm_sub_comm] | |
| exact add_le_add_right ((eLpNorm_mono_measure _ Measure.restrict_le_self).trans (hu n)) _ | |
| have ht : Tendsto (fun n => eLpNorm (u n-g) 1 (volume.restrict K)+B) atTop (π B) := by | |
| simpa using (hc K hK).add_const B | |
| have h := ge_of_tendsto ht (Eventually.of_forall he) | |
| simpa only [eLpNorm_one_eq_lintegral_enorm hg.restrict] using h | |
| theorem localL2_global_L1_bound {u : β β Lp β 2 (volume : Measure FourierSpace)} | |
| {g : Lp β 2 (volume : Measure FourierSpace)} (B : ββ₯0β) | |
| (hu : β n, eLpNorm (u n : FourierSpace β β) 1 volume β€ B) | |
| (hc : β K : Set FourierSpace, volume K < β€ β | |
| Tendsto (fun n => βcomplexL2Restriction K (u n-g)β) atTop (π 0)) : | |
| eLpNorm (g : FourierSpace β β) 1 volume β€ B := by | |
| apply localL1_global_bound (Lp.aestronglyMeasurable g) B hu | |
| intro K hK | |
| have h := localL2_L1_tendsto K hK (hc K hK) | |
| have he n : eLpNorm (u n-g : Lp β 2 volume) 1 (volume.restrict K) = | |
| eLpNorm ((u n : FourierSpace β β)-(g : FourierSpace β β)) 1 (volume.restrict K) := | |
| eLpNorm_congr_ae (ae_restrict_of_ae (Lp.coeFn_sub _ _)) | |
| simpa only [he] using h | |
| end BoltzmannNonuniqueness.Published | |
| end | |
| end | |
| section | |
| /-! # Local L1 convergence is stable under differences -/ | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped Topology ENNReal | |
| namespace BoltzmannNonuniqueness.Published | |
| theorem eLpNorm_sub_triangle {X : Type*} [MeasurableSpace X] (ΞΌ : Measure X) | |
| (f g h : X β β) : eLpNorm (f-h) 1 ΞΌ β€ eLpNorm (f-g) 1 ΞΌ+eLpNorm (g-h) 1 ΞΌ := by | |
| have he : f-h = (f-g)+(g-h) := by ext x; simp | |
| rw [he] | |
| exact eLpNorm_add_le (by norm_num) | |
| theorem localL1_difference_tendsto {u v : β β FourierSpace β β} | |
| {g h : FourierSpace β β} (K : Set FourierSpace) | |
| (hu : Tendsto (fun n => eLpNorm (u n-g) 1 (volume.restrict K)) atTop (π 0)) | |
| (hv : Tendsto (fun n => eLpNorm (v n-h) 1 (volume.restrict K)) atTop (π 0)) : | |
| Tendsto (fun n => eLpNorm ((u n-v n)-(g-h)) 1 (volume.restrict K)) atTop (π 0) := by | |
| have he n : (u n-v n)-(g-h) = (u n-g)-(v n-h) := by ext x; simp only [Pi.sub_apply]; ring | |
| have hb n : eLpNorm ((u n-v n)-(g-h)) 1 (volume.restrict K) β€ | |
| eLpNorm (u n-g) 1 (volume.restrict K)+eLpNorm (v n-h) 1 (volume.restrict K) := by | |
| rw [he] | |
| exact eLpNorm_sub_le (by norm_num) | |
| have ht : Tendsto (fun n => eLpNorm (u n-g) 1 (volume.restrict K)+ | |
| eLpNorm (v n-h) 1 (volume.restrict K)) atTop (π 0) := by simpa using hu.add hv | |
| exact tendsto_of_tendsto_of_tendsto_of_le_of_le tendsto_const_nhds ht | |
| (fun _ => bot_le) hb | |
| end BoltzmannNonuniqueness.Published | |
| end | |
| end | |
| section | |
| /-! # Limits of uniform L1 approximations are Cauchy in global L1 -/ | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped Topology ENNReal | |
| namespace BoltzmannNonuniqueness.Published | |
| theorem localL1_approximation_difference_bound | |
| (f : β β FourierSpace β β) (u : β β β β FourierSpace β β) | |
| (g : β β FourierSpace β β) (hg : β m, Integrable (g m)) | |
| (Ξ΄ : β β β) (hΞ΄ : β m, 0 β€ Ξ΄ m) | |
| (he : β m n, eLpNorm (f n-u m n) 1 volume β€ ENNReal.ofReal (Ξ΄ m)) | |
| (hc : β m (K : Set FourierSpace), volume K < β€ β | |
| Tendsto (fun n => eLpNorm (u m n-g m) 1 (volume.restrict K)) atTop (π 0)) | |
| (m k : β) : eLpNorm (g m-g k) 1 volume β€ ENNReal.ofReal (Ξ΄ m+Ξ΄ k) := by | |
| apply localL1_global_bound ((hg m).sub (hg k)).aestronglyMeasurable | |
| Β· intro n | |
| have h := eLpNorm_sub_triangle volume (u m n) (f n) (u k n) | |
| rw [eLpNorm_sub_comm (u m n) (f n)] at h | |
| apply h.trans | |
| simpa only [ENNReal.ofReal_add (hΞ΄ m) (hΞ΄ k)] using add_le_add (he m n) (he k n) | |
| Β· intro K hK | |
| exact localL1_difference_tendsto K (hc m K hK) (hc k K hK) | |
| theorem localL1_approximation_cauchy | |
| (f : β β FourierSpace β β) (u : β β β β FourierSpace β β) | |
| (g : β β FourierSpace β β) (hg : β m, Integrable (g m)) | |
| (Ξ΄ : β β β) (hΞ΄ : β m, 0 β€ Ξ΄ m) (hΞ΄0 : Tendsto Ξ΄ atTop (π 0)) | |
| (he : β m n, eLpNorm (f n-u m n) 1 volume β€ ENNReal.ofReal (Ξ΄ m)) | |
| (hc : β m (K : Set FourierSpace), volume K < β€ β | |
| Tendsto (fun n => eLpNorm (u m n-g m) 1 (volume.restrict K)) atTop (π 0)) : | |
| CauchySeq (fun m => (hg m).toL1 (g m)) := by | |
| have hb m k := localL1_approximation_difference_bound f u g hg Ξ΄ hΞ΄ he hc m k | |
| have hd m k : dist ((hg m).toL1 (g m)) ((hg k).toL1 (g k)) β€ Ξ΄ m+Ξ΄ k := by | |
| apply (ENNReal.ofReal_le_ofReal_iff (add_nonneg (hΞ΄ m) (hΞ΄ k))).mp | |
| rw [dist_eq_norm,L1.ofReal_norm_sub_eq_lintegral] | |
| have hae : (fun x => β(hg m).toL1 (g m) x-(hg k).toL1 (g k) xββ) =α΅[volume] | |
| (fun x => β(g m-g k) xββ) := by | |
| filter_upwards [(hg m).coeFn_toL1,(hg k).coeFn_toL1] with x hm hk | |
| simp only [hm,hk,Pi.sub_apply] | |
| rw [lintegral_congr_ae hae] | |
| simpa only [eLpNorm_one_eq_lintegral_enorm ((hg m).sub (hg k)).aestronglyMeasurable] using hb m k | |
| rw [Metric.cauchySeq_iff] | |
| intro Ξ΅ hΞ΅ | |
| obtain β¨N,hNβ© := eventually_atTop.mp (hΞ΄0.eventually (gt_mem_nhds (half_pos hΞ΅))) | |
| exact β¨N,fun m hm k hk => (hd m k).trans_lt (by linarith [hN m hm,hN k hk])β© | |
| end BoltzmannNonuniqueness.Published | |
| end | |
| end | |
| section | |
| /-! # Identification on compact subsets of a local weak-convergence window -/ | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped ENNReal Topology | |
| namespace BoltzmannNonuniqueness.Published | |
| theorem WeakL1Converges.eq_of_local_strong | |
| {X : Type*} [NormedAddCommGroup X] [MeasurableSpace X] [BorelSpace X] | |
| {ΞΌ : Measure X} {Ξ© E : Set X} {f : β β X β β} {g A : X β β} | |
| (h : WeakL1Converges (ΞΌ.restrict Ξ©) f g) | |
| (hf : βαΆ n in atTop, Integrable (f n) (ΞΌ.restrict Ξ©)) | |
| (hA : LocallyIntegrable A ΞΌ) (hE : IsCompact E) (hEΞ© : E β Ξ©) | |
| (hstrong : Tendsto (fun n => eLpNorm (fun x => f n x-A x) 1 (ΞΌ.restrict E)) | |
| atTop (π 0)) : A =α΅[ΞΌ.restrict E] g := by | |
| have hr := h.restrict hE.measurableSet | |
| rw [Measure.restrict_restrict_of_subset hEΞ©] at hr | |
| apply hr.eq_of_strong_eventually _ (hA.integrableOn_isCompact hE) hstrong | |
| filter_upwards [hf] with n hn | |
| exact hn.mono_measure (Measure.restrict_mono hEΞ© le_rfl) | |
| end BoltzmannNonuniqueness.Published | |
| end | |
| end | |
| section | |
| /-! # Transfer of local strong convergence through eventual equality on a window -/ | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped Topology ENNReal | |
| namespace BoltzmannNonuniqueness.Published | |
| theorem LocalL1Converges.congr_on_window {f h : β β SpaceTime β β} | |
| {g : SpaceTime β β} (hf : LocalL1Converges f g) {Ξ© : Set SpaceTime} | |
| (he : βαΆ n in atTop, h n =α΅[volume.restrict Ξ©] f n) : | |
| β K : Set SpaceTime, IsCompact K β K β Ξ© β | |
| Tendsto (fun n => eLpNorm (fun z => h n z-g z) 1 (volume.restrict K)) atTop (π 0) := by | |
| intro K hK hKΞ© | |
| apply (hf.2 K hK).congr' | |
| filter_upwards [he] with n hn | |
| apply eLpNorm_congr_ae | |
| have hkn := hn.filter_mono (ae_mono (Measure.restrict_mono hKΞ© le_rfl)) | |
| filter_upwards [hkn] with z hz | |
| rw [hz] | |
| end BoltzmannNonuniqueness.Published | |
| end | |
| end | |
| section | |
| /-! # Completing a sequence uniformly approximated by locally compact families -/ | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped Topology ENNReal | |
| namespace BoltzmannNonuniqueness.Published | |
| theorem localL1_approximation_limit | |
| (f : β β FourierSpace β β) (u : β β β β FourierSpace β β) | |
| (g : β β FourierSpace β β) (hg : β m, Integrable (g m)) | |
| (Ξ΄ : β β β) (hΞ΄ : β m, 0 β€ Ξ΄ m) (hΞ΄0 : Tendsto Ξ΄ atTop (π 0)) | |
| (he : β m n, eLpNorm (f n-u m n) 1 volume β€ ENNReal.ofReal (Ξ΄ m)) | |
| (hc : β m (K : Set FourierSpace), volume K < β€ β | |
| Tendsto (fun n => eLpNorm (u m n-g m) 1 (volume.restrict K)) atTop (π 0)) : | |
| β q : Lp β 1 (volume : Measure FourierSpace), | |
| β K : Set FourierSpace, volume K < β€ β | |
| Tendsto (fun n => eLpNorm (f n-(q : FourierSpace β β)) 1 (volume.restrict K)) atTop (π 0) := by | |
| obtain β¨q,hqβ© := cauchySeq_tendsto_of_complete | |
| (localL1_approximation_cauchy f u g hg Ξ΄ hΞ΄ hΞ΄0 he hc) | |
| have hq0 : Tendsto (fun m => eLpNorm (g m-(q : FourierSpace β β)) 1 volume) atTop (π 0) := by | |
| have ht := ENNReal.continuous_ofReal.continuousAt.tendsto.comp ((hq.sub_const q).norm) | |
| have heq m : ENNReal.ofReal β(hg m).toL1 (g m)-qβ = eLpNorm (g m-(q : FourierSpace β β)) 1 volume := by | |
| rw [L1.ofReal_norm_sub_eq_lintegral, | |
| eLpNorm_one_eq_lintegral_enorm ((hg m).sub (L1.integrable_coeFn q)).aestronglyMeasurable] | |
| apply lintegral_congr_ae | |
| filter_upwards [(hg m).coeFn_toL1] with x hx | |
| simp only [hx,Pi.sub_apply] | |
| simpa only [Function.comp_def,sub_self,norm_zero,ENNReal.ofReal_zero,heq] using ht | |
| have herror : Tendsto (fun m => ENNReal.ofReal (Ξ΄ m)+eLpNorm (g m-(q : FourierSpace β β)) 1 volume) atTop (π 0) := by | |
| simpa only [Function.comp_def,ENNReal.ofReal_zero,zero_add] using | |
| (ENNReal.continuous_ofReal.continuousAt.tendsto.comp hΞ΄0).add hq0 | |
| refine β¨q,fun K hK => ?_β© | |
| apply ENNReal.tendsto_nhds_zero.mpr | |
| intro Ξ΅ hΞ΅ | |
| have hh : 0 < Ξ΅/2 := ENNReal.div_pos hΞ΅.ne' (by norm_num) | |
| obtain β¨m,hmβ© := (ENNReal.tendsto_nhds_zero.mp herror (Ξ΅/2) hh).exists | |
| filter_upwards [ENNReal.tendsto_nhds_zero.mp (hc m K hK) (Ξ΅/2) hh] with n hn | |
| calc | |
| eLpNorm (f n-(q : FourierSpace β β)) 1 (volume.restrict K) β€ | |
| eLpNorm (f n-u m n) 1 (volume.restrict K)+eLpNorm (u m n-(q : FourierSpace β β)) 1 (volume.restrict K) := | |
| eLpNorm_sub_triangle _ _ _ _ | |
| _ β€ ENNReal.ofReal (Ξ΄ m)+(eLpNorm (u m n-g m) 1 (volume.restrict K)+eLpNorm (g m-(q : FourierSpace β β)) 1 volume) := by | |
| apply add_le_add ((eLpNorm_mono_measure _ Measure.restrict_le_self).trans (he m n)) | |
| exact (eLpNorm_sub_triangle _ _ _ _).trans | |
| (add_le_add le_rfl (eLpNorm_mono_measure _ Measure.restrict_le_self)) | |
| _ = (ENNReal.ofReal (Ξ΄ m)+eLpNorm (g m-(q : FourierSpace β β)) 1 volume)+eLpNorm (u m n-g m) 1 (volume.restrict K) := by ac_rfl | |
| _ β€ Ξ΅/2+Ξ΅/2 := add_le_add hm hn | |
| _ = Ξ΅ := ENNReal.add_halves Ξ΅ | |
| end BoltzmannNonuniqueness.Published | |
| end | |
| end | |
| end OAI | |