math / data /lean /OAI /MathematicalPhysics /Boltzmann /Approximation /MassNormalizedCollisionLimits.lean
Download data/lean/OAI/MathematicalPhysics/Boltzmann/Approximation/MassNormalizedCollisionLimits.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 33.6 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MathematicalPhysics/Boltzmann/Approximation/MassNormalizedCollisionLimits.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/MathematicalPhysics/Boltzmann/Approximation/MassNormalizedCollisionLimits.lean
-
curl -L -o MassNormalizedCollisionLimits.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MathematicalPhysics/Boltzmann/Approximation/MassNormalizedCollisionLimits.lean
33.6 kB
| import OAI.MathematicalPhysics.Boltzmann.Branching.MarginalUniformIntegrability | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.RealL1ApproximationLimit | |
| import OAI.MathematicalPhysics.Boltzmann.Collision.CollisionSources | |
| import OAI.MathematicalPhysics.Boltzmann.Collision.CollisionConservation | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.NormalizedCollisionRates | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.NormalizedGainCompactness | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.NormalizedKernelAction | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.NormalizedPairCompactness | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.PeriodicMildApproximation | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.PeriodicRenormalizedCompactness | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.StrongMassClip | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.UniformIntegrability | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.WeakL1Operations | |
| import OAI.MathematicalPhysics.Boltzmann.Jets.TorusTransport | |
| namespace OAI | |
| section | |
| /-! # Strong spatial masses remove gain normalization in measure -/ | |
| noncomputable section | |
| open MeasureTheory Filter | |
| open scoped ENNReal Topology | |
| namespace BoltzmannNonuniqueness.Compactness | |
| variable {X : Type*} [MeasurableSpace X] {ΞΌ : Measure X} [IsFiniteMeasure ΞΌ] | |
| theorem tendstoInMeasure_of_strong_massNormalized | |
| {f r : β β X β β} {g s : X β β} | |
| (hfm : β n, Measurable (f n)) (hrm : β n, Measurable (r n)) | |
| (hr0 : β n x, 0 β€ r n x) (hs0 : β x, 0 β€ s x) | |
| (hr : Tendsto (fun n => eLpNorm (fun x => r n x-s x) 1 ΞΌ) atTop (π 0)) | |
| (hf : Tendsto (fun n => eLpNorm (fun x => | |
| f n x/(1+r n x)-g x/(1+s x)) 1 ΞΌ) atTop (π 0)) : | |
| TendstoInMeasure ΞΌ f atTop g := by | |
| have hri := tendstoInMeasure_of_tendsto_eLpNorm (by norm_num : (1:ββ₯0β) β 0) hr | |
| have hfi := tendstoInMeasure_of_tendsto_eLpNorm (by norm_num : (1:ββ₯0β) β 0) hf | |
| have hrc := tendstoInMeasure_continuous_comp (fun n => (hrm n).aestronglyMeasurable) hri | |
| (P := fun x : β => 1+x) (continuous_const.add continuous_id) | |
| have h := tendstoInMeasure_mul | |
| (fun n => ((hfm n).div (measurable_const.add (hrm n))).aestronglyMeasurable) | |
| (fun n => (measurable_const.add (hrm n)).aestronglyMeasurable) hfi hrc | |
| have he n x : f n x/(1+r n x)*(1+r n x) = f n x := | |
| div_mul_cancelβ _ (by linarith [hr0 n x]) | |
| have heg x : g x/(1+s x)*(1+s x) = g x := div_mul_cancelβ _ (by linarith [hs0 x]) | |
| change TendstoInMeasure ΞΌ (fun n x => f n x/(1+r n x)*(1+r n x)) atTop | |
| (fun x => g x/(1+s x)*(1+s x)) at h | |
| simpa only [he,heg] using h | |
| end BoltzmannNonuniqueness.Compactness | |
| end | |
| end | |
| section | |
| /-! # Compact temporal support of the complete local-mass integrand -/ | |
| noncomputable section | |
| open Set | |
| namespace BoltzmannNonuniqueness | |
| theorem MassTest.exists_time_cutoff (Ο : MassTest) : | |
| β T : β, 0 < T β§ (β x, Ο.toFun T x = 0) β§ | |
| β t, T < t β β p : Phase, Ο.transportDerivative t p = 0 := by | |
| obtain β¨R,hR,hzeroβ© := Ο.compact_time | |
| let L : β Γ Velocity β β := fun z => Ο.toFun z.1 (torusProjection z.2) | |
| have hs : tsupport L β {z : β Γ Velocity | z.1 β€ R} := by | |
| apply closure_minimal | |
| Β· intro z hz | |
| by_contra hn | |
| exact hz (hzero z.1 (torusProjection z.2) ((lt_of_not_ge hn).trans_le (le_abs_self _))) | |
| Β· exact isClosed_le continuous_fst continuous_const | |
| refine β¨R+1,by linarith,?_,?_β© | |
| Β· intro x | |
| exact hzero (R+1) x (by rw [abs_of_pos (by linarith : 0 < R+1)]; linarith) | |
| Β· intro t ht p | |
| have hn : (t,torusRepresentative p.1) β tsupport L := by | |
| intro hp | |
| have := hs hp | |
| change t β€ R at this | |
| linarith | |
| have hd : fderiv β L (t,torusRepresentative p.1) = 0 := fderiv_of_notMem_tsupport β hn | |
| exact congrArg (fun A : (β Γ Velocity) βL[β] β => A (1,p.2)) hd | |
| end BoltzmannNonuniqueness | |
| end | |
| end | |
| section | |
| /-! # The actual finite collision rates divided by the same spatial mass -/ | |
| noncomputable section | |
| open MeasureTheory | |
| namespace BoltzmannNonuniqueness.PeriodicApproximation | |
| open CollisionCompactness Compactness | |
| variable {X : Type*} [MeasurableSpace X] | |
| def massRegularizedPreRate (N : β) (f : X Γ Velocity β β) | |
| (z : (X Γ (Velocity Γ Velocity)) Γ Sphere) : β := | |
| regularizedPreRate N f z/(1+fiberMass volume f z.1.1) | |
| def massRegularizedPostRate (N : β) (f : X Γ Velocity β β) | |
| (z : (X Γ (Velocity Γ Velocity)) Γ Sphere) : β := | |
| regularizedPostRate N f z/(1+fiberMass volume f z.1.1) | |
| theorem massRegularizedPreRate_measurable (N : β) {f : X Γ Velocity β β} | |
| (hfm : Measurable f) : Measurable (massRegularizedPreRate N f) := by | |
| exact (regularizedPreRate_measurable N hfm).div | |
| (measurable_const.add ((fiberMass_measurable hfm).comp measurable_fst.fst)) | |
| omit [MeasurableSpace X] in | |
| theorem massRegularizedPostRate_eq (N : β) (f : X Γ Velocity β β) : | |
| massRegularizedPostRate N f = massRegularizedPreRate N f β scatterTriple := rfl | |
| theorem massRegularizedPostRate_measurable (N : β) {f : X Γ Velocity β β} | |
| (hfm : Measurable f) : Measurable (massRegularizedPostRate N f) := | |
| (massRegularizedPreRate_measurable N hfm).comp scatterTriple_measurable | |
| omit [MeasurableSpace X] in | |
| theorem massRegularizedPreRate_bounds {N : β} (hN : 0 < N) | |
| {f : X Γ Velocity β β} (hf : β p, 0 β€ f p) | |
| (z : (X Γ (Velocity Γ Velocity)) Γ Sphere) : | |
| 0 β€ massRegularizedPreRate N f z β§ massRegularizedPreRate N f z β€ massNormalizedPreRate f z := by | |
| have hd : 0 β€ 1+fiberMass volume f z.1.1 := by | |
| have h : 0 β€ fiberMass volume f z.1.1 := integral_nonneg (fun v => hf (z.1.1,v)) | |
| linarith | |
| exact β¨div_nonneg (regularizedPreRate_bounds hN hf z).1 hd, | |
| div_le_div_of_nonneg_right (regularizedPreRate_le_physical hN hf z) hdβ© | |
| variable {ΞΌ : Measure X} [SFinite ΞΌ] | |
| omit [SFinite ΞΌ] in | |
| theorem massRegularizedPreRate_integrable {N : β} (hN : 0 < N) | |
| {f : X Γ Velocity β β} (hfm : Measurable f) (hf : β p, 0 β€ f p) | |
| (hi : Integrable (weightedNormalizedPair f) (ΞΌ.prod (volume : Measure (Velocity Γ Velocity)))) : | |
| Integrable (massRegularizedPreRate N f) | |
| ((ΞΌ.prod (volume : Measure (Velocity Γ Velocity))).prod sphereArea) := by | |
| apply (massNormalizedPreRate_integrable hfm hi).mono' | |
| (massRegularizedPreRate_measurable N hfm).aestronglyMeasurable | |
| filter_upwards [] with z | |
| rw [Real.norm_of_nonneg (massRegularizedPreRate_bounds hN hf z).1] | |
| exact (massRegularizedPreRate_bounds hN hf z).2 | |
| theorem massRegularizedPostRate_integrable {N : β} (hN : 0 < N) | |
| {f : X Γ Velocity β β} (hfm : Measurable f) (hf : β p, 0 β€ f p) | |
| (hi : Integrable (weightedNormalizedPair f) (ΞΌ.prod (volume : Measure (Velocity Γ Velocity)))) : | |
| Integrable (massRegularizedPostRate N f) | |
| ((ΞΌ.prod (volume : Measure (Velocity Γ Velocity))).prod sphereArea) := | |
| (scatterTriple_measurePreserving ΞΌ).integrable_comp_of_integrable | |
| (massRegularizedPreRate_integrable hN hfm hf hi) | |
| end BoltzmannNonuniqueness.PeriodicApproximation | |
| end | |
| end | |
| section | |
| /-! # Entropy controls the mass-normalized collision rate outside velocity windows -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open scoped ENNReal | |
| namespace BoltzmannNonuniqueness.PeriodicApproximation | |
| open CollisionCompactness Compactness | |
| variable {X : Type*} [MeasurableSpace X] {ΞΌ : Measure X} [SFinite ΞΌ] | |
| theorem massPreRate_velocity_tail {R C : β} (hR : 0 < R) | |
| {f : X Γ Velocity β β} (hfm : Measurable f) (hf : β p, 0 β€ f p) | |
| (hi : Integrable (entropyGauge f) (ΞΌ.prod volume)) | |
| (hb : (β« p, entropyGauge f p βΞΌ.prod volume) β€ C) : | |
| eLpNorm ((collisionWindow R)αΆ.indicator (massNormalizedPreRate f)) 1 | |
| ((ΞΌ.prod (volume : Measure (Velocity Γ Velocity))).prod sphereArea) β€ | |
| ENNReal.ofReal (16*C/R)*eLpNorm (fun _ : Sphere => (1:β)) 1 sphereArea := by | |
| let u : X Γ (Velocity Γ Velocity) β β := | |
| fun z => weightedNormalizedPair f z-pairVelocityCut (R/2) f z | |
| have hum : Measurable u := | |
| (weightedNormalizedPair_measurable hfm).sub (pairVelocityCut_measurable (R/2) hfm) | |
| have hdom (z : (X Γ (Velocity Γ Velocity)) Γ Sphere) : | |
| β((collisionWindow R)αΆ.indicator (massNormalizedPreRate f)) zβ β€ βu z.1β := by | |
| by_cases hz : z β collisionWindow R | |
| Β· rw [indicator_of_notMem (notMem_compl_iff.mpr hz),norm_zero] | |
| exact norm_nonneg _ | |
| Β· have hbox : Β¬(βz.1.2.1β β€ R/2 β§ βz.1.2.2β β€ R/2) := by | |
| intro h | |
| have hv : βz.1.2.1β^2 β€ (R/2)^2 := (sq_le_sqβ (norm_nonneg _) (by positivity)).mpr h.1 | |
| have hw : βz.1.2.2β^2 β€ (R/2)^2 := (sq_le_sqβ (norm_nonneg _) (by positivity)).mpr h.2 | |
| apply hz | |
| change βz.1.2.1β^2+βz.1.2.2β^2 β€ R^2 | |
| nlinarith [sq_nonneg R] | |
| rw [indicator_of_mem (mem_compl hz),massNormalizedPreRate_eq] | |
| change βnormalizedKernel z*weightedNormalizedPair f z.1β β€ | |
| βweightedNormalizedPair f z.1-pairVelocityCut (R/2) f z.1β | |
| simp only [pairVelocityCut,hbox,ite_false,sub_zero,norm_mul] | |
| exact (mul_le_mul_of_nonneg_right (normalizedKernel_bound z) (norm_nonneg _)).trans_eq (one_mul _) | |
| have hm := (massNormalizedPreRate_measurable hfm).indicator (collisionWindow_measurable R).compl | |
| have hn := eLpNorm_mono (p := 1) (ΞΌ := (ΞΌ.prod (volume : Measure (Velocity Γ Velocity))).prod sphereArea) | |
| hm.aestronglyMeasurable hdom | |
| have hp := eLpNorm_mul_prod_one (ΞΌ := ΞΌ.prod (volume.prod volume)) | |
| (Ξ½ := sphereArea) hum (g := fun _ : Sphere => (1:β)) measurable_const | |
| simp only [mul_one] at hp | |
| rw [Measure.volume_eq_prod] at hn | |
| rw [hp] at hn | |
| apply hn.trans | |
| have he := pairVelocityCut_L1_error (half_pos hR) hfm hf hi hb | |
| have hc : 8*C/(R/2) = 16*C/R := by ring | |
| rw [hc] at he | |
| exact mul_le_mul' he le_rfl | |
| end BoltzmannNonuniqueness.PeriodicApproximation | |
| end | |
| end | |
| section | |
| /-! # Strong mass coefficients on bounded collision windows -/ | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped ENNReal Topology | |
| namespace BoltzmannNonuniqueness.PeriodicApproximation | |
| open Compactness CollisionCompactness | |
| variable {X : Type*} [MeasurableSpace X] {ΞΌ : Measure X} [IsFiniteMeasure ΞΌ] | |
| def collisionMassClip (K : β) (f : X Γ Velocity β β) | |
| (z : (X Γ (Velocity Γ Velocity)) Γ Sphere) : β := | |
| massClip K (fiberMass volume f z.1.1) | |
| theorem collisionMassClip_measurable (K : β) {f : X Γ Velocity β β} | |
| (hf : Measurable f) : Measurable (collisionMassClip K f) := | |
| (massClip_measurable K (fiberMass_measurable hf)).comp measurable_fst.fst | |
| theorem collisionMassClip_strong_on_box {f : β β X Γ Velocity β β} {g : X Γ Velocity β β} | |
| (hfm : β n, Measurable (f n)) (hgm : Measurable g) | |
| (hm : Tendsto (fun n => eLpNorm (fun x => fiberMass volume (f n) x-fiberMass volume g x) | |
| 1 ΞΌ) atTop (π 0)) (K R : β) : | |
| Tendsto (fun n => eLpNorm (fun z => collisionMassClip K (f n) z-collisionMassClip K g z) | |
| 1 (((ΞΌ.prod (volume : Measure (Velocity Γ Velocity))).prod sphereArea).restrict | |
| (angularPairBox R))) atTop (π 0) := by | |
| let B : Set (Velocity Γ Velocity) := Metric.closedBall 0 R ΓΛ’ Metric.closedBall 0 R | |
| let Ξ½ : Measure (Velocity Γ Velocity) := volume.restrict B | |
| have : IsFiniteMeasure Ξ½ := by | |
| constructor | |
| dsimp only [Ξ½] | |
| rw [Measure.restrict_apply_univ,Measure.volume_eq_prod,Measure.prod_prod] | |
| exact ENNReal.mul_lt_top (isCompact_closedBall (0:Velocity) R).measure_lt_top | |
| (isCompact_closedBall (0:Velocity) R).measure_lt_top | |
| let a n x := massClip K (fiberMass volume (f n) x)-massClip K (fiberMass volume g x) | |
| have ham n : Measurable (a n) := | |
| (massClip_measurable K (fiberMass_measurable (hfm n))).sub | |
| (massClip_measurable K (fiberMass_measurable hgm)) | |
| have ha := strong_massClip (fun n => fiberMass_measurable (hfm n)) | |
| (fiberMass_measurable hgm) K hm | |
| have ht := strongL1_comp_fst (Ξ½ := sphereArea) | |
| (fun n => (ham n).comp measurable_fst) (strongL1_comp_fst (Ξ½ := Ξ½) ham ha) | |
| have he : (ΞΌ.prod Ξ½).prod sphereArea = | |
| ((ΞΌ.prod (volume : Measure (Velocity Γ Velocity))).prod sphereArea).restrict | |
| (angularPairBox R) := by | |
| dsimp only [Ξ½,angularPairBox,velocityPairBox,B] | |
| rw [β Measure.restrict_prod_eq_prod_univ,β Measure.prod_restrict,Measure.restrict_univ] | |
| rw [he] at ht | |
| exact ht | |
| omit [MeasurableSpace X] in | |
| theorem collisionWindow_subset_angularPairBox {R : β} (hR : 0 β€ R) : | |
| collisionWindow (X := X) R β angularPairBox R := by | |
| intro z hz | |
| have h := collisionWindow_bounds hR hz | |
| exact β¨β¨mem_univ _,by simpa only [Set.mem_prod,Metric.mem_closedBall,dist_zero_right] using hβ©,mem_univ _β© | |
| theorem collisionMassClip_strong_on_window {f : β β X Γ Velocity β β} {g : X Γ Velocity β β} | |
| (hfm : β n, Measurable (f n)) (hgm : Measurable g) | |
| (hm : Tendsto (fun n => eLpNorm (fun x => fiberMass volume (f n) x-fiberMass volume g x) | |
| 1 ΞΌ) atTop (π 0)) (K : β) {R : β} (hR : 0 β€ R) : | |
| Tendsto (fun n => eLpNorm (fun z => collisionMassClip K (f n) z-collisionMassClip K g z) | |
| 1 (((ΞΌ.prod (volume : Measure (Velocity Γ Velocity))).prod sphereArea).restrict | |
| (collisionWindow R))) atTop (π 0) := by | |
| apply tendsto_of_tendsto_of_tendsto_of_le_of_le tendsto_const_nhds | |
| (collisionMassClip_strong_on_box hfm hgm hm K R) (fun _ => zero_le) | |
| exact fun n => eLpNorm_mono_measure _ | |
| (Measure.restrict_mono (collisionWindow_subset_angularPairBox hR) le_rfl) | |
| end BoltzmannNonuniqueness.PeriodicApproximation | |
| end | |
| end | |
| section | |
| /-! # Actual finite pre-rates converge to physical pre-rates on each collision window -/ | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped ENNReal NNReal Topology | |
| namespace BoltzmannNonuniqueness.PeriodicApproximation | |
| open CollisionCompactness Compactness | |
| variable {X : Type*} [MeasurableSpace X] | |
| omit [MeasurableSpace X] in | |
| theorem collisionWindow_mono {R N : β} (hR : 0 β€ R) (hRN : R β€ N) : | |
| collisionWindow (X := X) R β collisionWindow N := by | |
| intro z hz | |
| exact hz.trans ((sq_le_sqβ hR (hR.trans hRN)).mpr hRN) | |
| omit [MeasurableSpace X] in | |
| theorem massRegularizedPreRate_on_window {R N : β} (hR : 0 β€ R) (hRN : R β€ N) | |
| (f : X Γ Velocity β β) (z : (X Γ (Velocity Γ Velocity)) Γ Sphere) | |
| (hz : z β collisionWindow R) : | |
| massRegularizedPreRate N f z = rateMultiplier N f z*massNormalizedPreRate f z := by | |
| unfold massRegularizedPreRate massNormalizedPreRate | |
| rw [regularizedPreRate_factor,windowKernel,indicator_of_mem (collisionWindow_mono hR hRN hz)] | |
| unfold preRate | |
| ring | |
| omit [MeasurableSpace X] in | |
| theorem massRegularizedPreRate_window_difference {R N : β} (hR : 0 β€ R) (hRN : R β€ N) | |
| (f : X Γ Velocity β β) : | |
| (collisionWindow R).indicator (fun z => massRegularizedPreRate N f z-massNormalizedPreRate f z) = | |
| fun z => -((collisionWindow R).indicator (fun z => 1-rateMultiplier N f z) z * | |
| massNormalizedPreRate f z) := by | |
| funext z | |
| by_cases hz : z β collisionWindow R | |
| Β· rw [indicator_of_mem hz,indicator_of_mem hz,massRegularizedPreRate_on_window hR hRN f z hz] | |
| ring | |
| Β· simp only [indicator_of_notMem hz,zero_mul,neg_zero] | |
| variable {ΞΌ : Measure X} [IsFiniteMeasure ΞΌ] | |
| theorem massRegularizedPreRate_window_L1 | |
| {f : β β X Γ Velocity β β} {N : β β β} {C : β} | |
| (R : β) (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) | |
| (hN : β n, 0 < N n) (hNt : Tendsto N atTop atTop) | |
| (B : ββ₯0) (hB : β n, eLpNorm (f n) 1 (ΞΌ.prod volume) β€ B) : | |
| Tendsto (fun n => eLpNorm ((collisionWindow R).indicator | |
| (fun z => massRegularizedPreRate (N n) (f n) z-massNormalizedPreRate (f n) z)) 1 | |
| ((ΞΌ.prod (volume : Measure (Velocity Γ Velocity))).prod sphereArea)) atTop (π 0) := by | |
| have ht := collisionAttenuation_preRate_L1 R hR hfm hf hi hb hN hNt B hB | |
| have he : (fun n => eLpNorm ((collisionWindow R).indicator | |
| (fun z => massRegularizedPreRate (N n) (f n) z-massNormalizedPreRate (f n) z)) 1 | |
| ((ΞΌ.prod (volume : Measure (Velocity Γ Velocity))).prod sphereArea)) =αΆ [atTop] | |
| (fun n => eLpNorm (fun z => (collisionWindow R).indicator | |
| (fun z => 1-rateMultiplier (N n) (f n) z) z*massNormalizedPreRate (f n) z) 1 | |
| ((ΞΌ.prod (volume : Measure (Velocity Γ Velocity))).prod sphereArea)) := by | |
| filter_upwards [hNt.eventually (eventually_ge_atTop R)] with n hn | |
| rw [massRegularizedPreRate_window_difference hR hn] | |
| exact eLpNorm_neg _ _ _ | |
| exact (tendsto_congr' he).mpr ht | |
| end BoltzmannNonuniqueness.PeriodicApproximation | |
| end | |
| end | |
| section | |
| /-! # Removing every collision cutoff from the mass-normalized actual rates -/ | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped ENNReal NNReal Topology | |
| namespace BoltzmannNonuniqueness.PeriodicApproximation | |
| open CollisionCompactness Compactness | |
| variable {X : Type*} [MeasurableSpace X] {ΞΌ : Measure X} [IsFiniteMeasure ΞΌ] | |
| omit [MeasurableSpace X] [IsFiniteMeasure ΞΌ] in | |
| private theorem massRegularizedPreRate_difference_bound {N : β} (hN : 0 < N) | |
| {f : X Γ Velocity β β} (hf : β p, 0 β€ f p) | |
| (z : (X Γ (Velocity Γ Velocity)) Γ Sphere) : | |
| |massRegularizedPreRate N f z-massNormalizedPreRate f z| β€ |massNormalizedPreRate f z| := by | |
| have h := massRegularizedPreRate_bounds hN hf z | |
| rw [abs_of_nonpos (sub_nonpos.mpr h.2),abs_of_nonneg (h.1.trans h.2)] | |
| linarith | |
| theorem massRegularizedPreRate_L1 | |
| {f : β β X Γ Velocity β β} {N : β β β} {C : β} | |
| (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) | |
| (hN : β n, 0 < N n) (hNt : Tendsto N atTop atTop) | |
| (B : ββ₯0) (hB : β n, eLpNorm (f n) 1 (ΞΌ.prod volume) β€ B) : | |
| Tendsto (fun n => eLpNorm (fun z => massRegularizedPreRate (N n) (f n) z- | |
| massNormalizedPreRate (f n) z) 1 | |
| ((ΞΌ.prod (volume : Measure (Velocity Γ Velocity))).prod sphereArea)) atTop (π 0) := by | |
| let Ξ½ := (ΞΌ.prod (volume : Measure (Velocity Γ Velocity))).prod sphereArea | |
| let d n := fun z => massRegularizedPreRate (N n) (f n) z-massNormalizedPreRate (f n) z | |
| let P := eLpNorm (fun _ : Sphere => (1:β)) 1 sphereArea | |
| have hP : P β β€ := (memLp_one_iff_integrable.mpr (integrable_const (1:β))).eLpNorm_ne_top | |
| have hdm n : Measurable (d n) := (massRegularizedPreRate_measurable (N n) (hfm n)).sub | |
| (massNormalizedPreRate_measurable (hfm n)) | |
| have htail (R : β) (hR : 0 < R) (n : β) : | |
| eLpNorm ((collisionWindow R)αΆ.indicator (d n)) 1 Ξ½ β€ ENNReal.ofReal (16*C/R)*P := by | |
| apply le_trans (b := eLpNorm ((collisionWindow R)αΆ.indicator (massNormalizedPreRate (f n))) 1 Ξ½) | |
| Β· apply eLpNorm_mono ((hdm n).indicator (collisionWindow_measurable R).compl).aestronglyMeasurable | |
| intro z | |
| by_cases hz : z β collisionWindow R | |
| Β· simp only [indicator_of_notMem (notMem_compl_iff.mpr hz),norm_zero,le_refl] | |
| Β· simp only [indicator_of_mem (mem_compl hz),Real.norm_eq_abs] | |
| exact massRegularizedPreRate_difference_bound (hN n) (hf n) z | |
| Β· exact massPreRate_velocity_tail hR (hfm n) (hf n) (hi n) (hb n) | |
| have hsplit (R : β) (n : β) : eLpNorm (d n) 1 Ξ½ β€ | |
| eLpNorm ((collisionWindow R).indicator (d n)) 1 Ξ½+ | |
| eLpNorm ((collisionWindow R)αΆ.indicator (d n)) 1 Ξ½ := by | |
| have he : d n = (collisionWindow R).indicator (d n)+(collisionWindow R)αΆ.indicator (d n) := by | |
| funext z | |
| by_cases hz : z β collisionWindow R <;> simp [hz] | |
| conv_lhs => rw [he] | |
| exact eLpNorm_add_le (by norm_num) | |
| have hΞ΄ : Tendsto (fun j : β => ENNReal.ofReal (16*C/((j:β)+1))*P) atTop (π 0) := by | |
| have ht := ENNReal.tendsto_ofReal (tendsto_const_nhds.div_atTop | |
| (tendsto_natCast_atTop_atTop.atTop_add tendsto_const_nhds) : | |
| Tendsto (fun j : β => 16*C/((j:β)+1)) atTop (π 0)) | |
| simpa only [ENNReal.ofReal_zero,zero_mul] using ENNReal.Tendsto.mul_const ht (Or.inr hP) | |
| apply ENNReal.tendsto_nhds_zero.mpr | |
| intro Ξ΅ hΞ΅ | |
| have hΞ΅2 : 0 < Ξ΅/2 := ENNReal.div_pos hΞ΅.ne' (by norm_num) | |
| obtain β¨j,hjβ© := (ENNReal.tendsto_nhds_zero.mp hΞ΄ (Ξ΅/2) hΞ΅2).exists | |
| have hR : 0 < (j:β)+1 := by positivity | |
| have hw := massRegularizedPreRate_window_L1 ((j:β)+1) hR.le hfm hf hi hb hN hNt B hB | |
| filter_upwards [ENNReal.tendsto_nhds_zero.mp hw (Ξ΅/2) hΞ΅2] with n hn | |
| exact (hsplit ((j:β)+1) n).trans ((add_le_add hn ((htail _ hR n).trans hj)).trans_eq Ξ΅.add_halves) | |
| theorem massRegularizedPostRate_L1 | |
| {f : β β X Γ Velocity β β} {N : β β β} {C : β} | |
| (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) | |
| (hN : β n, 0 < N n) (hNt : Tendsto N atTop atTop) | |
| (B : ββ₯0) (hB : β n, eLpNorm (f n) 1 (ΞΌ.prod volume) β€ B) : | |
| Tendsto (fun n => eLpNorm (fun z => massRegularizedPostRate (N n) (f n) z- | |
| massNormalizedPostRate (f n) z) 1 | |
| ((ΞΌ.prod (volume : Measure (Velocity Γ Velocity))).prod sphereArea)) atTop (π 0) := by | |
| have he n : eLpNorm (fun z => massRegularizedPostRate (N n) (f n) z- | |
| massNormalizedPostRate (f n) z) 1 | |
| ((ΞΌ.prod (volume : Measure (Velocity Γ Velocity))).prod sphereArea) = | |
| eLpNorm (fun z => massRegularizedPreRate (N n) (f n) z- | |
| massNormalizedPreRate (f n) z) 1 | |
| ((ΞΌ.prod (volume : Measure (Velocity Γ Velocity))).prod sphereArea) := by | |
| exact eLpNorm_comp_measurePreserving | |
| ((massRegularizedPreRate_measurable (N n) (hfm n)).sub | |
| (massNormalizedPreRate_measurable (hfm n))).aestronglyMeasurable | |
| (scatterTriple_measurePreserving ΞΌ) | |
| simpa only [he] using massRegularizedPreRate_L1 hfm hf hi hb hN hNt B hB | |
| end BoltzmannNonuniqueness.PeriodicApproximation | |
| end | |
| end | |
| section | |
| /-! # Removing velocity cutoffs from strong mass averages -/ | |
| noncomputable section | |
| open MeasureTheory Filter | |
| open scoped ENNReal Topology | |
| namespace BoltzmannNonuniqueness.Compactness | |
| variable {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y] | |
| variable {ΞΌ : Measure X} {Ξ½ : Measure Y} [SFinite ΞΌ] [SFinite Ξ½] | |
| theorem strong_mass_of_velocity_averages {f : β β X Γ Y β β} {g : X Γ Y β β} | |
| (hfm : β n, Measurable (f n)) (hfi : β n, Integrable (f n) (ΞΌ.prod Ξ½)) | |
| (hw : Published.WeakL1Converges (ΞΌ.prod Ξ½) f g) | |
| {k : β β Y β β} (hkm : β j, Measurable (k j)) (hkb : β j y, |k j y| β€ 1) | |
| {Ξ΄ : β β ββ₯0β} (hΞ΄ : Tendsto Ξ΄ atTop (π 0)) | |
| (he : β j n, eLpNorm (fun p => f n p-k j p.2*f n p) 1 (ΞΌ.prod Ξ½) β€ Ξ΄ j) | |
| (hc : β j, Tendsto (fun n => eLpNorm (fun x => | |
| (β« v, k j v*f n (x,v) βΞ½)-(β« v, k j v*g (x,v) βΞ½)) 1 ΞΌ) atTop (π 0)) : | |
| Tendsto (fun n => eLpNorm (fun x => (β« v, f n (x,v) βΞ½)-(β« v, g (x,v) βΞ½)) | |
| 1 ΞΌ) atTop (π 0) := by | |
| let U := fun j n x => β« v, k j v*f n (x,v) βΞ½ | |
| have hu j n : Integrable (fun p : X Γ Y => k j p.2*f n p) (ΞΌ.prod Ξ½) := | |
| (hfi n).bdd_mul ((hkm j).comp measurable_snd).aestronglyMeasurable | |
| (ae_of_all _ (fun p => hkb j p.2)) | |
| have herr j n : eLpNorm ((fun x => β« v, f n (x,v) βΞ½)-U j n) 1 ΞΌ β€ Ξ΄ j := by | |
| have hae : ((fun x => β« v, f n (x,v) βΞ½)-U j n) =α΅[ΞΌ] | |
| (fun x => β« v, f n (x,v)-k j v*f n (x,v) βΞ½) := by | |
| filter_upwards [(hfi n).prod_right_ae,(hu j n).prod_right_ae] with x hfx hux | |
| exact (integral_sub hfx hux).symm | |
| rw [eLpNorm_congr_ae hae] | |
| exact (eLpNorm_integral_le ((hfm n).sub (((hkm j).comp measurable_snd).mul (hfm n)))).trans (he j n) | |
| obtain β¨q,hqi,hqβ© := l1_limit_of_uniform_approximation | |
| (fun n => (hfi n).integral_prod_left) hΞ΄ herr hc | |
| have hwm := hw.marginal hfi (measurable_const : Measurable (fun _ : X Γ Y => (1:β))) 1 | |
| (fun _ => by norm_num) | |
| simp only [one_mul] at hwm | |
| have hq' : Tendsto (fun n => eLpNorm (fun x => (β« v, f n (x,v) βΞ½)-q x) 1 ΞΌ) atTop (π 0) := hq | |
| have hqe := hwm.eq_of_strong (fun n => (hfi n).integral_prod_left) hqi hq' | |
| have hn n : eLpNorm (fun x => (β« v, f n (x,v) βΞ½)-q x) 1 ΞΌ = | |
| eLpNorm (fun x => (β« v, f n (x,v) βΞ½)-(β« v, g (x,v) βΞ½)) 1 ΞΌ := by | |
| apply eLpNorm_congr_ae | |
| filter_upwards [hqe] with x hx | |
| rw [hx] | |
| simpa only [hn] using hq' | |
| end BoltzmannNonuniqueness.Compactness | |
| end | |
| end | |
| section | |
| /-! # The actual finite collision rates have the same mass-normalized weak limit -/ | |
| noncomputable section | |
| open MeasureTheory Filter | |
| open scoped ENNReal NNReal Topology | |
| namespace BoltzmannNonuniqueness.PeriodicApproximation | |
| open CollisionCompactness Compactness | |
| variable {X : Type*} [MeasurableSpace X] {ΞΌ : Measure X} [IsFiniteMeasure ΞΌ] | |
| theorem weak_massRegularizedPreRate | |
| {f : β β X Γ Velocity β β} {g : X Γ Velocity β β} {N : β β β} {C : β} | |
| (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) | |
| (hN : β n, 0 < N n) (hNt : Tendsto N atTop atTop) | |
| (B : ββ₯0) (hB : β n, eLpNorm (f n) 1 (ΞΌ.prod volume) β€ B) | |
| (hw : Published.WeakL1Converges ((ΞΌ.prod (volume : Measure (Velocity Γ Velocity))).prod sphereArea) | |
| (fun n => massNormalizedPreRate (f n)) (massNormalizedPreRate g)) : | |
| Published.WeakL1Converges ((ΞΌ.prod (volume : Measure (Velocity Γ Velocity))).prod sphereArea) | |
| (fun n => massRegularizedPreRate (N n) (f n)) (massNormalizedPreRate g) := by | |
| have hwi n : Integrable (weightedNormalizedPair (f n)) | |
| (ΞΌ.prod (volume : Measure (Velocity Γ Velocity))) := by | |
| rw [Measure.volume_eq_prod] | |
| exact weightedNormalizedPair_integrable (hfm n) (hf n) (hi n) | |
| exact hw.of_eLpNorm_sub (fun n => massNormalizedPreRate_integrable (hfm n) (hwi n)) | |
| (fun n => massRegularizedPreRate_integrable (hN n) (hfm n) (hf n) (hwi n)) | |
| (massRegularizedPreRate_L1 hfm hf hi hb hN hNt B hB) | |
| theorem weak_massRegularizedPostRate | |
| {f : β β X Γ Velocity β β} {g : X Γ Velocity β β} {N : β β β} {C : β} | |
| (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) | |
| (hN : β n, 0 < N n) (hNt : Tendsto N atTop atTop) | |
| (B : ββ₯0) (hB : β n, eLpNorm (f n) 1 (ΞΌ.prod volume) β€ B) | |
| (hw : Published.WeakL1Converges ((ΞΌ.prod (volume : Measure (Velocity Γ Velocity))).prod sphereArea) | |
| (fun n => massNormalizedPostRate (f n)) (massNormalizedPostRate g)) : | |
| Published.WeakL1Converges ((ΞΌ.prod (volume : Measure (Velocity Γ Velocity))).prod sphereArea) | |
| (fun n => massRegularizedPostRate (N n) (f n)) (massNormalizedPostRate g) := by | |
| have hwi n : Integrable (weightedNormalizedPair (f n)) | |
| (ΞΌ.prod (volume : Measure (Velocity Γ Velocity))) := by | |
| rw [Measure.volume_eq_prod] | |
| exact weightedNormalizedPair_integrable (hfm n) (hf n) (hi n) | |
| exact hw.of_eLpNorm_sub (fun n => massNormalizedPostRate_integrable (hfm n) (hwi n)) | |
| (fun n => massRegularizedPostRate_integrable (hN n) (hfm n) (hf n) (hwi n)) | |
| (massRegularizedPostRate_L1 hfm hf hi hb hN hNt B hB) | |
| end BoltzmannNonuniqueness.PeriodicApproximation | |
| end | |
| end | |
| section | |
| /-! # Removing finite collision attenuation from the mass-normalized gain -/ | |
| noncomputable section | |
| open MeasureTheory Filter | |
| open scoped ENNReal NNReal Topology | |
| namespace BoltzmannNonuniqueness.PeriodicApproximation | |
| open Compactness CollisionCompactness CollisionCompactness.DoubleGain | |
| variable {X : Type*} [MeasurableSpace X] {ΞΌ : Measure X} [IsFiniteMeasure ΞΌ] | |
| theorem massRegularized_gain {N : β} (hN : 0 β€ N) (f : X Γ Velocity β β) (p : X Γ Velocity) : | |
| collisionMarginal (massRegularizedPostRate N f) p = gain N f p/(1+fiberMass volume f p.1) := by | |
| change (β« q : Velocity Γ Sphere, | |
| regularizedPostRate N f (collisionGrouping.symm (p,q))/(1+fiberMass volume f p.1) | |
| β(volume : Measure Velocity).prod sphereArea) = _ | |
| rw [integral_div,β gain_eq_full_integral hN] | |
| theorem massNormalized_gain (f : X Γ Velocity β β) (p : X Γ Velocity) : | |
| collisionMarginal (massNormalizedPostRate f) p = gainDensity f p/(1+fiberMass volume f p.1) := by | |
| change (β« q : Velocity Γ Sphere, | |
| postRate f (collisionGrouping.symm (p,q))/(1+fiberMass volume f p.1) | |
| β(volume : Measure Velocity).prod sphereArea) = _ | |
| rw [integral_div] | |
| rfl | |
| theorem massRegularizedGain_L1 | |
| {f : β β X Γ Velocity β β} {N : β β β} {C : β} | |
| (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) | |
| (hN : β n, 0 < N n) (hNt : Tendsto N atTop atTop) | |
| (B : ββ₯0) (hB : β n, eLpNorm (f n) 1 (ΞΌ.prod volume) β€ B) : | |
| Tendsto (fun n => eLpNorm (fun p => | |
| gain (N n) (f n) p/(1+fiberMass volume (f n) p.1)- | |
| gainDensity (f n) p/(1+fiberMass volume (f n) p.1)) 1 (ΞΌ.prod volume)) atTop (π 0) := by | |
| have herr := massRegularizedPostRate_L1 hfm hf hi hb hN hNt B hB | |
| apply tendsto_of_tendsto_of_tendsto_of_le_of_le tendsto_const_nhds herr (fun _ => zero_le) | |
| intro n | |
| have hwi : Integrable (weightedNormalizedPair (f n)) | |
| (ΞΌ.prod (volume : Measure (Velocity Γ Velocity))) := by | |
| simpa only [Measure.volume_eq_prod] using weightedNormalizedPair_integrable (hfm n) (hf n) (hi n) | |
| have hm := massRegularizedPostRate_measurable (N n) (hfm n) | |
| have km := massNormalizedPostRate_measurable (hfm n) | |
| have hri := massRegularizedPostRate_integrable (hN n) (hfm n) (hf n) hwi | |
| have hpi := massNormalizedPostRate_integrable (hfm n) hwi | |
| have h := collisionMarginal_difference_le hm km hri hpi | |
| have he : collisionMarginal (massRegularizedPostRate (N n) (f n))- | |
| collisionMarginal (massNormalizedPostRate (f n)) = | |
| (fun p => gain (N n) (f n) p/(1+fiberMass volume (f n) p.1)- | |
| gainDensity (f n) p/(1+fiberMass volume (f n) p.1)) := by | |
| funext p | |
| exact congrArgβ (fun a b : β => a-b) (massRegularized_gain (hN n).le (f n) p) | |
| (massNormalized_gain (f n) p) | |
| rw [he] at h | |
| exact h | |
| end BoltzmannNonuniqueness.PeriodicApproximation | |
| end | |
| end | |
| section | |
| /-! # Removing finite collision attenuation from the mass-normalized loss -/ | |
| noncomputable section | |
| open MeasureTheory Filter | |
| open scoped ENNReal NNReal Topology | |
| namespace BoltzmannNonuniqueness.PeriodicApproximation | |
| open Compactness CollisionCompactness CollisionCompactness.DoubleGain | |
| variable {X : Type*} [MeasurableSpace X] {ΞΌ : Measure X} [IsFiniteMeasure ΞΌ] | |
| theorem massRegularized_loss {N : β} (hN : 0 β€ N) (f : X Γ Velocity β β) (p : X Γ Velocity) : | |
| collisionMarginal (massRegularizedPreRate N f) p = loss N f p/(1+fiberMass volume f p.1) := by | |
| change (β« q : Velocity Γ Sphere, | |
| regularizedPreRate N f (collisionGrouping.symm (p,q))/(1+fiberMass volume f p.1) | |
| β(volume : Measure Velocity).prod sphereArea) = _ | |
| rw [integral_div,β loss_eq_full_integral hN] | |
| theorem massNormalized_loss (f : X Γ Velocity β β) (p : X Γ Velocity) : | |
| collisionMarginal (massNormalizedPreRate f) p = lossDensity f p/(1+fiberMass volume f p.1) := by | |
| change (β« q : Velocity Γ Sphere, | |
| preRate f (collisionGrouping.symm (p,q))/(1+fiberMass volume f p.1) | |
| β(volume : Measure Velocity).prod sphereArea) = _ | |
| rw [integral_div] | |
| rfl | |
| theorem massRegularizedLoss_L1 | |
| {f : β β X Γ Velocity β β} {N : β β β} {C : β} | |
| (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) | |
| (hN : β n, 0 < N n) (hNt : Tendsto N atTop atTop) | |
| (B : ββ₯0) (hB : β n, eLpNorm (f n) 1 (ΞΌ.prod volume) β€ B) : | |
| Tendsto (fun n => eLpNorm (fun p => | |
| loss (N n) (f n) p/(1+fiberMass volume (f n) p.1)- | |
| lossDensity (f n) p/(1+fiberMass volume (f n) p.1)) 1 (ΞΌ.prod volume)) atTop (π 0) := by | |
| have herr := massRegularizedPreRate_L1 hfm hf hi hb hN hNt B hB | |
| apply tendsto_of_tendsto_of_tendsto_of_le_of_le tendsto_const_nhds herr (fun _ => zero_le) | |
| intro n | |
| have hwi : Integrable (weightedNormalizedPair (f n)) | |
| (ΞΌ.prod (volume : Measure (Velocity Γ Velocity))) := by | |
| simpa only [Measure.volume_eq_prod] using weightedNormalizedPair_integrable (hfm n) (hf n) (hi n) | |
| have hm := massRegularizedPreRate_measurable (N n) (hfm n) | |
| have km := massNormalizedPreRate_measurable (hfm n) | |
| have hri := massRegularizedPreRate_integrable (hN n) (hfm n) (hf n) hwi | |
| have hpi := massNormalizedPreRate_integrable (hfm n) hwi | |
| have h := collisionMarginal_difference_le hm km hri hpi | |
| have he : collisionMarginal (massRegularizedPreRate (N n) (f n))- | |
| collisionMarginal (massNormalizedPreRate (f n)) = | |
| (fun p => loss (N n) (f n) p/(1+fiberMass volume (f n) p.1)- | |
| lossDensity (f n) p/(1+fiberMass volume (f n) p.1)) := by | |
| funext p | |
| exact congrArgβ (fun a b : β => a-b) (massRegularized_loss (hN n).le (f n) p) | |
| (massNormalized_loss (f n) p) | |
| rw [he] at h | |
| exact h | |
| end BoltzmannNonuniqueness.PeriodicApproximation | |
| end | |
| end | |
| end OAI | |