openAI-math-dataset / lean /OAI /MathematicalPhysics /Boltzmann /Compactness /EntropyDissipationAverage.lean
| import OAI.MathematicalPhysics.Boltzmann.Admissibility | |
| import OAI.MathematicalPhysics.Boltzmann.Approximation.RegularizedCollisionDifference | |
| import OAI.MathematicalPhysics.Boltzmann.Collision.CollisionSources | |
| import OAI.MathematicalPhysics.Boltzmann.Collision.ScalarEntropyConvex | |
| import OAI.MathematicalPhysics.Boltzmann.Collision.VelocityCutoffEntropyError | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.FiniteDepthKernelOrder | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.NormalizedKernelAction | |
| import Mathlib.Analysis.SpecialFunctions.Log.NegMulLog | |
| import Mathlib.MeasureTheory.Integral.Lebesgue.Add | |
| namespace OAI | |
| section | |
| /-! # The integrable entropy error caused by positive regularization -/ | |
| noncomputable section | |
| open MeasureTheory | |
| open BoltzmannNonuniqueness.VelocityWeight | |
| namespace BoltzmannNonuniqueness | |
| def entropyErrorCoefficient (q A b : ℝ) : ℝ := | |
| tiltConstant*(2*A+tiltConstant)* | |
| (HotApplication.realBound q+CutoffLipschitz.frequencyConstant q b) | |
| theorem entropyErrorCoefficient_nonneg {A b : ℝ} (hA : 0 ≤ A) (hb : 0 ≤ b) (q : ℝ) : | |
| 0 ≤ entropyErrorCoefficient q A b := by | |
| unfold entropyErrorCoefficient | |
| exact mul_nonneg (mul_nonneg tiltConstant_pos.le (by linarith [tiltConstant_pos])) | |
| (add_nonneg (HotApplication.realBound_pos q).le (CutoffLipschitz.frequencyConstant_nonneg hb q)) | |
| theorem cutoffCollision_measurable {f : Velocity → ℝ} (hfm : Measurable f) (b : ℝ) : | |
| Measurable (CutoffLipschitz.collision b f) := by | |
| let F : Unit × Velocity → ℝ := fun z => f z.2 | |
| have hF : Measurable F := hfm.comp measurable_snd | |
| have hg := KineticCollisionNullSets.measurable_gain hF b | |
| have hν := KineticCollisionNullSets.measurable_frequency hF b | |
| have hs := (hg.sub (hF.mul hν)).comp | |
| (measurable_const.prodMk measurable_id : Measurable (fun v : Velocity => ((),v))) | |
| convert hs using 1 | |
| funext v | |
| rfl | |
| theorem entropy_regularization_error (hcarleman : Published.GPV2009CarlemanInput) | |
| {δ A q b p : ℝ} (hδ : 0 < δ) (hδone : δ ≤ 1) (hA : 0 ≤ A) | |
| (hq₁ : 1 < q) (hq₂ : q < 2) (hb : 0 ≤ b) (hp : 1 < p) | |
| (hpi : Integrable (fun v : Velocity => H q v^p)) | |
| {f : Velocity → ℝ} (hfm : Measurable f) (hfn : ∀ v, 0 ≤ f v) | |
| (hfb : ∀ v, f v ≤ A*H q v) : | |
| Integrable (fun v => Real.log (gaussianRegularization δ f v/maxwellian v)* | |
| (CutoffLipschitz.collision b (gaussianRegularization δ f) v-CutoffLipschitz.collision b f v)) ∧ | |
| |∫ v, Real.log (gaussianRegularization δ f v/maxwellian v)* | |
| (CutoffLipschitz.collision b (gaussianRegularization δ f) v-CutoffLipschitz.collision b f v)| ≤ | |
| δ*entropyErrorCoefficient q A b*∫ v, logarithmicMajorant q (A+tiltConstant) p δ v := by | |
| let L := fun v => Real.log (gaussianRegularization δ f v/maxwellian v) | |
| let Q := fun v => CutoffLipschitz.collision b (gaussianRegularization δ f) v- | |
| CutoffLipschitz.collision b f v | |
| have hgm := gaussianRegularization_measurable δ hfm | |
| have hmm : Measurable maxwellian := by unfold maxwellian; fun_prop | |
| have hLm : Measurable L := (hgm.div hmm).log | |
| have hQm : Measurable Q := (cutoffCollision_measurable hgm b).sub (cutoffCollision_measurable hfm b) | |
| have hC := entropyErrorCoefficient_nonneg hA hb q | |
| have hδC : 0 ≤ δ*entropyErrorCoefficient q A b := mul_nonneg hδ.le hC | |
| have hmajor := (logarithmicMajorant_integrable (B := A+tiltConstant) (δ := δ) hq₂ hpi).const_mul | |
| (δ*entropyErrorCoefficient q A b) | |
| have hbound : ∀ᵐ v : Velocity, ‖L v*Q v‖ ≤ | |
| δ*entropyErrorCoefficient q A b*logarithmicMajorant q (A+tiltConstant) p δ v := by | |
| filter_upwards [gaussianRegularization_collision_error hcarleman hδ.le hδone hA hq₁ hq₂ hb hfm hfn hfb] | |
| with v hv | |
| have hl : |L v| * H q v ≤ logarithmicMajorant q (A+tiltConstant) p δ v := | |
| logarithm_weight_bound (add_nonneg hA tiltConstant_pos.le) hp hδ v | |
| (by dsimp [gaussianRegularization]; linarith [hfn v]) | |
| (gaussianRegularization_bound hδ.le hδone hfb v) | |
| rw [Real.norm_eq_abs,abs_mul] | |
| calc | |
| _ ≤ |L v| * (δ*entropyErrorCoefficient q A b*H q v) := | |
| mul_le_mul_of_nonneg_left hv (abs_nonneg _) | |
| _ = (δ*entropyErrorCoefficient q A b)*(|L v| * H q v) := by ring | |
| _ ≤ _ := mul_le_mul_of_nonneg_left hl hδC | |
| refine ⟨hmajor.mono' (hLm.mul hQm).aestronglyMeasurable hbound,?_⟩ | |
| have h := norm_integral_le_of_norm_le hmajor hbound | |
| simpa only [Real.norm_eq_abs,integral_const_mul] using h | |
| end BoltzmannNonuniqueness | |
| end | |
| end | |
| section | |
| /-! # Finite Gaussian relative entropy controls the required datum class -/ | |
| noncomputable section | |
| open MeasureTheory | |
| namespace BoltzmannNonuniqueness | |
| def entropyGaussian (v : Velocity) : ℝ := | |
| maxwellian v * Real.exp ((1+‖v‖^2)/4) | |
| theorem entropyGaussian_integrable : Integrable entropyGaussian := by | |
| have h := (GaussianFourier.integrable_cexp_neg_mul_sq_norm_add | |
| (by norm_num : 0 < ((1/4:ℂ)).re) 0 (0:Velocity)).norm | |
| have hg : Integrable (fun v : Velocity => Real.exp (-‖v‖^2/4)) := by | |
| convert! h using 1 | |
| funext v | |
| simp only [zero_mul,add_zero,Complex.norm_exp] | |
| congr 1 | |
| norm_num | |
| norm_cast | |
| ring | |
| convert hg.const_mul ((2*Real.pi)^(-(3/2:ℝ))*Real.exp (1/4)) using 1 | |
| funext v | |
| dsimp [entropyGaussian,maxwellian] | |
| simp only [mul_assoc,← Real.exp_add] | |
| congr 2 | |
| ring | |
| theorem entropy_controls_mass_energy {u : ℝ} (hu : 0 ≤ u) (v : Velocity) : | |
| (1+‖v‖^2)*u ≤ 4*(scalarRelativeEntropy (maxwellian v) u+entropyGaussian v) := by | |
| have h := entropyDual_le (maxwellian_pos v) hu ((1+‖v‖^2)/4) | |
| dsimp [entropyDual,entropyGaussian] at * | |
| nlinarith [maxwellian_pos v] | |
| theorem finiteEntropy_of_relativeEntropy_integrable {f : Density} | |
| (hfm : Measurable f) (hfn : ∀ z, 0 ≤ f z) | |
| (hH : Integrable (fun z => scalarRelativeEntropy (maxwellian z.2) (f z))) : | |
| FiniteEntropyDatum f := by | |
| have hmajor : Integrable (fun z : Phase => | |
| 4*(scalarRelativeEntropy (maxwellian z.2) (f z)+entropyGaussian z.2)) := | |
| (hH.add (entropyGaussian_integrable.comp_snd volume)).const_mul 4 | |
| have hweight : Integrable (fun z : Phase => (1+‖z.2‖^2)*f z) := by | |
| apply hmajor.mono' ((measurable_const.add (measurable_snd.norm.pow_const 2)).mul hfm).aestronglyMeasurable | |
| filter_upwards [] with z | |
| change ‖(1+‖z.2‖^2)*f z‖ ≤ _ | |
| rw [Real.norm_of_nonneg (mul_nonneg (by positivity) (hfn z))] | |
| exact entropy_controls_mass_energy (hfn z) z.2 | |
| have hfi : Integrable f := by | |
| apply hweight.mono' hfm.aestronglyMeasurable | |
| filter_upwards [] with z | |
| rw [Real.norm_of_nonneg (hfn z)] | |
| nlinarith [sq_nonneg ‖z.2‖,hfn z] | |
| have hEi : Integrable (fun z : Phase => ‖z.2‖^2*f z) := by | |
| apply hweight.mono' ((measurable_snd.norm.pow_const 2).mul hfm).aestronglyMeasurable | |
| filter_upwards [] with z | |
| change ‖‖z.2‖^2*f z‖ ≤ _ | |
| rw [Real.norm_of_nonneg (mul_nonneg (sq_nonneg _) (hfn z))] | |
| nlinarith [hfn z] | |
| exact FiniteEntropyDatum.of_relativeEntropy_integrable (Filter.Eventually.of_forall hfn) hfi hEi hH | |
| end BoltzmannNonuniqueness | |
| end | |
| end | |
| section | |
| /-! # The regularization error vanishes as the Gaussian is removed -/ | |
| noncomputable section | |
| open MeasureTheory Filter | |
| open scoped Topology | |
| open BoltzmannNonuniqueness.VelocityWeight | |
| namespace BoltzmannNonuniqueness | |
| theorem tendsto_mul_abs_log_zero : | |
| Tendsto (fun δ : ℝ => δ*|Real.log δ|) (𝓝 0) (𝓝 0) := by | |
| rw [tendsto_zero_iff_norm_tendsto_zero] | |
| have h : Tendsto (fun δ : ℝ => |δ*Real.log δ|) (𝓝 0) (𝓝 0) := by | |
| simpa using Real.continuous_mul_log.abs.tendsto 0 | |
| simpa only [norm_mul,Real.norm_eq_abs,abs_abs,abs_mul] using h | |
| theorem tendsto_mul_affine_abs_log_zero (a b : ℝ) : | |
| Tendsto (fun δ : ℝ => δ*(a+b*|Real.log δ|)) (𝓝 0) (𝓝 0) := by | |
| have h := ((tendsto_id : Tendsto (fun δ : ℝ => δ) (𝓝 0) (𝓝 0)).mul_const a).add | |
| (tendsto_mul_abs_log_zero.mul_const b) | |
| convert h using 1 | |
| · funext δ | |
| simp only [id_eq] | |
| ring | |
| · ring_nf | |
| theorem integral_logarithmicMajorant {q B p δ : ℝ} (hq : q < 2) | |
| (hp : Integrable (fun v : Velocity => H q v^p)) : | |
| (∫ v, logarithmicMajorant q B p δ v) = | |
| (B^(p-1)/(p-1))*(∫ v, H q v^p)+ | |
| (|Real.log δ|+|-(3/2:ℝ)*Real.log (2*Real.pi)|)*(∫ v, H q v)+ | |
| (5/2:ℝ)*(∫ v, ‖v‖^2*H q v) := by | |
| have hH := (integrable_H hq).const_mul (|Real.log δ|+|-(3/2:ℝ)*Real.log (2*Real.pi)|) | |
| have hE : Integrable (fun v : Velocity => (5/2:ℝ)*(‖v‖^2*H q v)) := by | |
| simpa only [Nat.reduceMul] using (integrable_even_moment_H hq 1).const_mul (5/2:ℝ) | |
| have he : logarithmicMajorant q B p δ = | |
| (fun v => (B^(p-1)/(p-1))*H q v^p)+ | |
| (fun v => (|Real.log δ|+|-(3/2:ℝ)*Real.log (2*Real.pi)|)*H q v)+ | |
| (fun v => (5/2:ℝ)*(‖v‖^2*H q v)) := by | |
| funext v | |
| dsimp [logarithmicMajorant] | |
| ring | |
| rw [he,integral_add' ((hp.const_mul _).add hH) hE,integral_add' (hp.const_mul _) hH] | |
| simp only [integral_const_mul] | |
| theorem tendsto_integrated_entropy_error {q B p : ℝ} (C : ℝ) (hq : q < 2) | |
| (hp : Integrable (fun v : Velocity => H q v^p)) : | |
| Tendsto (fun δ : ℝ => δ*C*(∫ v, logarithmicMajorant q B p δ v)) (𝓝 0) (𝓝 0) := by | |
| have h := (tendsto_mul_affine_abs_log_zero | |
| ((B^(p-1)/(p-1))*(∫ v, H q v^p)+ | |
| |-(3/2:ℝ)*Real.log (2*Real.pi)| *(∫ v, H q v)+ | |
| (5/2:ℝ)*(∫ v, ‖v‖^2*H q v)) (∫ v, H q v)).mul_const C | |
| convert h using 1 | |
| · funext δ | |
| rw [integral_logarithmicMajorant hq hp] | |
| ring | |
| · ring_nf | |
| end BoltzmannNonuniqueness | |
| end | |
| end | |
| section | |
| /-! # Passing an entropy-dissipation inequality through a vanishing error -/ | |
| noncomputable section | |
| open Filter | |
| open scoped ENNReal Topology | |
| namespace BoltzmannNonuniqueness | |
| theorem entropy_dissipation_of_vanishing_error {ι : Type*} {l : Filter ι} [NeBot l] | |
| {H H₀ error D : ι → ℝ} {h h₀ : ℝ} {d : ℝ≥0∞} | |
| (hh : Tendsto H l (𝓝 h)) (hh₀ : Tendsto H₀ l (𝓝 h₀)) | |
| (herr : Tendsto error l (𝓝 0)) (hn : 0 ≤ h) | |
| (hDn : ∀ᶠ i in l, 0 ≤ D i) | |
| (hineq : ∀ᶠ i in l, H i-H₀ i+D i ≤ error i) | |
| (hfatou : d ≤ liminf (fun i => ENNReal.ofReal (D i)) l) : | |
| ENNReal.ofReal h+d ≤ ENNReal.ofReal h₀ := by | |
| have hHle : h ≤ h₀ := by | |
| have hlim : Tendsto (fun i => H₀ i+error i) l (𝓝 h₀) := by | |
| simpa only [add_zero] using hh₀.add herr | |
| apply le_of_tendsto_of_tendsto hh hlim | |
| filter_upwards [hDn,hineq] with i hi he | |
| linarith | |
| have hlim : Tendsto (fun i => H₀ i+error i-H i) l (𝓝 (h₀-h)) := by | |
| simpa only [add_zero] using (hh₀.add herr).sub hh | |
| have hmono : liminf (fun i => ENNReal.ofReal (D i)) l ≤ | |
| liminf (fun i => ENNReal.ofReal (H₀ i+error i-H i)) l := by | |
| exact liminf_le_liminf (hineq.mono (fun i hi => ENNReal.ofReal_le_ofReal (by linarith))) | |
| rw [(ENNReal.tendsto_ofReal hlim).liminf_eq] at hmono | |
| calc | |
| _ ≤ ENNReal.ofReal h+ENNReal.ofReal (h₀-h) := add_le_add le_rfl (hfatou.trans hmono) | |
| _ = ENNReal.ofReal (h+(h₀-h)) := (ENNReal.ofReal_add hn (sub_nonneg.mpr hHle)).symm | |
| _ = _ := by congr 1; ring | |
| end BoltzmannNonuniqueness | |
| end | |
| end | |
| section | |
| /-! # Uniform integrability of the actual mass marginal from entropy -/ | |
| noncomputable section | |
| open MeasureTheory | |
| open scoped ENNReal | |
| namespace BoltzmannNonuniqueness.PeriodicApproximation | |
| variable {X : Type*} [MeasurableSpace X] {μ : Measure X} [IsFiniteMeasure μ] | |
| theorem mass_marginal_uniformIntegrable {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 => Compactness.fiberMass volume (f n)) 1 μ := by | |
| have hui := linearMoment_marginal_uniformIntegrable hfm hf hi hb | |
| have hbound n : ∀ᵐ x ∂μ, ‖Compactness.fiberMass volume (f n) x‖ₑ ≤ | |
| ‖∫ v, linearMoment (f n) (x,v)‖ₑ := by | |
| filter_upwards [(linearMoment_integrable (hfm n) (hf n) (hi n)).prod_right_ae] with x hx | |
| apply enorm_le_iff_norm_le.mpr | |
| dsimp only [Compactness.fiberMass] | |
| have hln (v : Velocity) : 0 ≤ linearMoment (f n) (x,v) := | |
| mul_nonneg (by dsimp only [Prod.snd]; positivity) (hf n (x,v)) | |
| have hL0 : 0 ≤ ∫ v, linearMoment (f n) (x,v) := integral_nonneg hln | |
| rw [Real.norm_of_nonneg (integral_nonneg (fun v => hf n (x,v))),Real.norm_of_nonneg hL0] | |
| apply integral_mono_of_nonneg (ae_of_all _ (fun v => hf n (x,v))) hx | |
| filter_upwards [] with v | |
| change f n (x,v) ≤ (1+‖v‖)*f n (x,v) | |
| nlinarith [norm_nonneg v,hf n (x,v)] | |
| obtain ⟨hu,D,hD⟩ := hui | |
| have hm n := (Compactness.fiberMass_measurable (ν := volume) (hfm n)).aestronglyMeasurable (μ := μ) | |
| exact ⟨hu.ae_mono hm hbound,D,fun n => (eLpNorm_mono_enorm_ae (hm n) (hbound n)).trans (hD n)⟩ | |
| end BoltzmannNonuniqueness.PeriodicApproximation | |
| end | |
| end | |
| section | |
| /-! # A uniform absolute-entropy moment from the relative-entropy bound -/ | |
| noncomputable section | |
| open MeasureTheory | |
| namespace BoltzmannNonuniqueness | |
| def entropyMomentCoefficient : ℝ := | |
| 2+3*|1-(3/2:ℝ)*Real.log (2*Real.pi)| | |
| theorem entropyMomentCoefficient_nonneg : 0 ≤ entropyMomentCoefficient := by | |
| unfold entropyMomentCoefficient | |
| positivity | |
| theorem entropyMoment_control {f : Density} {z : Phase} (hu : 0 ≤ f z) : | |
| entropyMoment f z ≤ | |
| (1+4*entropyMomentCoefficient)*scalarRelativeEntropy (maxwellian z.2) (f z)+ | |
| 4*entropyMomentCoefficient*entropyGaussian z.2+maxwellian z.2 := by | |
| let u := f z | |
| let c := 1-(3/2:ℝ)*Real.log (2*Real.pi) | |
| have hu' : 0 ≤ u := hu | |
| have hE : 0 ≤ ‖z.2‖^2*u := mul_nonneg (sq_nonneg _) hu' | |
| have hm := (maxwellian_pos z.2).le | |
| have hc : c*u ≤ |c| *u := mul_le_mul_of_nonneg_right (le_abs_self c) hu' | |
| have hc' : -(|c| *u) ≤ c*u := by | |
| simpa only [neg_mul] using mul_le_mul_of_nonneg_right (neg_abs_le c) hu' | |
| have hcu : 0 ≤ |c| *u := mul_nonneg (abs_nonneg c) hu' | |
| have hH := scalarRelativeEntropy_nonneg (maxwellian_pos z.2) hu' | |
| have he : scalarRelativeEntropy (maxwellian z.2) u = | |
| u*Real.log u-c*u+(1/2:ℝ)*(‖z.2‖^2*u)+maxwellian z.2 := by | |
| dsimp [scalarRelativeEntropy,c] | |
| rw [log_maxwellian] | |
| ring | |
| have ha : |u*Real.log u| ≤ u*Real.log u+2*(|c| *u+(1/2:ℝ)*(‖z.2‖^2*u)+maxwellian z.2) := by | |
| apply abs_le.mpr | |
| constructor <;> nlinarith | |
| have hpre : entropyMoment f z ≤ scalarRelativeEntropy (maxwellian z.2) u+ | |
| entropyMomentCoefficient*((1+‖z.2‖^2)*u)+maxwellian z.2 := by | |
| have habs : u*|Real.log u| = |u*Real.log u| := by rw [abs_mul,abs_of_nonneg hu'] | |
| change u*(1+‖z.2‖^2+|Real.log u|) ≤ _ | |
| rw [mul_add,habs] | |
| change _ ≤ scalarRelativeEntropy (maxwellian z.2) u+(2+3*|c|)*((1+‖z.2‖^2)*u)+maxwellian z.2 | |
| have hEc : 0 ≤ |c| *(‖z.2‖^2*u) := mul_nonneg (abs_nonneg c) hE | |
| nlinarith | |
| have hb := mul_le_mul_of_nonneg_left (entropy_controls_mass_energy hu' z.2) | |
| entropyMomentCoefficient_nonneg | |
| exact hpre.trans (by nlinarith) | |
| theorem entropyMoment_integral_control {f : Density} (hf : FiniteEntropyDatum f) : | |
| (∫ z, entropyMoment f z) ≤ | |
| (1+4*entropyMomentCoefficient)*relativeEntropy f+ | |
| 4*entropyMomentCoefficient*(∫ z : Phase, entropyGaussian z.2)+ | |
| (∫ z : Phase, maxwellian z.2) := by | |
| have hH := hf.integrable_relativeEntropy.congr (Filter.Eventually.of_forall (fun z => | |
| (scalarRelativeEntropy_eq (maxwellian_pos z.2) _).symm)) | |
| have hG : Integrable (fun z : Phase => entropyGaussian z.2) := | |
| entropyGaussian_integrable.comp_snd volume | |
| have hi := ((hH.const_mul (1+4*entropyMomentCoefficient)).add | |
| (hG.const_mul (4*entropyMomentCoefficient))).add integrable_maxwellian_phase | |
| have hb := integral_mono_ae hf.2.2 hi (hf.1.mono (fun _ hu => entropyMoment_control hu)) | |
| simp only [Pi.add_apply] at hb | |
| have hsum := integral_add ((hH.const_mul (1+4*entropyMomentCoefficient)).add | |
| (hG.const_mul (4*entropyMomentCoefficient))) integrable_maxwellian_phase | |
| have hsum' := integral_add (hH.const_mul (1+4*entropyMomentCoefficient)) | |
| (hG.const_mul (4*entropyMomentCoefficient)) | |
| simp only [Pi.add_apply] at hsum hsum' | |
| rw [hsum,hsum',integral_const_mul,integral_const_mul] at hb | |
| have he : (∫ z, scalarRelativeEntropy (maxwellian z.2) (f z)) = relativeEntropy f := | |
| integral_congr_ae (Filter.Eventually.of_forall (fun z => scalarRelativeEntropy_eq (maxwellian_pos z.2) _)) | |
| rwa [he] at hb | |
| end BoltzmannNonuniqueness | |
| end | |
| end | |
| section | |
| /-! # Passing the sum of nonnegative entropy and dissipation to a subsequential limit -/ | |
| noncomputable section | |
| open Filter | |
| open scoped ENNReal Topology | |
| namespace BoltzmannNonuniqueness | |
| theorem ennreal_liminf_add_nat (u v : ℕ → ℝ≥0∞) : | |
| liminf u atTop+liminf v atTop ≤ liminf (fun n => u n+v n) atTop := by | |
| simp_rw [liminf_eq_iSup_iInf_of_nat] | |
| apply ENNReal.iSup_add_iSup_le | |
| intro N M | |
| apply le_iSup_of_le (max N M) | |
| apply le_iInf₂ | |
| intro k hk | |
| exact add_le_add (iInf₂_le k ((le_max_left N M).trans hk)) | |
| (iInf₂_le k ((le_max_right N M).trans hk)) | |
| theorem entropy_dissipation_of_liminfs {H D : ℕ → ℝ≥0∞} {C : ℕ → ℝ} | |
| {h d : ℝ≥0∞} {c : ℝ} | |
| (hh : h ≤ liminf H atTop) (hd : d ≤ liminf D atTop) | |
| (hC : Tendsto C atTop (𝓝 c)) | |
| (hupper : ∀ᶠ n in atTop, H n+D n ≤ ENNReal.ofReal (C n)) : | |
| h+d ≤ ENNReal.ofReal c := by | |
| have hm := liminf_le_liminf hupper | |
| rw [(ENNReal.tendsto_ofReal hC).liminf_eq] at hm | |
| exact (add_le_add hh hd).trans ((ennreal_liminf_add_nat H D).trans hm) | |
| end BoltzmannNonuniqueness | |
| end | |
| end | |
| section | |
| /-! # Retaining a common entropy and dissipation budget under time averaging -/ | |
| noncomputable section | |
| open MeasureTheory Filter | |
| open scoped ENNReal Topology | |
| namespace BoltzmannNonuniqueness | |
| variable {X : Type*} [MeasurableSpace X] {μ : Measure X} [IsFiniteMeasure μ] | |
| theorem entropy_dissipation_average_limit {H : ℕ → X → ℝ≥0∞} {h : X → ℝ≥0∞} | |
| {D C : ℕ → ℝ≥0∞} {d c : ℝ≥0∞} | |
| (hHm : ∀ n, Measurable (H n)) | |
| (hh : (∫⁻ x, h x ∂μ) ≤ liminf (fun n => ∫⁻ x, H n x ∂μ) atTop) | |
| (hd : d ≤ liminf D atTop) (hC : Tendsto C atTop (𝓝 c)) | |
| (hu : ∀ᶠ n in atTop, ∀ᵐ x ∂μ, H n x+D n ≤ C n) : | |
| (∫⁻ x, h x ∂μ)+μ Set.univ*d ≤ μ Set.univ*c := by | |
| have hm := ENNReal.le_liminf_mul (u := fun _ : ℕ => μ Set.univ) (v := D) (f := atTop) | |
| have hd' : μ Set.univ*d ≤ liminf (fun n => μ Set.univ*D n) atTop := by | |
| apply (mul_le_mul' le_rfl hd).trans | |
| simpa only [liminf_const,Pi.mul_def] using hm | |
| have hu' : ∀ᶠ n in atTop, (∫⁻ x, H n x ∂μ)+μ Set.univ*D n ≤ μ Set.univ*C n := by | |
| filter_upwards [hu] with n hn | |
| have h := lintegral_mono_ae hn | |
| rw [lintegral_add_left (hHm n),lintegral_const,lintegral_const] at h | |
| simpa only [mul_comm] using h | |
| have hlim : Tendsto (fun n => μ Set.univ*C n) atTop (𝓝 (μ Set.univ*c)) := | |
| ENNReal.Tendsto.const_mul hC (Or.inr (measure_ne_top μ Set.univ)) | |
| apply (add_le_add hh hd').trans | |
| apply (ennreal_liminf_add_nat _ _).trans | |
| have hb := liminf_le_liminf hu' | |
| rwa [hlim.liminf_eq] at hb | |
| end BoltzmannNonuniqueness | |
| end | |
| end | |
| end OAI | |