openAI-math-dataset / lean /OAI /MathematicalPhysics /Boltzmann /Collision /VelocityCutoffEntropyError.lean
| import OAI.MathematicalPhysics.Boltzmann.Branching.MarginalUniformIntegrability | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.EntropyUniformIntegrability | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.UniformIntegrability | |
| import OAI.MathematicalPhysics.Boltzmann.Model | |
| import Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | |
| import Mathlib.Analysis.Calculus.BumpFunction.Normed | |
| namespace OAI | |
| section | |
| /-! # Uniform integrability of the linear velocity moment from entropy and energy -/ | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped ENNReal NNReal | |
| namespace BoltzmannNonuniqueness.PeriodicApproximation | |
| variable {X : Type*} [MeasurableSpace X] | |
| def linearMoment (f : X × Velocity → ℝ) (p : X × Velocity) : ℝ := (1+‖p.2‖)*f p | |
| def velocityLinearCut (R : ℝ) (f : X × Velocity → ℝ) (p : X × Velocity) : ℝ := | |
| if ‖p.2‖ ≤ R then linearMoment f p else 0 | |
| theorem linearMoment_measurable {f : X × Velocity → ℝ} (hf : Measurable f) : | |
| Measurable (linearMoment f) := (measurable_const.add measurable_snd.norm).mul hf | |
| theorem velocityLinearCut_measurable (R : ℝ) {f : X × Velocity → ℝ} (hf : Measurable f) : | |
| Measurable (velocityLinearCut R f) := (linearMoment_measurable hf).ite | |
| (measurableSet_le measurable_snd.norm measurable_const) measurable_const | |
| theorem linearMoment_integrable {μ : Measure (X × Velocity)} {f : X × Velocity → ℝ} | |
| (hfm : Measurable f) (hf : ∀ p, 0 ≤ f p) (hi : Integrable (entropyGauge f) μ) : | |
| Integrable (linearMoment f) μ := by | |
| apply (hi.const_mul 2).mono' (linearMoment_measurable hfm).aestronglyMeasurable | |
| filter_upwards [] with p | |
| change ‖(1+‖p.2‖)*f p‖ ≤ _ | |
| rw [Real.norm_of_nonneg (mul_nonneg (by positivity) (hf p))] | |
| have h : 1+‖p.2‖ ≤ 2*(1+‖p.2‖^2+|Real.log (f p)|) := by | |
| nlinarith [sq_nonneg (‖p.2‖-1),abs_nonneg (Real.log (f p))] | |
| simpa only [linearMoment,entropyGauge,mul_assoc,mul_left_comm,mul_comm] using | |
| mul_le_mul_of_nonneg_right h (hf p) | |
| omit [MeasurableSpace X] in | |
| theorem velocityLinearCut_error {R : ℝ} (hR : 0 < R) {f : X × Velocity → ℝ} | |
| (hf : ∀ p, 0 ≤ f p) (p : X × Velocity) : | |
| |linearMoment f p-velocityLinearCut R f p| ≤ 2*entropyGauge f p/R := by | |
| by_cases hp : ‖p.2‖ ≤ R | |
| · simp only [velocityLinearCut,ite_eq_left hp,sub_self,abs_zero] | |
| exact div_nonneg (mul_nonneg (by norm_num) (entropyGauge_nonneg hf p)) hR.le | |
| · have hr : R ≤ ‖p.2‖ := (lt_of_not_ge hp).le | |
| simp only [velocityLinearCut,ite_eq_right hp,sub_zero,linearMoment] | |
| rw [abs_of_nonneg (mul_nonneg (by positivity) (hf p))] | |
| apply (le_div_iff₀ hR).mpr | |
| have hcoeff : (1+‖p.2‖)*R ≤ 2*(1+‖p.2‖^2+|Real.log (f p)|) := by | |
| have hh := mul_le_mul_of_nonneg_left hr (show 0 ≤ 1+‖p.2‖ by positivity) | |
| nlinarith [sq_nonneg (‖p.2‖-1),abs_nonneg (Real.log (f p))] | |
| simpa only [entropyGauge,mul_assoc,mul_left_comm,mul_comm] using | |
| mul_le_mul_of_nonneg_right hcoeff (hf p) | |
| theorem velocityLinearCut_integrable {μ : Measure (X × Velocity)} (R : ℝ) | |
| {f : X × Velocity → ℝ} (hfm : Measurable f) (hf : ∀ p, 0 ≤ f p) | |
| (hi : Integrable (entropyGauge f) μ) : Integrable (velocityLinearCut R f) μ := by | |
| apply (linearMoment_integrable hfm hf hi).mono' | |
| (velocityLinearCut_measurable R hfm).aestronglyMeasurable | |
| filter_upwards [] with p | |
| have hn : 0 ≤ linearMoment f p := mul_nonneg (by positivity) (hf p) | |
| by_cases hp : ‖p.2‖ ≤ R | |
| · rw [velocityLinearCut,ite_eq_left hp,Real.norm_of_nonneg hn] | |
| · rw [velocityLinearCut,ite_eq_right hp,norm_zero] | |
| exact hn | |
| theorem velocityLinearCut_L1_error {μ : Measure (X × Velocity)} {R C : ℝ} (hR : 0 < R) | |
| {f : X × Velocity → ℝ} (hfm : Measurable f) (hf : ∀ p, 0 ≤ f p) | |
| (hi : Integrable (entropyGauge f) μ) (hb : (∫ p, entropyGauge f p ∂μ) ≤ C) : | |
| eLpNorm (fun p => linearMoment f p-velocityLinearCut R f p) 1 μ ≤ ENNReal.ofReal (2*C/R) := by | |
| have he := (linearMoment_integrable hfm hf hi).sub (velocityLinearCut_integrable R hfm hf hi) | |
| change Integrable (fun p => linearMoment f p-velocityLinearCut R f p) μ at he | |
| rw [eLpNorm_one_eq_lintegral_enorm he.aestronglyMeasurable, | |
| ← ofReal_integral_norm_eq_lintegral_enorm he] | |
| apply ENNReal.ofReal_le_ofReal | |
| calc | |
| _ ≤ ∫ p, 2*entropyGauge f p/R ∂μ := | |
| integral_mono he.norm ((hi.const_mul 2).div_const R) (fun p => by | |
| simpa only [Real.norm_eq_abs] using velocityLinearCut_error hR hf p) | |
| _ = 2*(∫ p, entropyGauge f p ∂μ)/R := by rw [integral_div,integral_const_mul] | |
| _ ≤ 2*C/R := div_le_div_of_nonneg_right (by linarith) hR.le | |
| theorem linearMoment_uniformIntegrable {μ : Measure X} [IsFiniteMeasure μ] | |
| {f : ℕ → X × Velocity → ℝ} {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) : | |
| UniformIntegrable (fun n => linearMoment (f n)) 1 (μ.prod volume) := by | |
| have hui := uniformIntegrable_of_entropyGauge hfm hf hi hb | |
| apply Compactness.uniformIntegrable_of_approximation (g := fun j n => velocityLinearCut ((j:ℝ)+1) (f n)) | |
| · intro j | |
| let a : X × Velocity → ℝ := fun p => if ‖p.2‖ ≤ (j:ℝ)+1 then 1+‖p.2‖ else 0 | |
| have ha : Measurable a := (measurable_const.add measurable_snd.norm).ite | |
| (measurableSet_le measurable_snd.norm measurable_const) measurable_const | |
| let D : ℝ≥0 := ⟨(j:ℝ)+2,by positivity⟩ | |
| have hD (p : X × Velocity) : |a p| ≤ D := by | |
| change |if ‖p.2‖ ≤ (j:ℝ)+1 then 1+‖p.2‖ else 0| ≤ (j:ℝ)+2 | |
| split_ifs with hp | |
| · rw [abs_of_nonneg (by positivity)] | |
| linarith | |
| · simp only [abs_zero] | |
| positivity | |
| change UniformIntegrable (fun n p => if ‖p.2‖ ≤ (j:ℝ)+1 then | |
| (1+‖p.2‖)*f n p else 0) 1 (μ.prod volume) | |
| simpa only [a,ite_mul,zero_mul] using | |
| Compactness.uniformIntegrable_of_bounded_multiplier hui ha D hD | |
| · intro ε hε | |
| obtain ⟨j,hj⟩ := exists_entropyTruncation_radius (2*C) hε | |
| exact ⟨j,fun n => (velocityLinearCut_L1_error (by positivity) (hfm n) (hf n) (hi n) (hb n)).trans hj⟩ | |
| end BoltzmannNonuniqueness.PeriodicApproximation | |
| end | |
| end | |
| section | |
| /-! # Compactly supported unit-mass velocity kernels of arbitrarily small radius -/ | |
| noncomputable section | |
| open MeasureTheory | |
| namespace BoltzmannNonuniqueness.CollisionCompactness.DoubleGain | |
| theorem exists_velocity_mollifier {δ : ℝ} (hδ : 0 < δ) : | |
| ∃ χ : C(Velocity,ℝ), HasCompactSupport χ ∧ Integrable χ ∧ | |
| (∀ a, 0 ≤ χ a) ∧ (∫ a, χ a) = 1 ∧ (∀ a, χ a ≠ 0 → ‖a‖ < δ) := by | |
| let b : ContDiffBump (0 : Velocity) := ⟨δ/2,δ,by linarith,by linarith⟩ | |
| let χ : C(Velocity,ℝ) := ⟨b.normed volume,b.continuous_normed⟩ | |
| refine ⟨χ,b.hasCompactSupport_normed,b.integrable_normed,?_,b.integral_normed,?_⟩ | |
| · exact b.nonneg_normed | |
| · intro a ha | |
| have hs : a ∈ Function.support (b.normed (volume : Measure Velocity)) := ha | |
| rw [b.support_normed_eq] at hs | |
| simpa only [Metric.mem_ball,dist_zero_right] using hs | |
| end BoltzmannNonuniqueness.CollisionCompactness.DoubleGain | |
| end | |
| end | |
| section | |
| /-! # Uniform integrability of the spatial mass and first-moment marginal -/ | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped ENNReal | |
| namespace BoltzmannNonuniqueness.PeriodicApproximation | |
| variable {X : Type*} [MeasurableSpace X] | |
| theorem linearMoment_marginal_uniformIntegrable {μ : Measure X} [IsFiniteMeasure μ] | |
| {f : ℕ → X × Velocity → ℝ} {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) : | |
| UniformIntegrable (fun n x => ∫ v, linearMoment (f n) (x,v)) 1 μ := by | |
| have hui := linearMoment_uniformIntegrable hfm hf hi hb | |
| have he (R : ℝ) (n : ℕ) (x : X) : | |
| (∫ v, velocityLinearCut R (f n) (x,v)) = | |
| ∫ v in Metric.closedBall (0:Velocity) R, linearMoment (f n) (x,v) := by | |
| rw [← integral_indicator Metric.isClosed_closedBall.measurableSet] | |
| congr 1 | |
| ext v | |
| simp only [velocityLinearCut,indicator,Metric.mem_closedBall,dist_zero_right] | |
| apply Compactness.uniformIntegrable_of_approximation | |
| (g := fun j n x => ∫ v, velocityLinearCut ((j:ℝ)+1) (f n) (x,v)) | |
| · intro j | |
| let s : Set Velocity := Metric.closedBall 0 ((j:ℝ)+1) | |
| let : IsFiniteMeasure ((volume : Measure Velocity).restrict s) := | |
| isFiniteMeasure_restrict.mpr (isCompact_closedBall (0:Velocity) ((j:ℝ)+1)).measure_lt_top.ne | |
| have hu := Compactness.uniformIntegrable_restrict hui (univ ×ˢ s) | |
| rw [← Measure.prod_restrict,Measure.restrict_univ] at hu | |
| have hm := Compactness.uniformIntegrable_integral (fun n => linearMoment_measurable (hfm n)) hu | |
| simpa only [he] using hm | |
| · intro ε hε | |
| obtain ⟨j,hj⟩ := exists_entropyTruncation_radius (2*C) hε | |
| refine ⟨j,fun n => ?_⟩ | |
| have hfi := linearMoment_integrable (hfm n) (hf n) (hi n) | |
| have hgi := velocityLinearCut_integrable ((j:ℝ)+1) (hfm n) (hf n) (hi n) | |
| have hae : (fun x => (∫ v, linearMoment (f n) (x,v))- | |
| ∫ v, velocityLinearCut ((j:ℝ)+1) (f n) (x,v)) =ᵐ[μ] | |
| (fun x => ∫ v, linearMoment (f n) (x,v)-velocityLinearCut ((j:ℝ)+1) (f n) (x,v)) := by | |
| filter_upwards [hfi.prod_right_ae,hgi.prod_right_ae] with x hfx hgx | |
| exact (integral_sub hfx hgx).symm | |
| rw [eLpNorm_congr_ae hae] | |
| exact (Compactness.eLpNorm_integral_le | |
| ((linearMoment_measurable (hfm n)).sub (velocityLinearCut_measurable ((j:ℝ)+1) (hfm n)))).trans | |
| ((velocityLinearCut_L1_error (by positivity) (hfm n) (hf n) (hi n) (hb n)).trans hj) | |
| end BoltzmannNonuniqueness.PeriodicApproximation | |
| end | |
| end | |
| section | |
| /-! # Removing bounded velocity cutoffs by the uniform energy-entropy budget -/ | |
| noncomputable section | |
| open MeasureTheory | |
| open scoped ENNReal | |
| namespace BoltzmannNonuniqueness.PeriodicApproximation | |
| variable {X : Type*} [MeasurableSpace X] | |
| omit [MeasurableSpace X] in | |
| theorem velocityCutoff_error_le {f : X × Velocity → ℝ} {β : Velocity → ℝ} {R : ℝ} | |
| (hR : 0 < R) (hf : ∀ p, 0 ≤ f p) (hβ0 : ∀ v, 0 ≤ β v) (hβ1 : ∀ v, β v ≤ 1) | |
| (hβeq : ∀ v, ‖v‖ ≤ R → β v = 1) (p : X × Velocity) : | |
| |f p-β p.2*f p| ≤ entropyGauge f p/R^2 := by | |
| have hfn := hf p | |
| have hnon : 0 ≤ f p-β p.2*f p := by nlinarith [hβ1 p.2] | |
| rw [abs_of_nonneg hnon] | |
| apply (le_div_iff₀ (sq_pos_of_pos hR)).mpr | |
| by_cases hv : ‖p.2‖ ≤ R | |
| · rw [hβeq p.2 hv,one_mul,sub_self,zero_mul] | |
| exact entropyGauge_nonneg hf p | |
| · have hv' : R < ‖p.2‖ := lt_of_not_ge hv | |
| have hs : R^2 ≤ ‖p.2‖^2 := by nlinarith | |
| have hle : f p-β p.2*f p ≤ f p := by nlinarith [hβ0 p.2] | |
| have hlog := abs_nonneg (Real.log (f p)) | |
| unfold entropyGauge | |
| nlinarith [mul_le_mul_of_nonneg_right hle (sq_nonneg R), | |
| mul_le_mul_of_nonneg_left hs hfn,mul_nonneg hfn hlog] | |
| theorem velocityCutoff_L1_bound {μ : Measure (X × Velocity)} {f : X × Velocity → ℝ} | |
| {β : Velocity → ℝ} {R C : ℝ} (hR : 0 < R) | |
| (hfm : Measurable f) (hf : ∀ p, 0 ≤ f p) (hβm : Measurable β) | |
| (hβ0 : ∀ v, 0 ≤ β v) (hβ1 : ∀ v, β v ≤ 1) | |
| (hβeq : ∀ v, ‖v‖ ≤ R → β v = 1) | |
| (hi : Integrable (entropyGauge f) μ) (hb : (∫ p, entropyGauge f p ∂μ) ≤ C) : | |
| eLpNorm (fun p => f p-β p.2*f p) 1 μ ≤ ENNReal.ofReal (C/R^2) := by | |
| have hfi := integrable_of_entropyGauge hfm hf hi | |
| have hbi : Integrable (fun p => β p.2*f p) μ := hfi.bdd_mul | |
| (hβm.comp measurable_snd).aestronglyMeasurable | |
| (ae_of_all _ (fun p => by rw [Real.norm_of_nonneg (hβ0 p.2)]; exact hβ1 p.2)) | |
| have hei := hfi.sub hbi | |
| change Integrable (fun p => f p-β p.2*f p) μ at hei | |
| rw [eLpNorm_one_eq_lintegral_enorm hei.aestronglyMeasurable, | |
| ← ofReal_integral_norm_eq_lintegral_enorm hei] | |
| apply ENNReal.ofReal_le_ofReal | |
| calc | |
| _ ≤ ∫ p, entropyGauge f p/R^2 ∂μ := integral_mono hei.norm (hi.div_const (R^2)) | |
| (fun p => by simpa only [Real.norm_eq_abs] using velocityCutoff_error_le hR hf hβ0 hβ1 hβeq p) | |
| _ = (∫ p, entropyGauge f p ∂μ)/R^2 := integral_div _ _ | |
| _ ≤ _ := div_le_div_of_nonneg_right hb (sq_nonneg R) | |
| end BoltzmannNonuniqueness.PeriodicApproximation | |
| end | |
| end | |
| end OAI | |