openAI-math-dataset / lean /OAI /MathematicalPhysics /Boltzmann /Compactness /EntropyUniformIntegrability.lean
| import OAI.MathematicalPhysics.Boltzmann.Branching.BoundedVelocityIntegral | |
| import OAI.MathematicalPhysics.Boltzmann.Collision.ScalarEntropyConvex | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.EntropyIntegralBalance | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.UniformIntegrability | |
| import Mathlib.MeasureTheory.Function.UnifTight | |
| import Mathlib.MeasureTheory.Integral.DominatedConvergence | |
| namespace OAI | |
| section | |
| /-! # Joint value and velocity truncation controlled by absolute entropy -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| namespace BoltzmannNonuniqueness.PeriodicApproximation | |
| variable {X : Type*} [MeasurableSpace X] | |
| def entropyGauge (f : X × Velocity → ℝ) (p : X × Velocity) : ℝ := | |
| f p*(1+‖p.2‖^2+|Real.log (f p)|) | |
| def entropyTruncation (R : ℝ) (f : X × Velocity → ℝ) (p : X × Velocity) : ℝ := | |
| if ‖p.2‖ ≤ R ∧ f p ≤ Real.exp R then f p else 0 | |
| theorem entropyGauge_measurable {f : X × Velocity → ℝ} (hf : Measurable f) : | |
| Measurable (entropyGauge f) := | |
| hf.mul ((measurable_const.add (measurable_snd.norm.pow_const 2)).add hf.log.abs) | |
| theorem entropyTruncation_measurable (R : ℝ) {f : X × Velocity → ℝ} (hf : Measurable f) : | |
| Measurable (entropyTruncation R f) := | |
| Measurable.ite ((measurableSet_le measurable_snd.norm measurable_const).inter | |
| (measurableSet_le hf measurable_const)) hf measurable_const | |
| omit [MeasurableSpace X] in | |
| theorem entropyGauge_nonneg {f : X × Velocity → ℝ} (hf : ∀ p, 0 ≤ f p) (p : X × Velocity) : | |
| 0 ≤ entropyGauge f p := mul_nonneg (hf p) (by positivity) | |
| omit [MeasurableSpace X] in | |
| theorem entropyGauge_ge_density {f : X × Velocity → ℝ} (hf : ∀ p, 0 ≤ f p) (p : X × Velocity) : | |
| f p ≤ entropyGauge f p := by | |
| have hs := mul_nonneg (hf p) (sq_nonneg ‖p.2‖) | |
| have hl := mul_nonneg (hf p) (abs_nonneg (Real.log (f p))) | |
| unfold entropyGauge | |
| nlinarith | |
| omit [MeasurableSpace X] in | |
| theorem entropyTruncation_bounds (R : ℝ) {f : X × Velocity → ℝ} (hf : ∀ p, 0 ≤ f p) (p : X × Velocity) : | |
| 0 ≤ entropyTruncation R f p ∧ entropyTruncation R f p ≤ Real.exp R := by | |
| unfold entropyTruncation | |
| split_ifs with hp | |
| · exact ⟨hf p,hp.2⟩ | |
| · exact ⟨le_rfl,(Real.exp_pos R).le⟩ | |
| omit [MeasurableSpace X] in | |
| theorem entropyTruncation_support (R : ℝ) (f : X × Velocity → ℝ) (p : X × Velocity) | |
| (hp : R < ‖p.2‖) : entropyTruncation R f p = 0 := by | |
| simp only [entropyTruncation,not_le.mpr hp,false_and,ite_false] | |
| omit [MeasurableSpace X] in | |
| theorem entropyTruncation_error {R : ℝ} (hR : 1 ≤ R) {f : X × Velocity → ℝ} | |
| (hf : ∀ p, 0 ≤ f p) (p : X × Velocity) : | |
| |f p-entropyTruncation R f p| ≤ entropyGauge f p/R := by | |
| have hR0 : 0 < R := lt_of_lt_of_le zero_lt_one hR | |
| unfold entropyTruncation | |
| split_ifs with hp | |
| · rw [sub_self,abs_zero] | |
| exact div_nonneg (entropyGauge_nonneg hf p) hR0.le | |
| · rw [sub_zero,abs_of_nonneg (hf p)] | |
| apply (le_div_iff₀ hR0).mpr | |
| have hn := hf p | |
| have he : 0 ≤ ‖p.2‖^2 := sq_nonneg _ | |
| have hl : 0 ≤ |Real.log (f p)| := abs_nonneg _ | |
| by_cases hv : ‖p.2‖ ≤ R | |
| · have hbig : Real.exp R < f p := lt_of_not_ge (fun ha => hp ⟨hv,ha⟩) | |
| have hlog : R ≤ Real.log (f p) := by | |
| simpa only [Real.log_exp] using Real.log_le_log (Real.exp_pos R) hbig.le | |
| have hh := mul_le_mul_of_nonneg_left (hlog.trans (le_abs_self _)) hn | |
| unfold entropyGauge | |
| nlinarith [mul_nonneg hn he] | |
| · have hvR : R < ‖p.2‖ := lt_of_not_ge hv | |
| have hs : R ≤ ‖p.2‖^2 := by nlinarith [norm_nonneg p.2] | |
| have hh := mul_le_mul_of_nonneg_left hs hn | |
| unfold entropyGauge | |
| nlinarith [mul_nonneg hn hl] | |
| end BoltzmannNonuniqueness.PeriodicApproximation | |
| end | |
| end | |
| section | |
| /-! # Entropy convergence of truncations with a vanishing bounded perturbation -/ | |
| noncomputable section | |
| open MeasureTheory Filter | |
| open scoped Topology | |
| open BoltzmannNonuniqueness.VelocityWeight | |
| namespace BoltzmannNonuniqueness | |
| theorem scalarRelativeEntropy_truncation_perturbation_le {q C p a b f : ℝ} | |
| (hC : 0 ≤ C) (hp : 1 < p) (v : Velocity) | |
| (ha : 0 ≤ a) (haf : a ≤ f) (hb : 0 ≤ b) (hbg : b ≤ C*H q v) : | |
| scalarRelativeEntropy (maxwellian v) (a+b) ≤ | |
| scalarRelativeEntropy (maxwellian v) f+entropyPowerMajorant q C p v+ | |
| (f+C*H q v)*Real.log 2 := by | |
| have hs := scalarRelativeEntropy_add_le (m := maxwellian v) ha hb | |
| have hcut := scalarRelativeEntropy_le_of_le (maxwellian_pos v) ha haf | |
| have hhot := scalarRelativeEntropy_le_majorant hC hp v hb hbg | |
| have hmass := mul_le_mul_of_nonneg_right (add_le_add haf hbg) | |
| (Real.log_nonneg (by norm_num : (1:ℝ) ≤ 2)) | |
| linarith | |
| theorem entropy_truncation_perturbation_tendsto {q C p : ℝ} | |
| (hq : q < 2) (hC : 0 ≤ C) (hp : 1 < p) | |
| (hpi : Integrable (fun v : Velocity => H q v^p)) | |
| {f : Density} (hf : FiniteEntropyDatum f) | |
| {a b : ℕ → Density} (ham : ∀ n, Measurable (a n)) (hbm : ∀ n, Measurable (b n)) | |
| (ha : ∀ n z, 0 ≤ a n z ∧ a n z ≤ f z) | |
| (hb : ∀ n z, 0 ≤ b n z ∧ b n z ≤ C*H q z.2) | |
| (halim : ∀ z, Tendsto (fun n => a n z) atTop (𝓝 (f z))) | |
| (hblim : ∀ z, Tendsto (fun n => b n z) atTop (𝓝 0)) : | |
| Tendsto (fun n => ∫ z, scalarRelativeEntropy (maxwellian z.2) (a n z+b n z)) | |
| atTop (𝓝 (relativeEntropy f)) := by | |
| let B : Phase → ℝ := fun z => scalarRelativeEntropy (maxwellian z.2) (f z)+ | |
| entropyPowerMajorant q C p z.2+(f z+C*H q z.2)*Real.log 2 | |
| have hHi : Integrable (fun z => scalarRelativeEntropy (maxwellian z.2) (f z)) := by | |
| apply (FiniteEntropyDatum.integrable_relativeEntropy hf).congr | |
| filter_upwards [] with z | |
| exact (scalarRelativeEntropy_eq (maxwellian_pos z.2) (f z)).symm | |
| have hBi : Integrable B := by | |
| exact (hHi.add ((entropyPowerMajorant_integrable (B := C) hq hpi).comp_snd volume)).add | |
| (((FiniteEntropyDatum.integrable hf).add (((integrable_H hq).const_mul C).comp_snd volume)).mul_const _) | |
| have hlim := tendsto_integral_of_dominated_convergence B (fun n => by | |
| have hm : Measurable (fun z : Phase => scalarRelativeEntropy (maxwellian z.2) (a n z+b n z)) := by | |
| have hsum := (ham n).add (hbm n) | |
| have hM : Measurable (fun z : Phase => maxwellian z.2) := by unfold maxwellian; fun_prop | |
| exact ((hsum.mul hsum.log).sub (hsum.mul (measurable_const.add hM.log))).add hM | |
| exact hm.aestronglyMeasurable) hBi (fun n => by | |
| filter_upwards [] with z | |
| rw [Real.norm_of_nonneg (scalarRelativeEntropy_nonneg (maxwellian_pos z.2) | |
| (add_nonneg (ha n z).1 (hb n z).1))] | |
| exact scalarRelativeEntropy_truncation_perturbation_le hC hp z.2 (ha n z).1 (ha n z).2 | |
| (hb n z).1 (hb n z).2) (by | |
| filter_upwards [] with z | |
| have hs : Tendsto (fun n => a n z+b n z) atTop (𝓝 (f z)) := by | |
| simpa only [add_zero] using (halim z).add (hblim z) | |
| exact ((scalarRelativeEntropy_continuous (maxwellian z.2)).tendsto (f z)).comp hs) | |
| have he : (∫ z, scalarRelativeEntropy (maxwellian z.2) (f z)) = relativeEntropy f := by | |
| apply integral_congr_ae | |
| filter_upwards [] with z | |
| exact scalarRelativeEntropy_eq (maxwellian_pos z.2) (f z) | |
| rwa [he] at hlim | |
| end BoltzmannNonuniqueness | |
| end | |
| end | |
| section | |
| /-! # Uniform L1 approximation by bounded velocity truncations -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open scoped ENNReal | |
| namespace BoltzmannNonuniqueness.PeriodicApproximation | |
| variable {X : Type*} [MeasurableSpace X] | |
| theorem integrable_of_entropyGauge {μ : Measure (X × Velocity)} {f : X × Velocity → ℝ} | |
| (hfm : Measurable f) (hf : ∀ p, 0 ≤ f p) (hi : Integrable (entropyGauge f) μ) : Integrable f μ := by | |
| apply hi.mono' hfm.aestronglyMeasurable | |
| exact Filter.Eventually.of_forall (fun p => by | |
| rw [Real.norm_of_nonneg (hf p)] | |
| exact entropyGauge_ge_density hf p) | |
| theorem entropyTruncation_integrable {μ : Measure X} [IsFiniteMeasure μ] | |
| (R : ℝ) {f : X × Velocity → ℝ} (hfm : Measurable f) (hf : ∀ p, 0 ≤ f p) : | |
| Integrable (entropyTruncation R f) (μ.prod volume) := | |
| bounded_velocity_integrable (entropyTruncation_measurable R hfm) | |
| (fun p => (abs_of_nonneg (entropyTruncation_bounds R hf p).1).trans_le | |
| (entropyTruncation_bounds R hf p).2) (entropyTruncation_support R f) | |
| theorem entropyTruncation_L1_bound {μ : Measure X} [IsFiniteMeasure μ] | |
| {R C : ℝ} (hR : 1 ≤ 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 (fun p => f p-entropyTruncation R f p) 1 (μ.prod volume) ≤ ENNReal.ofReal (C/R) := by | |
| have hei := (integrable_of_entropyGauge hfm hf hi).sub (entropyTruncation_integrable R hfm hf) | |
| change Integrable (fun p => f p-entropyTruncation R f p) (μ.prod volume) 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 ∂μ.prod volume := | |
| integral_mono hei.norm (hi.div_const R) (fun p => by | |
| simpa only [Real.norm_eq_abs] using entropyTruncation_error hR hf p) | |
| _ = (∫ p, entropyGauge f p ∂μ.prod volume)/R := integral_div R _ | |
| _ ≤ C/R := div_le_div_of_nonneg_right hb (zero_le_one.trans hR) | |
| theorem entropyTruncation_uniformIntegrable {μ : Measure X} [IsFiniteMeasure μ] | |
| (R : ℝ) {f : ℕ → X × Velocity → ℝ} (hfm : ∀ n, Measurable (f n)) (hf : ∀ n p, 0 ≤ f n p) : | |
| UniformIntegrable (fun n => entropyTruncation R (f n)) 1 (μ.prod volume) := by | |
| let g : X × Velocity → ℝ := fun p => | |
| (Metric.closedBall (0:Velocity) R).indicator (fun _ => Real.exp R) p.2 | |
| have hi : Integrable g (μ.prod volume) := | |
| ((integrableOn_const (isCompact_closedBall (0:Velocity) R).measure_lt_top.ne).integrable_indicator | |
| Metric.isClosed_closedBall.measurableSet).comp_snd μ | |
| have hg := uniformIntegrable_const (ι := ℕ) (by norm_num : (1:ℝ≥0∞) ≤ 1) (by norm_num) (memLp_one_iff_integrable.mpr hi) | |
| have hdom (n : ℕ) (p : X × Velocity) : ‖entropyTruncation R (f n) p‖ ≤ g p := by | |
| rw [Real.norm_of_nonneg (entropyTruncation_bounds R (hf n) p).1] | |
| by_cases hp : p.2 ∈ Metric.closedBall 0 R | |
| · rw [show g p = Real.exp R from indicator_of_mem hp _] | |
| exact (entropyTruncation_bounds R (hf n) p).2 | |
| · have hv : R < ‖p.2‖ := by simpa only [Metric.mem_closedBall,dist_zero_right,not_le] using hp | |
| rw [entropyTruncation_support R (f n) p hv,show g p = 0 from indicator_of_notMem hp _] | |
| have hmono (n : ℕ) (s : Set (X × Velocity)) : | |
| eLpNorm (entropyTruncation R (f n)) 1 ((μ.prod volume).restrict s) ≤ | |
| eLpNorm g 1 ((μ.prod volume).restrict s) := | |
| eLpNorm_mono_real (entropyTruncation_measurable R (hfm n)).aestronglyMeasurable (hdom n) | |
| refine ⟨unifIntegrable_iff.mpr ?_,?_⟩ | |
| · intro ε hε | |
| obtain ⟨δ,hδ,hgδ⟩ := unifIntegrable_iff.mp hg.1 ε hε | |
| exact ⟨δ,hδ,fun n s hs => (hmono n s).trans (hgδ n s hs)⟩ | |
| · obtain ⟨C,hC⟩ := hg.2 | |
| refine ⟨C,fun n => ?_⟩ | |
| have h := (hmono n univ).trans (by simpa only [Measure.restrict_univ] using hC n) | |
| simpa only [Measure.restrict_univ] using h | |
| end BoltzmannNonuniqueness.PeriodicApproximation | |
| end | |
| end | |
| section | |
| /-! # Uniform entropy and velocity moments imply L1 compactness hypotheses -/ | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped Topology ENNReal | |
| namespace BoltzmannNonuniqueness.PeriodicApproximation | |
| theorem exists_entropyTruncation_radius (C : ℝ) {ε : ℝ≥0∞} (hε : 0 < ε) : | |
| ∃ j : ℕ, ENNReal.ofReal (C/((j:ℝ)+1)) ≤ ε := by | |
| have h : Tendsto (fun j : ℕ => C/((j:ℝ)+1)) atTop (𝓝 0) := | |
| tendsto_const_nhds.div_atTop (tendsto_natCast_atTop_atTop.atTop_add tendsto_const_nhds) | |
| have ht : Tendsto (fun j : ℕ => ENNReal.ofReal (C/((j:ℝ)+1))) atTop (𝓝 0) := by | |
| simpa only [ENNReal.ofReal_zero] using ENNReal.tendsto_ofReal h | |
| obtain ⟨j,hj⟩ := (ht.eventually (gt_mem_nhds hε)).exists | |
| exact ⟨j,hj.le⟩ | |
| variable {X : Type*} [MeasurableSpace X] | |
| theorem uniformIntegrable_of_entropyGauge {μ : 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 f 1 (μ.prod volume) := by | |
| apply Compactness.uniformIntegrable_of_approximation | |
| (g := fun j n => entropyTruncation ((j:ℝ)+1) (f n)) | |
| (fun j => entropyTruncation_uniformIntegrable ((j:ℝ)+1) hfm hf) | |
| intro ε hε | |
| obtain ⟨j,hj⟩ := exists_entropyTruncation_radius C hε | |
| refine ⟨j,fun n => ?_⟩ | |
| exact (entropyTruncation_L1_bound (by have := Nat.cast_nonneg (α := ℝ) j; linarith) | |
| (hfm n) (hf n) (hi n) (hb n)).trans hj | |
| theorem unifTight_of_entropyGauge {μ : 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) : | |
| UnifTight f 1 (μ.prod volume) := by | |
| intro ε hε | |
| obtain ⟨j,hj⟩ := exists_entropyTruncation_radius C hε | |
| let R : ℝ := (j:ℝ)+1 | |
| let s : Set (X × Velocity) := univ ×ˢ Metric.closedBall 0 R | |
| have hs : MeasurableSet s := MeasurableSet.univ.prod Metric.isClosed_closedBall.measurableSet | |
| refine ⟨s,?_,fun n => ?_⟩ | |
| · rw [Measure.prod_prod] | |
| exact ENNReal.mul_ne_top (measure_ne_top _ _) (isCompact_closedBall (0:Velocity) R).measure_lt_top.ne | |
| · have hdom (p : X × Velocity) : ‖sᶜ.indicator (f n) p‖ ≤ ‖f n p-entropyTruncation R (f n) p‖ := by | |
| by_cases hp : p ∈ s | |
| · rw [indicator_of_notMem (notMem_compl_iff.mpr hp),norm_zero] | |
| exact norm_nonneg _ | |
| · have hv : R < ‖p.2‖ := by | |
| have hnv : p.2 ∉ Metric.closedBall 0 R := fun hv => hp ⟨mem_univ _,hv⟩ | |
| simpa only [Metric.mem_closedBall,dist_zero_right,not_le] using hnv | |
| rw [indicator_of_mem (mem_compl hp),entropyTruncation_support R (f n) p hv,sub_zero] | |
| exact (eLpNorm_mono ((hfm n).indicator hs.compl).aestronglyMeasurable hdom).trans | |
| ((entropyTruncation_L1_bound (by dsimp [R]; have := Nat.cast_nonneg (α := ℝ) j; linarith) | |
| (hfm n) (hf n) (hi n) (hb n)).trans hj) | |
| end BoltzmannNonuniqueness.PeriodicApproximation | |
| end | |
| end | |
| end OAI | |