| import OAI.MathematicalPhysics.Boltzmann.Approximation.CutoffLossFrequency |
| import OAI.MathematicalPhysics.Boltzmann.Branching.MixedPhysicalMeasures |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.PairBoundedTruncation |
|
|
| namespace OAI |
|
|
| section |
|
|
| /-! # Uniform integrability of the actual cutoff equation's right-hand side -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory |
| open scoped ENNReal |
|
|
| namespace BoltzmannNonuniqueness.CollisionCompactness |
|
|
| variable {X : Type*} [MeasurableSpace X] {μ : Measure X} |
|
|
| def collisionSource (b : ℝ) (f : X × Velocity → ℝ) (p : X × Velocity) : ℝ := |
| KineticCollisionNullSets.gain b f p-f p*KineticCollisionNullSets.frequency b f p |
|
|
| theorem collisionSource_measurable {f : X × Velocity → ℝ} (hf : Measurable f) (b : ℝ) : |
| Measurable (collisionSource b f) := |
| (KineticCollisionNullSets.measurable_gain hf b).sub |
| (hf.mul (KineticCollisionNullSets.measurable_frequency hf b)) |
|
|
| private theorem uniformIntegrable_sub {Y : Type*} [MeasurableSpace Y] {ν : Measure Y} |
| {f g : ℕ → Y → ℝ} (hf : UniformIntegrable f 1 ν) (hg : UniformIntegrable g 1 ν) : |
| UniformIntegrable (fun n y => f n y-g n y) 1 ν := by |
| obtain ⟨hu,C,hC⟩ := hf |
| obtain ⟨hv,D,hD⟩ := hg |
| refine ⟨hu.sub hv (by norm_num),C+D,fun n => ?_⟩ |
| exact (eLpNorm_sub_le (by norm_num : (1 : ℝ≥0∞) ≤ 1)).trans |
| (by simpa only [ENNReal.coe_add] using add_le_add (hC n) (hD n)) |
|
|
| theorem collisionSource_uniformIntegrable [SFinite μ] |
| {f : ℕ → X × Velocity → ℝ} (hfm : ∀ n, Measurable (f n)) (hf : ∀ n z, 0 ≤ f n z) |
| (hpair : UniformIntegrable (fun n => pairDensity (f n)) 1 |
| (μ.prod (volume : Measure (Velocity × Velocity)))) (b : ℕ → ℝ) |
| (hgain : UniformIntegrable (fun n => KineticCollisionNullSets.gain (b n) (f n)) 1 |
| (μ.prod (volume : Measure Velocity))) |
| (hloss : UniformIntegrable (fun n => cutoffLossDensity (b n) (f n)) 1 |
| (μ.prod (volume : Measure Velocity))) : |
| UniformIntegrable (fun n => collisionSource (b n) (f n)) 1 |
| (μ.prod (volume : Measure Velocity)) := by |
| have he (n) := cutoff_loss_ae_eq_frequency (hfm n) (hf n) |
| (memLp_one_iff_integrable.mp (hpair.memLp n)) (b n) |
| exact uniformIntegrable_sub hgain (hloss.ae_eq he) |
|
|
| end BoltzmannNonuniqueness.CollisionCompactness |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| /-! # Discarding the nonnegative losses in the actual hot source -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory |
|
|
| namespace BoltzmannNonuniqueness.CollisionCompactness |
|
|
| variable {X : Type*} |
|
|
| theorem cutoffFrequency_nonneg (b : ℝ) {f : X × Velocity → ℝ} |
| (hf : ∀ p, 0 ≤ f p) (p : X × Velocity) : |
| 0 ≤ KineticCollisionNullSets.frequency b f p := by |
| apply mul_nonneg (by positivity : (0:ℝ) ≤ 2*Real.pi) |
| exact integral_nonneg (fun w => mul_nonneg (CollisionCutoff.rate_nonneg b p.2 w) (hf _)) |
|
|
| theorem collisionSource_le_gain (b : ℝ) {f : X × Velocity → ℝ} |
| (hf : ∀ p, 0 ≤ f p) (p : X × Velocity) : |
| collisionSource b f p ≤ KineticCollisionNullSets.gain b f p := |
| sub_le_self _ (mul_nonneg (hf _) (cutoffFrequency_nonneg b hf p)) |
|
|
| variable [MeasurableSpace X] |
|
|
| theorem hot_source_le_gain (b r e : ℝ) {c h : X × Velocity → ℝ} |
| (hc : ∀ p, 0 ≤ c p) (hh : ∀ p, 0 ≤ h p) (p : X × Velocity) : |
| 2*mixedGainDensity b c h p-h p*KineticCollisionNullSets.frequency b c p+ |
| r^2*collisionSource b h p+e ≤ |
| 2*mixedGainDensity b c h p+r^2*KineticCollisionNullSets.gain b h p+e := by |
| exact add_le_add (add_le_add (sub_le_self _ (mul_nonneg (hh _) (cutoffFrequency_nonneg b hc p))) |
| (mul_le_mul_of_nonneg_left (collisionSource_le_gain b hh p) (sq_nonneg r))) le_rfl |
|
|
| end BoltzmannNonuniqueness.CollisionCompactness |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| /-! # Scaling and base-coordinate identities for physical cutoff collisions -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory |
|
|
| namespace BoltzmannNonuniqueness.CollisionCompactness |
|
|
| variable {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y] |
|
|
| omit [MeasurableSpace X] in |
| theorem mixedPostRate_const_mul (b a d : ℝ) (c h : X × Velocity → ℝ) |
| (z : (X × (Velocity × Velocity)) × Sphere) : |
| mixedPostRate b (fun p => a*c p) (fun p => d*h p) z = |
| (a*d)*mixedPostRate b c h z := by |
| unfold mixedPostRate mixedPreRate |
| ring |
|
|
| theorem mixedGain_const_mul (b a d : ℝ) (c h : X × Velocity → ℝ) (p : X × Velocity) : |
| mixedGainDensity b (fun p => a*c p) (fun p => d*h p) p = |
| (a*d)*mixedGainDensity b c h p := by |
| unfold mixedGainDensity |
| simp_rw [mixedPostRate_const_mul] |
| rw [integral_const_mul,integral_const_mul] |
| ring |
|
|
| theorem cutoffGain_const_mul (b a : ℝ) (f : X × Velocity → ℝ) (p : X × Velocity) : |
| KineticCollisionNullSets.gain b (fun p => a*f p) p = |
| a^2*KineticCollisionNullSets.gain b f p := by |
| rw [← mixedGainDensity_self, mixedGain_const_mul, mixedGainDensity_self] |
| ring |
|
|
| omit [MeasurableSpace X] in |
| theorem cutoffFrequency_const_mul (b a : ℝ) (f : X × Velocity → ℝ) (p : X × Velocity) : |
| KineticCollisionNullSets.frequency b (fun p => a*f p) p = |
| a*KineticCollisionNullSets.frequency b f p := by |
| unfold KineticCollisionNullSets.frequency CollisionCutoff.frequency |
| simp_rw [show ∀ w, CollisionCutoff.rate b p.2 w*(a*f (p.1,w)) = |
| a*(CollisionCutoff.rate b p.2 w*f (p.1,w)) by intro w; ring] |
| rw [integral_const_mul] |
| ring |
|
|
| omit [MeasurableSpace X] in |
| theorem cutoffFrequency_add (b : ℝ) (c h : X × Velocity → ℝ) (p : X × Velocity) |
| (hc : Integrable (fun w => CollisionCutoff.rate b p.2 w*c (p.1,w))) |
| (hh : Integrable (fun w => CollisionCutoff.rate b p.2 w*h (p.1,w))) : |
| KineticCollisionNullSets.frequency b (c+h) p = |
| KineticCollisionNullSets.frequency b c p+KineticCollisionNullSets.frequency b h p := by |
| unfold KineticCollisionNullSets.frequency CollisionCutoff.frequency |
| simp only [Pi.add_apply,mul_add] |
| have he := integral_add hc hh |
| rw [he] |
| ring |
|
|
| omit [MeasurableSpace X] [MeasurableSpace Y] in |
| theorem mixedPostRate_base_comp (b : ℝ) (c h : X × Velocity → ℝ) (τ : Y → X) |
| (z : (Y × (Velocity × Velocity)) × Sphere) : |
| mixedPostRate b (fun p => c (τ p.1,p.2)) (fun p => h (τ p.1,p.2)) z = |
| mixedPostRate b c h ((τ z.1.1,z.1.2),z.2) := rfl |
|
|
| theorem mixedGain_base_comp (b : ℝ) (c h : X × Velocity → ℝ) (τ : Y → X) |
| (p : Y × Velocity) : |
| mixedGainDensity b (fun p => c (τ p.1,p.2)) (fun p => h (τ p.1,p.2)) p = |
| mixedGainDensity b c h (τ p.1,p.2) := rfl |
|
|
| omit [MeasurableSpace X] [MeasurableSpace Y] in |
| theorem cutoffGain_base_comp (b : ℝ) (f : X × Velocity → ℝ) (τ : Y → X) |
| (p : Y × Velocity) : |
| KineticCollisionNullSets.gain b (fun p => f (τ p.1,p.2)) p = |
| KineticCollisionNullSets.gain b f (τ p.1,p.2) := rfl |
|
|
| omit [MeasurableSpace X] [MeasurableSpace Y] in |
| theorem cutoffFrequency_base_comp (b : ℝ) (f : X × Velocity → ℝ) (τ : Y → X) |
| (p : Y × Velocity) : |
| KineticCollisionNullSets.frequency b (fun p => f (τ p.1,p.2)) p = |
| KineticCollisionNullSets.frequency b f (τ p.1,p.2) := rfl |
|
|
| end BoltzmannNonuniqueness.CollisionCompactness |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| /-! # L1 contraction for marginalizing a collision rate -/ |
| noncomputable section |
| open MeasureTheory |
| open scoped ENNReal |
| namespace BoltzmannNonuniqueness.CollisionCompactness |
| variable {X : Type*} [MeasurableSpace X] {μ : Measure X} [SFinite μ] |
| local instance : SFinite ((volume : Measure Velocity).prod sphereArea) := Measure.prod.instSFinite |
|
|
| def collisionMarginal (h : (X × (Velocity × Velocity)) × Sphere → ℝ) |
| (p : X × Velocity) : ℝ := |
| ∫ q : Velocity × Sphere, h (collisionGrouping.symm (p,q)) |
| ∂(volume : Measure Velocity).prod sphereArea |
|
|
| theorem collisionMarginal_integrable {h : (X × (Velocity × Velocity)) × Sphere → ℝ} |
| (hi : Integrable h ((μ.prod (volume : Measure (Velocity × Velocity))).prod sphereArea)) : |
| Integrable (collisionMarginal h) (μ.prod volume) := |
| ((collisionGrouping_measurePreserving μ).symm.integrable_comp_of_integrable hi).integral_prod_left |
|
|
| theorem collisionMarginal_sub_ae {h k : (X × (Velocity × Velocity)) × Sphere → ℝ} |
| (hi : Integrable h ((μ.prod (volume : Measure (Velocity × Velocity))).prod sphereArea)) |
| (ki : Integrable k ((μ.prod (volume : Measure (Velocity × Velocity))).prod sphereArea)) : |
| collisionMarginal (h-k) =ᵐ[μ.prod volume] collisionMarginal h-collisionMarginal k := by |
| have hhi := (collisionGrouping_measurePreserving μ).symm.integrable_comp_of_integrable hi |
| have hki := (collisionGrouping_measurePreserving μ).symm.integrable_comp_of_integrable ki |
| filter_upwards [hhi.prod_right_ae,hki.prod_right_ae] with p hp kp |
| exact integral_sub hp kp |
|
|
| theorem collisionMarginal_eLpNorm_le {h : (X × (Velocity × Velocity)) × Sphere → ℝ} |
| (hm : Measurable h) : |
| eLpNorm (collisionMarginal h) 1 (μ.prod volume) ≤ |
| eLpNorm h 1 ((μ.prod (volume : Measure (Velocity × Velocity))).prod sphereArea) := by |
| have ht := Compactness.eLpNorm_integral_le (μ := μ.prod volume) |
| (ν := (volume : Measure Velocity).prod sphereArea) (hm.comp collisionGrouping.symm.measurable) |
| apply ht.trans_eq |
| exact eLpNorm_comp_measurePreserving hm.aestronglyMeasurable (collisionGrouping_measurePreserving μ).symm |
|
|
| theorem collisionMarginal_difference_le {h k : (X × (Velocity × Velocity)) × Sphere → ℝ} |
| (hm : Measurable h) (km : Measurable k) |
| (hi : Integrable h ((μ.prod (volume : Measure (Velocity × Velocity))).prod sphereArea)) |
| (ki : Integrable k ((μ.prod (volume : Measure (Velocity × Velocity))).prod sphereArea)) : |
| eLpNorm (collisionMarginal h-collisionMarginal k) 1 (μ.prod volume) ≤ |
| eLpNorm (h-k) 1 ((μ.prod (volume : Measure (Velocity × Velocity))).prod sphereArea) := by |
| rw [← eLpNorm_congr_ae (collisionMarginal_sub_ae hi ki)] |
| exact collisionMarginal_eLpNorm_le (hm.sub km) |
|
|
| end BoltzmannNonuniqueness.CollisionCompactness |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| /-! # Collision operators depend only on the velocity fibre at their base point -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory |
|
|
| namespace BoltzmannNonuniqueness.CollisionCompactness |
|
|
| variable {X : Type*} [MeasurableSpace X] |
|
|
| private theorem mixedPostRate_fiber_congr (b : ℝ) {c d h k : X × Velocity → ℝ} {x : X} |
| (hc : ∀ v, c (x,v) = d (x,v)) (hh : ∀ v, h (x,v) = k (x,v)) |
| (v : Velocity) (w : Velocity × Sphere) : |
| mixedPostRate b c h (collisionGrouping.symm ((x,v),w)) = |
| mixedPostRate b d k (collisionGrouping.symm ((x,v),w)) := by |
| rw [mixedPostRate_formula,mixedPostRate_formula] |
| change CollisionCutoff.kernel b v w.1 w.2*c (x,scatterLeft v w.1 w.2)*h (x,scatterRight v w.1 w.2) = |
| CollisionCutoff.kernel b v w.1 w.2*d (x,scatterLeft v w.1 w.2)*k (x,scatterRight v w.1 w.2) |
| rw [hc,hh] |
|
|
| theorem mixedGain_fiber_congr (b : ℝ) {c d h k : X × Velocity → ℝ} {x : X} |
| (hc : ∀ v, c (x,v) = d (x,v)) (hh : ∀ v, h (x,v) = k (x,v)) (v : Velocity) : |
| mixedGainDensity b c h (x,v) = mixedGainDensity b d k (x,v) := by |
| unfold mixedGainDensity |
| simp_rw [mixedPostRate_fiber_congr b hc hh,mixedPostRate_fiber_congr b hh hc] |
|
|
| omit [MeasurableSpace X] in |
| theorem cutoffGain_fiber_congr (b : ℝ) {f g : X × Velocity → ℝ} {x : X} |
| (hf : ∀ v, f (x,v) = g (x,v)) (v : Velocity) : |
| KineticCollisionNullSets.gain b f (x,v) = KineticCollisionNullSets.gain b g (x,v) := by |
| unfold KineticCollisionNullSets.gain CollisionCutoff.gain CollisionCutoff.integrand |
| simp_rw [hf] |
|
|
| omit [MeasurableSpace X] in |
| theorem cutoffFrequency_fiber_congr (b : ℝ) {f g : X × Velocity → ℝ} {x : X} |
| (hf : ∀ v, f (x,v) = g (x,v)) (v : Velocity) : |
| KineticCollisionNullSets.frequency b f (x,v) = KineticCollisionNullSets.frequency b g (x,v) := by |
| unfold KineticCollisionNullSets.frequency CollisionCutoff.frequency |
| simp_rw [hf] |
|
|
| omit [MeasurableSpace X] in |
| theorem collisionSource_fiber_congr (b : ℝ) {f g : X × Velocity → ℝ} {x : X} |
| (hf : ∀ v, f (x,v) = g (x,v)) (v : Velocity) : |
| collisionSource b f (x,v) = collisionSource b g (x,v) := by |
| unfold collisionSource |
| rw [cutoffGain_fiber_congr b hf,cutoffFrequency_fiber_congr b hf,hf] |
|
|
| end BoltzmannNonuniqueness.CollisionCompactness |
|
|
| end |
|
|
| end |
|
|
| end OAI |
|
|
