openAI-math-dataset / lean /OAI /MathematicalPhysics /Boltzmann /Approximation /MildConservation.lean
| import OAI.MathematicalPhysics.Boltzmann.Approximation.MildRenormalization | |
| import OAI.MathematicalPhysics.Boltzmann.Approximation.MildRenormalizedBalance | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.Moments | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.MomentumCollisionIntegrability | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.WeightedMildBalance | |
| import OAI.MathematicalPhysics.Boltzmann.Collision.CollisionConservation | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.EntropyDissipationAverage | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.EntropyDissipationCoordinates | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.LocalMomentIntegrability | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.StrongMildRepresentative | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.WeakL1Operations | |
| namespace OAI | |
| section | |
| /-! # Integrable local mass tests and cancellation of their collision source -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| namespace BoltzmannNonuniqueness | |
| def massTestIntegrand (F : Evolution) (φ : MassTest) (z : ℝ × Phase) : ℝ := | |
| F z.1 z.2*φ.transportDerivative z.1 z.2+ | |
| collision (F z.1) z.2.1 z.2.2*φ.toFun z.1 z.2.1 | |
| theorem MassTest.slice_integrable (φ : MassTest) {T t : ℝ} (ht : t ∈ Icc 0 T) | |
| {f : Density} (hfi : Integrable f) : Integrable (fun p => f p*φ.toFun t p.1) := by | |
| have hφ : Measurable (fun p : Phase => φ.toFun t p.1) := | |
| φ.measurable_toFun.comp (measurable_const.prodMk measurable_id) | |
| obtain ⟨C,_hC,hb⟩ := φ.bounded_on_time T | |
| apply hfi.mul_bdd hφ.aestronglyMeasurable | |
| exact Filter.Eventually.of_forall (fun p => by | |
| simpa only [Real.norm_eq_abs] using (hb t ht p).1) | |
| namespace MildCollisionSolution | |
| variable {T : ℝ} {f₀ : Density} {g : (ℝ × Position) × Velocity → ℝ} | |
| theorem mass_source_integrable (S : MildCollisionSolution T f₀ g) (hf₀m : Measurable f₀) | |
| (φ : MassTest) : | |
| Integrable (fun z : ℝ × Phase => collision (positiveEvolution T f₀ g z.1) z.2.1 z.2.2* | |
| φ.toFun z.1 z.2.1) ((volume.restrict (Icc 0 T)).prod volume) := by | |
| obtain ⟨C,_hC,hb⟩ := φ.bounded_on_time T | |
| apply (S.positiveEvolution_collision_integrable hf₀m).mul_bdd φ.measurable_toFun.aestronglyMeasurable | |
| have ht : ∀ᵐ z : ℝ × Phase ∂(volume.restrict (Icc 0 T)).prod volume, z.1 ∈ Icc 0 T := | |
| Measure.quasiMeasurePreserving_fst.ae (ae_restrict_mem measurableSet_Icc) | |
| filter_upwards [ht] with z hz | |
| simpa only [Real.norm_eq_abs] using (hb z.1 hz z.2).1 | |
| theorem mass_source_zero (S : MildCollisionSolution T f₀ g) (hf₀m : Measurable f₀) | |
| (φ : MassTest) : | |
| (∫ z : ℝ × Phase, collision (positiveEvolution T f₀ g z.1) z.2.1 z.2.2* | |
| φ.toFun z.1 z.2.1 ∂(volume.restrict (Icc 0 T)).prod volume) = 0 := by | |
| let F := positiveEvolution T f₀ g | |
| let ψ : ℝ × Position → ℝ := fun u => φ.toFun u.1 u.2 | |
| have hψm : Measurable ψ := φ.measurable_toFun.comp | |
| (show Measurable (fun u : ℝ × Position => (u.1,(u.2,(0:Velocity)))) from by fun_prop) | |
| obtain ⟨C,_hC,hb⟩ := φ.bounded_on_time T | |
| have hψb : ∀ᵐ u ∂AnnularEnvelope.timePositionVolume T, ‖ψ u‖ ≤ C := by | |
| have ht : ∀ᵐ u : ℝ × Position ∂AnnularEnvelope.timePositionVolume T, u.1 ∈ Icc 0 T := | |
| Measure.quasiMeasurePreserving_fst.ae (ae_restrict_mem measurableSet_Icc) | |
| filter_upwards [ht] with u hu | |
| simpa only [ψ,Real.norm_eq_abs] using (hb u.1 hu (u.2,0)).1 | |
| have hz := CollisionCompactness.base_test_collision_zero (S.positiveDensity_measurable hf₀m) | |
| (fun p => positiveEvolution_nonnegative p.1.1 (p.1.2,p.2)) | |
| (S.positiveDensity_pair_integrable hf₀m) hψm hψb | |
| let W : ℝ × Phase → ℝ := fun z => collision (F z.1) z.2.1 z.2.2*φ.toFun z.1 z.2.1 | |
| have hc := (kineticGrouping_measurePreserving (volume.restrict (Icc 0 T))).integral_comp | |
| MeasurableEquiv.prodAssoc.measurableEmbedding W | |
| change (∫ z, W z ∂(volume.restrict (Icc 0 T)).prod volume) = 0 | |
| rw [← hc] | |
| calc | |
| _ = ∫ p, ψ p.1*(CollisionCompactness.gainDensity (kineticDensity F) p- | |
| CollisionCompactness.lossDensity (kineticDensity F) p) | |
| ∂(AnnularEnvelope.timePositionVolume T).prod volume := by | |
| apply integral_congr_ae | |
| filter_upwards [] with p | |
| have he := kineticDensity_collision F (p.1.1,(p.1.2,p.2)) | |
| change collision (F p.1.1) p.1.2 p.2*ψ p.1 = _ | |
| rw [← he] | |
| exact mul_comm _ _ | |
| _ = 0 := hz | |
| theorem mass_integrand_integrable (S : MildCollisionSolution T f₀ g) (hf₀m : Measurable f₀) | |
| (hEi : Integrable (fun z : ℝ × Phase => entropyMoment (positiveEvolution T f₀ g z.1) z.2) | |
| ((volume.restrict (Icc 0 T)).prod volume)) (φ : MassTest) : | |
| Integrable (massTestIntegrand (positiveEvolution T f₀ g) φ) | |
| ((volume.restrict (Icc 0 T)).prod volume) := | |
| (mass_transport_integrable (S.positiveEvolution_measurable hf₀m) positiveEvolution_nonnegative hEi φ).add | |
| (S.mass_source_integrable hf₀m φ) | |
| end MildCollisionSolution | |
| end BoltzmannNonuniqueness | |
| end | |
| end | |
| section | |
| /-! # The actual local mild solution conserves local mass -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| namespace BoltzmannNonuniqueness.MildCollisionSolution | |
| variable {T : ℝ} {f₀ : Density} {g : (ℝ × Position) × Velocity → ℝ} | |
| theorem massTestIntegrand_along_eq (S : MildCollisionSolution T f₀ g) | |
| (hf₀m : Measurable f₀) (φ : MassTest) : | |
| TorusFlight.along (massTestIntegrand (positiveEvolution T f₀ g) φ) =ᵐ[ | |
| (volume.restrict (Icc 0 T)).prod volume] | |
| (fun z => characteristicSource g z*φ.toFun z.1 (TorusFlight.flight z.1 z.2).1+ | |
| entropyPath f₀ (characteristicSource g) z.1 z.2* | |
| φ.transportDerivative z.1 (TorusFlight.flight z.1 z.2)) := by | |
| filter_upwards [S.positiveEvolution_along_eq_path_spacetime, | |
| S.positiveEvolution_along_collision_eq_source hf₀m] with z hf hr | |
| dsimp only [TorusFlight.along,massTestIntegrand] | |
| rw [hf,← hr] | |
| exact add_comm _ _ | |
| theorem mass_balance_with_source (S : MildCollisionSolution T f₀ g) (hT : 0 < T) | |
| (hf₀m : Measurable f₀) (hf₀i : Integrable f₀) | |
| (hEi : Integrable (fun z : ℝ × Phase => entropyMoment (positiveEvolution T f₀ g z.1) z.2) | |
| ((volume.restrict (Icc 0 T)).prod volume)) (φ : MassTest) : | |
| (∫ z, massTestIntegrand (positiveEvolution T f₀ g) φ z ∂(volume.restrict (Icc 0 T)).prod volume) = | |
| (∫ p : Phase, positiveEvolution T f₀ g T p*φ.toFun T p.1)- | |
| (∫ p : Phase, f₀ p*φ.toFun 0 p.1) := by | |
| let μ : Measure ℝ := volume.restrict (Icc 0 T) | |
| let F := positiveEvolution T f₀ g | |
| let I := massTestIntegrand F φ | |
| let B : Phase → ℝ := fun p => F T p*φ.toFun T p.1 | |
| let B₀ : Phase → ℝ := fun p => f₀ p*φ.toFun 0 p.1 | |
| have hIi : Integrable I (μ.prod volume) := S.mass_integrand_integrable hf₀m hEi φ | |
| have hAi := (TorusFlight.along_measurePreserving μ).integrable_comp_of_integrable hIi | |
| have hBi : Integrable B := φ.slice_integrable ⟨hT.le,le_rfl⟩ (S.positiveEvolution_integrable hf₀m hf₀i T) | |
| have hB₀i : Integrable B₀ := φ.slice_integrable ⟨le_rfl,hT.le⟩ hf₀i | |
| have hp : ∀ᵐ p : Phase, | |
| (∫ t, TorusFlight.along I (t,p) ∂μ) = B (TorusFlight.flight T p)-B₀ p := by | |
| have he := Measure.ae_ae_of_ae_prod | |
| ((Measure.measurePreserving_swap (μ := (volume : Measure Phase)) (ν := μ)).quasiMeasurePreserving.ae | |
| (S.massTestIntegrand_along_eq hf₀m φ)) | |
| filter_upwards [S.mass_tested_paths hT φ,he, | |
| S.positiveEvolution_along_eq_path hT hf₀m hf₀i ⟨hT.le,le_rfl⟩] with p hp he hend | |
| rw [intervalIntegral.integral_of_le hT.le,← integral_Icc_eq_integral_Ioc] at hp | |
| calc | |
| _ = _ := integral_congr_ae he | |
| _ = _ := hp | |
| _ = _ := by | |
| dsimp only [B,B₀,F] | |
| rw [hend] | |
| calc | |
| _ = ∫ z, TorusFlight.along I z ∂μ.prod volume := (TorusFlight.integral_along hIi).symm | |
| _ = ∫ p : Phase, ∫ t, TorusFlight.along I (t,p) ∂μ := integral_prod_symm _ hAi | |
| _ = ∫ p : Phase, B (TorusFlight.flight T p)-B₀ p := integral_congr_ae hp | |
| _ = (∫ p : Phase, B (TorusFlight.flight T p))-(∫ p : Phase, B₀ p) := | |
| integral_sub ((TorusFlight.flight_measurePreserving T).integrable_comp_of_integrable hBi) hB₀i | |
| _ = _ := by rw [TorusFlight.integral_flight] | |
| theorem local_mass_balance (S : MildCollisionSolution T f₀ g) (hT : 0 < T) | |
| (hf₀m : Measurable f₀) (hf₀i : Integrable f₀) | |
| (hEi : Integrable (fun z : ℝ × Phase => entropyMoment (positiveEvolution T f₀ g z.1) z.2) | |
| ((volume.restrict (Icc 0 T)).prod volume)) (φ : MassTest) : | |
| (∫ z in boundedTimes T, positiveEvolution T f₀ g z.1 z.2*φ.transportDerivative z.1 z.2) = | |
| (∫ p : Phase, positiveEvolution T f₀ g T p*φ.toFun T p.1)- | |
| (∫ p : Phase, f₀ p*φ.toFun 0 p.1) := by | |
| have h := S.mass_balance_with_source hT hf₀m hf₀i hEi φ | |
| change (∫ z, positiveEvolution T f₀ g z.1 z.2*φ.transportDerivative z.1 z.2+ | |
| collision (positiveEvolution T f₀ g z.1) z.2.1 z.2.2*φ.toFun z.1 z.2.1 | |
| ∂(volume.restrict (Icc 0 T)).prod volume) = _ at h | |
| rw [integral_add (mass_transport_integrable (S.positiveEvolution_measurable hf₀m) | |
| positiveEvolution_nonnegative hEi φ) (S.mass_source_integrable hf₀m φ), | |
| S.mass_source_zero hf₀m φ,add_zero] at h | |
| rwa [phaseInterval_measure] at h | |
| theorem local_mass_of_terminal_zero (S : MildCollisionSolution T f₀ g) (hT : 0 < T) | |
| (hf₀m : Measurable f₀) (hf₀i : Integrable f₀) | |
| (hEi : Integrable (fun z : ℝ × Phase => entropyMoment (positiveEvolution T f₀ g z.1) z.2) | |
| ((volume.restrict (Icc 0 T)).prod volume)) (φ : MassTest) | |
| (hφ : ∀ x, φ.toFun T x = 0) : | |
| (∫ z in boundedTimes T, positiveEvolution T f₀ g z.1 z.2*φ.transportDerivative z.1 z.2)+ | |
| (∫ p : Phase, f₀ p*φ.toFun 0 p.1) = 0 := by | |
| rw [S.local_mass_balance hT hf₀m hf₀i hEi φ] | |
| simp only [hφ,mul_zero,integral_zero,zero_sub,neg_add_cancel] | |
| end BoltzmannNonuniqueness.MildCollisionSolution | |
| end | |
| end | |
| section | |
| /-! # Every-time energy conservation of the constructed local mild solution -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| namespace BoltzmannNonuniqueness.MildCollisionSolution | |
| variable {T : ℝ} {f₀ : Density} {g : (ℝ × Position) × Velocity → ℝ} | |
| theorem energy_source_zero (S : MildCollisionSolution T f₀ g) | |
| (hE : Integrable (CollisionCompactness.exponentialPair g) | |
| ((AnnularEnvelope.timePositionVolume T).prod volume)) : | |
| ∀ᵐ t ∂volume.restrict (Icc 0 T), | |
| (∫ p : Phase, ‖p.2‖^2*source g ((t,p.1),p.2)) = 0 := by | |
| let μ : Measure ℝ := volume.restrict (Icc 0 T) | |
| have hpi := (measurePreserving_prodAssoc μ (volume : Measure Position) | |
| (volume : Measure (Velocity × Velocity))).symm.integrable_comp_of_integrable hE | |
| filter_upwards [hpi.prod_right_ae] with t ht | |
| let f : Position × Velocity → ℝ := fun p => g ((t,p.1),p.2) | |
| have hm : Measurable f := S.measurable.comp | |
| ((measurable_const.prodMk measurable_fst).prodMk measurable_snd) | |
| have hn : ∀ p, 0 ≤ f p := fun p => S.nonnegative _ | |
| have hp : Integrable (CollisionCompactness.exponentialPair f) | |
| ((volume : Measure Position).prod (volume : Measure (Velocity × Velocity))) := ht | |
| have hc := CollisionCompactness.energy_collision_balance hm hn hp | |
| have hi := CollisionCompactness.gainLoss_energy_integrable hm hn hp | |
| change (∫ p : Phase, ‖p.2‖^2*(CollisionCompactness.gainDensity f p- | |
| CollisionCompactness.lossDensity f p)) = 0 | |
| simp_rw [mul_sub] | |
| rw [Measure.volume_eq_prod,integral_sub hi.1 hi.2,hc,sub_self] | |
| theorem energy_characteristic_integrable (S : MildCollisionSolution T f₀ g) | |
| (hE : Integrable (CollisionCompactness.exponentialPair g) | |
| ((AnnularEnvelope.timePositionVolume T).prod volume)) : | |
| Integrable (fun z : ℝ × Phase => ‖z.2.2‖^2*characteristicSource g z) | |
| ((volume.restrict (Icc 0 T)).prod volume) := by | |
| have hi := CollisionCompactness.gainLoss_energy_integrable S.measurable S.nonnegative hE | |
| have hs : Integrable (fun p => ‖p.2‖^2*source g p) | |
| ((AnnularEnvelope.timePositionVolume T).prod volume) := by | |
| convert hi.1.sub hi.2 using 1 | |
| funext p | |
| exact mul_sub _ _ _ | |
| have hr := (measurePreserving_prodAssoc (volume.restrict (Icc 0 T)) | |
| (volume : Measure Position) (volume : Measure Velocity)).symm.integrable_comp_of_integrable hs | |
| have hrr : Integrable (fun z : ℝ × Phase => ‖z.2.2‖^2*TorusFlight.regroup (source g) z) | |
| ((volume.restrict (Icc 0 T)).prod volume) := by | |
| rw [Measure.volume_eq_prod] | |
| exact hr | |
| exact (TorusFlight.along_measurePreserving (volume.restrict (Icc 0 T))).integrable_comp_of_integrable hrr | |
| theorem energy_characteristic_zero (S : MildCollisionSolution T f₀ g) | |
| (hE : Integrable (CollisionCompactness.exponentialPair g) | |
| ((AnnularEnvelope.timePositionVolume T).prod volume)) : | |
| ∀ᵐ t ∂volume.restrict (Icc 0 T), | |
| (∫ p : Phase, ‖p.2‖^2*characteristicSource g (t,p)) = 0 := by | |
| filter_upwards [S.energy_source_zero hE] with t ht | |
| exact (TorusFlight.integral_flight | |
| (fun p : Phase => ‖p.2‖^2*source g ((t,p.1),p.2)) t).trans ht | |
| theorem energy_conservation (S : MildCollisionSolution T f₀ g) (hT : 0 < T) | |
| (hf₀m : Measurable f₀) (hf₀i : Integrable f₀) | |
| (hf₀E : Integrable (fun p : Phase => ‖p.2‖^2*f₀ p)) | |
| (hE : Integrable (CollisionCompactness.exponentialPair g) | |
| ((AnnularEnvelope.timePositionVolume T).prod volume)) | |
| {t : ℝ} (ht : t ∈ Icc 0 T) : | |
| energy (positiveEvolution T f₀ g t) = energy f₀ := by | |
| have hm : Measurable (fun z : ℝ × Phase => ‖z.2.2‖^2*characteristicSource g z) := | |
| (measurable_snd.snd.norm.pow_const 2).mul S.characteristicSource_measurable | |
| have h := TorusFlight.velocity_weighted_profile_balance f₀ (characteristicSource g) | |
| (fun v => ‖v‖^2) hm (S.energy_characteristic_integrable hE) hf₀E t | |
| have hz : (∫ s, if s ≤ t then ∫ p : Phase, ‖p.2‖^2*characteristicSource g (s,p) else 0 | |
| ∂volume.restrict (Icc 0 T)) = 0 := by | |
| apply integral_eq_zero_of_ae | |
| filter_upwards [S.energy_characteristic_zero hE] with s hs | |
| split_ifs <;> simp_all | |
| rw [hz,add_zero] at h | |
| change (∫ p : Phase, ‖p.2‖^2*positiveEvolution T f₀ g t p) = _ | |
| calc | |
| _ = ∫ p : Phase, ‖p.2‖^2*evolution T f₀ g t p := by | |
| apply integral_congr_ae | |
| filter_upwards [S.evolution_eq_positive_each_time hT hf₀m hf₀i t ht] with p hp | |
| rw [hp] | |
| _ = _ := h | |
| end BoltzmannNonuniqueness.MildCollisionSolution | |
| end | |
| end | |
| section | |
| /-! # Entropy admissibility of the positive representative of a mild solution -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open scoped ENNReal | |
| namespace BoltzmannNonuniqueness.MildCollisionSolution | |
| theorem entropy_admissible {T : ℝ} {f₀ : Density} {g : (ℝ × Position) × Velocity → ℝ} | |
| (S : MildCollisionSolution T f₀ g) (hT : 0 < T) (hf₀ : FiniteEntropyDatum f₀) | |
| (hm₀ : Measurable f₀) (hn₀ : ∀ z, 0 ≤ f₀ z) | |
| (hH : ∀ t ∈ Ioc 0 T, | |
| (∫⁻ z, ENNReal.ofReal (scalarRelativeEntropy (maxwellian z.2) (positiveEvolution T f₀ g t z)))+ | |
| CollisionCompactness.rateDissipation (AnnularEnvelope.timePositionVolume t) g ≤ | |
| ENNReal.ofReal (relativeEntropy f₀)) : | |
| (∀ t ∈ Icc 0 T, FiniteEntropyDatum (positiveEvolution T f₀ g t)) ∧ | |
| (∀ t ∈ Icc 0 T, ENNReal.ofReal (relativeEntropy (positiveEvolution T f₀ g t))+ | |
| (∫⁻ s in Icc (0:ℝ) t, entropyDissipation (positiveEvolution T f₀ g s)) ≤ | |
| ENNReal.ofReal (relativeEntropy f₀)) := by | |
| let F := positiveEvolution T f₀ g | |
| have hFm := S.positiveEvolution_measurable hm₀ | |
| have hFn : ∀ t z, 0 ≤ F t z := fun t z => positiveEvolution_nonnegative t z | |
| have hFi t : Measurable (F t) := hFm.comp (measurable_const.prodMk measurable_id) | |
| have hInitial : F 0 = f₀ := funext (positiveEvolution_initial hT.le hn₀) | |
| have hHintegrable {t : ℝ} (ht : t ∈ Icc 0 T) : | |
| Integrable (fun z => scalarRelativeEntropy (maxwellian z.2) (F t z)) := by | |
| by_cases ht0 : t = 0 | |
| · rw [ht0,hInitial] | |
| exact hf₀.integrable_relativeEntropy.congr (ae_of_all _ (fun z => | |
| (scalarRelativeEntropy_eq (maxwellian_pos z.2) _).symm)) | |
| · have htt : t ∈ Ioc 0 T := ⟨lt_of_le_of_ne ht.1 (Ne.symm ht0),ht.2⟩ | |
| have hfin : (∫⁻ z, ENNReal.ofReal (scalarRelativeEntropy (maxwellian z.2) (F t z))) ≤ | |
| ENNReal.ofReal (relativeEntropy f₀) := | |
| (le_add_of_nonneg_right zero_le).trans (hH t htt) | |
| have hmm : Measurable (fun z : Phase => maxwellian z.2) := by | |
| unfold maxwellian | |
| fun_prop | |
| have hm : Measurable (fun z => scalarRelativeEntropy (maxwellian z.2) (F t z)) := by | |
| unfold scalarRelativeEntropy | |
| exact (((hFi t).mul (hFi t).log).sub ((hFi t).mul | |
| (measurable_const.add hmm.log))).add hmm | |
| exact (lintegral_ofReal_ne_top_iff_integrable hm.aestronglyMeasurable | |
| (ae_of_all _ (fun z => scalarRelativeEntropy_nonneg (maxwellian_pos z.2) (hFn t z)))).mp | |
| (ne_of_lt (hfin.trans_lt ENNReal.ofReal_lt_top)) | |
| refine ⟨fun t ht => finiteEntropy_of_relativeEntropy_integrable (hFi t) (hFn t) (hHintegrable ht),?_⟩ | |
| intro t ht | |
| by_cases ht0 : t = 0 | |
| · change ENNReal.ofReal (relativeEntropy (F t))+_ ≤ _ | |
| simp [ht0,hInitial] | |
| · have htt : t ∈ Ioc 0 T := ⟨lt_of_le_of_ne ht.1 (Ne.symm ht0),ht.2⟩ | |
| have he : relativeEntropy (F t) = ∫ z, scalarRelativeEntropy (maxwellian z.2) (F t z) := | |
| integral_congr_ae (ae_of_all _ (fun z => (scalarRelativeEntropy_eq (maxwellian_pos z.2) _).symm)) | |
| have hD : CollisionCompactness.rateDissipation (AnnularEnvelope.timePositionVolume t) g = | |
| CollisionCompactness.rateDissipation (AnnularEnvelope.timePositionVolume t) (kineticDensity F) := | |
| CollisionCompactness.rateDissipation_congr S.measurable (S.positiveDensity_measurable hm₀) | |
| (S.positiveDensity_eq_ae.filter_mono (ae_mono | |
| (Measure.prod_mono (timePositionVolume_mono ht.2) le_rfl))) | |
| rw [kineticDensity_rateDissipation hFm hFn t] at hD | |
| change ENNReal.ofReal (relativeEntropy (F t))+_ ≤ _ | |
| rw [he,ofReal_integral_eq_lintegral_ofReal (hHintegrable ht) | |
| (ae_of_all _ (fun z => scalarRelativeEntropy_nonneg (maxwellian_pos z.2) (hFn t z))),← hD] | |
| exact hH t htt | |
| end BoltzmannNonuniqueness.MildCollisionSolution | |
| end | |
| end | |
| section | |
| /-! # Every-time momentum conservation for the actual local mild solution -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| namespace BoltzmannNonuniqueness.MildCollisionSolution | |
| variable {T : ℝ} {f₀ : Density} {g : (ℝ × Position) × Velocity → ℝ} | |
| theorem coordinate_source_zero (S : MildCollisionSolution T f₀ g) | |
| (hE : Integrable (CollisionCompactness.exponentialPair g) | |
| ((AnnularEnvelope.timePositionVolume T).prod volume)) (i : Fin 3) : | |
| ∀ᵐ t ∂volume.restrict (Icc 0 T), | |
| (∫ p : Phase, p.2 i*source g ((t,p.1),p.2)) = 0 := by | |
| let μ : Measure ℝ := volume.restrict (Icc 0 T) | |
| have hp := (measurePreserving_prodAssoc μ (volume : Measure Position) | |
| (volume : Measure (Velocity × Velocity))).symm.integrable_comp_of_integrable S.pair_integrable | |
| have he := (measurePreserving_prodAssoc μ (volume : Measure Position) | |
| (volume : Measure (Velocity × Velocity))).symm.integrable_comp_of_integrable hE | |
| filter_upwards [hp.prod_right_ae,he.prod_right_ae] with t hpt het | |
| let f : Position × Velocity → ℝ := fun p => g ((t,p.1),p.2) | |
| have hm : Measurable f := S.measurable.comp | |
| ((measurable_const.prodMk measurable_fst).prodMk measurable_snd) | |
| have hn : ∀ p, 0 ≤ f p := fun p => S.nonnegative _ | |
| have hpair : Integrable (CollisionCompactness.pairDensity f) | |
| ((volume : Measure Position).prod (volume : Measure (Velocity × Velocity))) := hpt | |
| have henergy : Integrable (CollisionCompactness.exponentialPair f) | |
| ((volume : Measure Position).prod (volume : Measure (Velocity × Velocity))) := het | |
| have hc := CollisionCompactness.momentum_collision_balance hm hn hpair henergy i | |
| have hi := CollisionCompactness.gainLoss_coordinate_integrable hm hn hpair henergy i | |
| change (∫ p : Phase, p.2 i*(CollisionCompactness.gainDensity f p-CollisionCompactness.lossDensity f p)) = 0 | |
| simp_rw [mul_sub] | |
| rw [Measure.volume_eq_prod,integral_sub hi.1 hi.2,hc,sub_self] | |
| theorem coordinate_characteristic_integrable (S : MildCollisionSolution T f₀ g) | |
| (hE : Integrable (CollisionCompactness.exponentialPair g) | |
| ((AnnularEnvelope.timePositionVolume T).prod volume)) (i : Fin 3) : | |
| Integrable (fun z : ℝ × Phase => z.2.2 i*characteristicSource g z) | |
| ((volume.restrict (Icc 0 T)).prod volume) := by | |
| have hi := CollisionCompactness.gainLoss_coordinate_integrable S.measurable S.nonnegative S.pair_integrable hE i | |
| have hs : Integrable (fun p => p.2 i*source g p) ((AnnularEnvelope.timePositionVolume T).prod volume) := by | |
| convert hi.1.sub hi.2 using 1 | |
| funext p | |
| exact mul_sub _ _ _ | |
| have hr := (kineticGrouping_measurePreserving (volume.restrict (Icc 0 T))).symm.integrable_comp_of_integrable hs | |
| exact (TorusFlight.along_measurePreserving (volume.restrict (Icc 0 T))).integrable_comp_of_integrable hr | |
| theorem coordinate_conservation (S : MildCollisionSolution T f₀ g) (hT : 0 < T) | |
| (hf₀m : Measurable f₀) (hf₀i : Integrable f₀) {i : Fin 3} | |
| (hf₀c : Integrable (fun p : Phase => p.2 i*f₀ p)) | |
| (hE : Integrable (CollisionCompactness.exponentialPair g) | |
| ((AnnularEnvelope.timePositionVolume T).prod volume)) | |
| {t : ℝ} (ht : t ∈ Icc 0 T) : | |
| (∫ p : Phase, p.2 i*positiveEvolution T f₀ g t p) = ∫ p : Phase, p.2 i*f₀ p := by | |
| have hm : Measurable (fun z : ℝ × Phase => z.2.2 i*characteristicSource g z) := by | |
| exact (by fun_prop : Measurable (fun z : ℝ × Phase => z.2.2 i)).mul S.characteristicSource_measurable | |
| have h := TorusFlight.velocity_weighted_profile_balance f₀ (characteristicSource g) | |
| (fun v => v i) hm (S.coordinate_characteristic_integrable hE i) hf₀c t | |
| have hz : (∫ s, if s ≤ t then ∫ p : Phase, p.2 i*characteristicSource g (s,p) else 0 | |
| ∂volume.restrict (Icc 0 T)) = 0 := by | |
| apply integral_eq_zero_of_ae | |
| filter_upwards [S.coordinate_source_zero hE i] with s hs | |
| have hchar : (∫ p : Phase, p.2 i*characteristicSource g (s,p)) = 0 := | |
| (TorusFlight.integral_flight (fun p : Phase => p.2 i*source g ((s,p.1),p.2)) s).trans hs | |
| split_ifs <;> simp_all | |
| rw [hz,add_zero] at h | |
| calc | |
| _ = ∫ p : Phase, p.2 i*evolution T f₀ g t p := by | |
| apply integral_congr_ae | |
| filter_upwards [S.evolution_eq_positive_each_time hT hf₀m hf₀i t ht] with p hp | |
| rw [hp] | |
| _ = _ := h | |
| theorem momentum_conservation (S : MildCollisionSolution T f₀ g) (hT : 0 < T) | |
| (hf₀m : Measurable f₀) (hf₀ : FiniteEntropyDatum f₀) | |
| (hfinite : ∀ t ∈ Icc 0 T, FiniteEntropyDatum (positiveEvolution T f₀ g t)) | |
| (hE : Integrable (CollisionCompactness.exponentialPair g) | |
| ((AnnularEnvelope.timePositionVolume T).prod volume)) | |
| {t : ℝ} (ht : t ∈ Icc 0 T) : momentum (positiveEvolution T f₀ g t) = momentum f₀ := by | |
| apply PiLp.ext | |
| intro i | |
| let L := PiLp.proj (𝕜 := ℝ) 2 (fun _ : Fin 3 => ℝ) i | |
| have h₀ := L.integrable_comp hf₀.integrable_momentum | |
| have h₁ := L.integral_comp_comm hf₀.integrable_momentum | |
| have h₂ := L.integral_comp_comm (hfinite t ht).integrable_momentum | |
| have hc : Integrable (fun p : Phase => p.2 i*f₀ p) := by | |
| simpa only [L,PiLp.proj_apply,PiLp.smul_apply,smul_eq_mul,mul_comm] using h₀ | |
| have h := S.coordinate_conservation hT hf₀m hf₀.integrable hc hE ht | |
| change (momentum (positiveEvolution T f₀ g t)) i = (momentum f₀) i | |
| simp only [L,PiLp.proj_apply,PiLp.smul_apply,smul_eq_mul] at h₁ h₂ | |
| calc | |
| _ = ∫ p : Phase, positiveEvolution T f₀ g t p*p.2 i := h₂.symm | |
| _ = ∫ p : Phase, p.2 i*positiveEvolution T f₀ g t p := by | |
| apply integral_congr_ae | |
| exact Filter.Eventually.of_forall (fun p => mul_comm _ _) | |
| _ = ∫ p : Phase, p.2 i*f₀ p := h | |
| _ = ∫ p : Phase, f₀ p*p.2 i := by | |
| apply integral_congr_ae | |
| exact Filter.Eventually.of_forall (fun p => mul_comm _ _) | |
| _ = _ := h₁ | |
| end BoltzmannNonuniqueness.MildCollisionSolution | |
| end | |
| end | |
| end OAI | |