openAI-math-dataset / lean /OAI /MathematicalPhysics /Boltzmann /Approximation /PositiveEndpointHistory.lean
| import OAI.MathematicalPhysics.Boltzmann.Approximation.PositiveVolterra | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.BoundedGeometricBlock | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.EndpointHistoryMass | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.MainPositiveRemainderBound | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.OccupationSliceIntegral | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.PhaseSliceLocalization | |
| import OAI.MathematicalPhysics.Boltzmann.Branching.SmallFirstGain | |
| import OAI.MathematicalPhysics.Boltzmann.Compactness.SelectedOriginDeletion | |
| namespace OAI | |
| section | |
| /-! # Axial spatial escape forces the actual positive fifth gain to vanish -/ | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped ENNReal Topology | |
| open BoltzmannNonuniqueness.VelocityWeight BoltzmannNonuniqueness.JetLattice | |
| open BoltzmannNonuniqueness.PositiveIteration | |
| namespace BoltzmannNonuniqueness.JetCopyDatum | |
| theorem positive_five_axial_escape_tendsto {K α γ q a T V s₀ η d₀ : ℝ} | |
| (hK : 0 ≤ K) (hα : 0 < α) (hγ : 0 < γ) (hq₁ : 1 < q) (hq₂ : q < 2) | |
| (ha : 0 < a) (hs₀ : 0 < s₀) (hsmax : s₀ ≤ 1/8) | |
| (hη : 0 < η) (hηmax : η ≤ Real.log 2) (hd₀ : 0 < d₀) (hdmax : d₀ ≤ 1) | |
| (r : ℕ → ℝ) (hr : ∀ n, 0 < r n) (N : ℕ → ℕ) (z : ℕ → Published.KineticPhase) | |
| (ht : ∀ n, (z n).1.1 ∈ Icc a T) (hv : ∀ n, ‖(z n).2‖ ≤ V) | |
| (hx : ∀ R : ℝ, ∀ᶠ n in atTop, ∀ k : Lattice, | |
| R ≤ |axial ((z n).1.2-(r n)⁻¹ • latticeVector k)|) | |
| {f : ℕ → Published.KineticPhase → ℝ≥0∞} {B : ℝ≥0∞} (hB : B ≠ ∞) | |
| (hf : ∀ n y, y.1.1 ∈ Icc a T → f n y ≤ B) : | |
| Tendsto (fun n => iterate a (positiveMainKernel (r n) s₀ η K α γ d₀ q (N n)) | |
| (f n) 5 (z n)) atTop (𝓝 0) := by | |
| refine five_tendsto_of_small_first_mass | |
| (C := ENNReal.ofReal ((2*JetCoreSheet.growthConstant K α γ q)/a)) | |
| (fun n => positiveMainKernel (r n) s₀ η K α γ d₀ q (N n)) ENNReal.ofReal_ne_top hB ?_ hf z ht ?_ | |
| · intro n y hy | |
| apply (positiveMainKernel_bound (hr n) hs₀ hsmax hη hηmax hK hα hγ hd₀ hdmax hq₁ hq₂ | |
| (N n) y (ha.trans_le hy.1)).trans | |
| exact ENNReal.ofReal_le_ofReal (div_le_div_of_nonneg_left | |
| (mul_nonneg (by norm_num) (JetCoreSheet.growthConstant_nonneg hK α γ q)) ha hy.1) | |
| · intro ε hε | |
| filter_upwards [selected_axial_escape_small hK hα hγ hq₁ hq₂ ha.le hs₀ hsmax | |
| hη hηmax hd₀ hdmax r hr N z ht hv hx (half_pos hε)] with n hn | |
| intro s hs | |
| have h := hn s hs | |
| change ((selectedFreeKernel (r n) s₀ η K α γ d₀ q (N n) (flight (z n) s))+ | |
| (selectedFreeKernel (r n) s₀ η K α γ d₀ q (N n) (flight (z n) s))) univ ≤ _ | |
| rw [Measure.add_apply] | |
| apply (add_le_add h h).trans_eq | |
| rw [← ENNReal.ofReal_add (half_pos hε).le (half_pos hε).le] | |
| congr 1 | |
| ring | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| end | |
| end | |
| section | |
| /-! # A positive bounded seed on a prescribed full-measure set of times -/ | |
| noncomputable section | |
| open MeasureTheory Set | |
| open scoped ENNReal | |
| namespace BoltzmannNonuniqueness.WeakTime | |
| theorem exists_nonzero_phaseSlice {F : ℝ × Phase → ℝ} (hF : Measurable F) | |
| (a b : ℝ) | |
| (hne : (positiveDensityMeasure volume F).restrict (Prod.fst ⁻¹' Ioc a b) ≠ 0) | |
| {G : Set ℝ} (hG : ∀ᵐ t ∂volume, t ∈ G) : | |
| ∃ t ∈ Ioc a b, t ∈ G ∧ phaseSlice F t ≠ 0 := by | |
| by_contra h | |
| push Not at h | |
| apply hne | |
| apply Measure.measure_univ_eq_zero.mp | |
| have H := occupation_slice_lintegral hF a b (f := fun _ => 1) measurable_const | |
| simp only [lintegral_one] at H | |
| rw [H] | |
| apply lintegral_eq_zero_of_ae_eq_zero | |
| filter_upwards [ae_restrict_mem measurableSet_Ioc,ae_restrict_of_ae hG] with t ht htg | |
| rw [h t ht htg] | |
| simp | |
| theorem exists_positive_seed_slice {F : ℝ × Phase → ℝ} (hF : Measurable F) | |
| (a b : ℝ) | |
| (hne : (positiveDensityMeasure volume F).restrict (Prod.fst ⁻¹' Ioc a b) ≠ 0) | |
| {G : Set ℝ} (hG : ∀ᵐ t ∂volume, t ∈ G) : | |
| ∃ t ∈ Ioc a b, t ∈ G ∧ ∃ n : ℕ, 0 < phaseSlice F t (seedPortion n) := by | |
| obtain ⟨t,ht,htG,htn⟩ := exists_nonzero_phaseSlice hF a b hne hG | |
| have hac : phaseSlice F t ≪ volume := by | |
| unfold phaseSlice positiveDensityMeasure | |
| exact withDensity_absolutelyContinuous _ _ | |
| obtain ⟨n,hn⟩ := exists_positive_seedPortion (phaseSlice F t) hac htn | |
| exact ⟨t,ht,htG,n,hn⟩ | |
| end BoltzmannNonuniqueness.WeakTime | |
| end | |
| end | |
| section | |
| /-! # Scalar exponential control of the actual positive Volterra inequality -/ | |
| noncomputable section | |
| open MeasureTheory ProbabilityTheory Set Filter | |
| open scoped ENNReal Topology | |
| open BoltzmannNonuniqueness.Published | |
| namespace BoltzmannNonuniqueness.PositiveIteration | |
| theorem iterate_unit_factorial_bound {T C B : ℝ} (hT : T ≤ 1) (hC : 0 ≤ C) (hB : 0 ≤ B) | |
| (K : Kernel KineticPhase Velocity) | |
| (hK : ∀ z, z.1.1 ∈ Icc 0 T → K z univ ≤ ENNReal.ofReal C) | |
| {f : KineticPhase → ℝ≥0∞} (hf : ∀ z, z.1.1 ∈ Icc 0 T → f z ≤ ENNReal.ofReal B) | |
| (n : ℕ) (z : KineticPhase) (hz : z.1.1 ∈ Icc 0 T) : | |
| iterate 0 K f n z ≤ ENNReal.ofReal (B*(C^n/(n.factorial:ℝ))) := by | |
| apply (iterate_factorial_bound hC hB K hK hf n z hz).trans | |
| apply ENNReal.ofReal_le_ofReal | |
| have ht : z.1.1^n ≤ 1 := pow_le_one₀ hz.1 (hz.2.trans hT) | |
| have hh := mul_le_mul_of_nonneg_left ht (mul_nonneg hB (pow_nonneg hC n)) | |
| calc | |
| _ ≤ (B*C^n*1)/(n.factorial:ℝ) := div_le_div_of_nonneg_right hh (Nat.cast_nonneg _) | |
| _ = _ := by ring | |
| theorem sum_iterate_const_le_exp {T C c : ℝ} (hT : T ≤ 1) (hC : 0 ≤ C) (hc : 0 ≤ c) | |
| (K : Kernel KineticPhase Velocity) | |
| (hK : ∀ z, z.1.1 ∈ Icc 0 T → K z univ ≤ ENNReal.ofReal C) | |
| (n : ℕ) (z : KineticPhase) (hz : z.1.1 ∈ Icc 0 T) : | |
| (∑ j ∈ Finset.range n, iterate 0 K (fun _ => ENNReal.ofReal c) j z) ≤ | |
| ENNReal.ofReal (c*Real.exp C) := by | |
| calc | |
| _ ≤ ∑ j ∈ Finset.range n, ENNReal.ofReal (c*(C^j/(j.factorial:ℝ))) := | |
| Finset.sum_le_sum (fun j _ => iterate_unit_factorial_bound hT hC hc K hK | |
| (fun _ _ => le_rfl) j z hz) | |
| _ = ENNReal.ofReal (c*∑ j ∈ Finset.range n, C^j/(j.factorial:ℝ)) := by | |
| rw [Finset.mul_sum,ENNReal.ofReal_sum_of_nonneg] | |
| intro j _ | |
| positivity | |
| _ ≤ _ := ENNReal.ofReal_le_ofReal | |
| (mul_le_mul_of_nonneg_left (Real.sum_le_exp_of_nonneg hC n) hc) | |
| end BoltzmannNonuniqueness.PositiveIteration | |
| namespace BoltzmannNonuniqueness.JetCopyDatum | |
| open PositiveIteration | |
| theorem positiveMain_exponential_bound (hcarleman : Published.GPV2009CarlemanInput) | |
| (r s₀ η K α γ d₀ q T C B c : ℝ) (N : ℕ) | |
| (hT : T ≤ 1) (hC : 0 ≤ C) (hB : 0 ≤ B) (hc : 0 ≤ c) | |
| {f : KineticPhase → ℝ≥0∞} (hf : Measurable f) | |
| (hfB : ∀ z, z.1.1 ∈ Icc 0 T → f z ≤ ENNReal.ofReal B) | |
| (hmass : ∀ z, z.1.1 ∈ Icc 0 T → | |
| positiveMainKernel r s₀ η K α γ d₀ q N z univ ≤ ENNReal.ofReal C) | |
| (h : ∀ t ∈ Icc 0 T, ∀ᵐ p : Velocity × Velocity, f ((t,p.1),p.2) ≤ | |
| ENNReal.ofReal c+step 0 (positiveMainKernel r s₀ η K α γ d₀ q N) f ((t,p.1),p.2)) | |
| {t : ℝ} (ht : t ∈ Icc 0 T) : | |
| ∀ᵐ p : Velocity × Velocity, f ((t,p.1),p.2) ≤ ENNReal.ofReal (c*Real.exp C) := by | |
| let J := positiveMainKernel r s₀ η K α γ d₀ q N | |
| have hall : ∀ᵐ p : Velocity × Velocity, ∀ n : ℕ, | |
| f ((t,p.1),p.2) ≤ ENNReal.ofReal (c*Real.exp C)+ENNReal.ofReal (B*(C^n/(n.factorial:ℝ))) := by | |
| apply ae_all_iff.mpr | |
| intro n | |
| filter_upwards [positiveMain_residual_on_slab hcarleman r s₀ η K α γ d₀ q 0 T N hf | |
| (ENNReal.ofReal c) h n ht] with p hp | |
| exact hp.trans (add_le_add (sum_iterate_const_le_exp hT hC hc J hmass n _ ht) | |
| (iterate_unit_factorial_bound hT hC hB J hmass hfB n _ ht)) | |
| have htend : Tendsto (fun n : ℕ => ENNReal.ofReal (c*Real.exp C)+ | |
| ENNReal.ofReal (B*(C^n/(n.factorial:ℝ)))) atTop (𝓝 (ENNReal.ofReal (c*Real.exp C))) := by | |
| have hh := ENNReal.continuous_ofReal.continuousAt.tendsto.comp | |
| ((FloorSemiring.tendsto_pow_div_factorial_atTop C).const_mul B) | |
| simpa only [Function.comp_def,mul_zero,ENNReal.ofReal_zero,add_zero] using tendsto_const_nhds.add hh | |
| filter_upwards [hall] with p hp | |
| exact le_of_tendsto_of_tendsto' tendsto_const_nhds htend hp | |
| end BoltzmannNonuniqueness.JetCopyDatum | |
| end | |
| end | |
| section | |
| /-! # Positive finite endpoint histories transfer positive seed mass to the hot trace -/ | |
| noncomputable section | |
| open MeasureTheory ProbabilityTheory Set | |
| open scoped ENNReal ProbabilityTheory | |
| namespace BoltzmannNonuniqueness | |
| theorem positive_endpoint_of_pointwise | |
| (K : Kernel (ℝ × WeakTime.Phase) WeakTime.Phase) | |
| (μ ν : Measure WeakTime.Phase) (s : ℝ) {A B : Set WeakTime.Phase} | |
| (hA : MeasurableSet A) (hmass : 0 < μ B) | |
| (hdom : K ∘ₘ WeakTime.phaseSeed s μ ≤ ν) | |
| (hpoint : ∀ p ∈ B, 0 < K (s,p) A) : 0 < ν A := by | |
| have hf : Measurable (fun p : WeakTime.Phase => K (s,p) A) := | |
| (K.measurable_coe hA).comp (by fun_prop) | |
| have hp : 0 < ∫⁻ p, K (s,p) A ∂μ := (lintegral_pos_iff_support hf).mpr | |
| (hmass.trans_le (measure_mono (fun p hp => ne_of_gt (hpoint p hp)))) | |
| have hh := hdom A | |
| rw [Measure.bind_apply hA K.aemeasurable,WeakTime.phaseSeed, | |
| lintegral_map (K.measurable_coe hA) (show Measurable (fun p : WeakTime.Phase => (s,p)) by fun_prop)] at hh | |
| exact hp.trans_le hh | |
| theorem single_endpoint_history_le | |
| (K : Kernel (ℝ × WeakTime.Phase) (ℝ × WeakTime.Phase)) | |
| (L : Kernel (ℝ × WeakTime.Phase) WeakTime.Phase) | |
| (μ : Measure (ℝ × WeakTime.Phase)) (ν : Measure WeakTime.Phase) (N : ℕ) | |
| (hdom : L ∘ₘ (∑ j ∈ Finset.range (N+1), (K^j) ∘ₘ μ) ≤ ν) : | |
| (L ∘ₖ (K^N)) ∘ₘ μ ≤ ν := by | |
| have hterm : (K^N) ∘ₘ μ ≤ ∑ j ∈ Finset.range (N+1), (K^j) ∘ₘ μ := | |
| Finset.single_le_sum (f := fun j : ℕ => (K^j) ∘ₘ μ) (fun j _ => bot_le) (Finset.mem_range.mpr (Nat.lt_succ_self N)) | |
| rw [← Measure.comp_assoc] | |
| exact (KernelHistoryOrder.measure_comp_mono le_rfl hterm).trans hdom | |
| open EuclideanFlight in | |
| theorem covered_hot_positive_history | |
| {f : JetCopyDatum.AttainedCapSequence.HotKineticPhase → ℝ} (hf : ∀ z, 0 ≤ f z) | |
| {β : WeakTime.Phase → ℝ} (hβ₁ : ∀ p, β p ≤ 1) | |
| (a U R s t : ℝ) {A B : Set WeakTime.Phase} (hA : MeasurableSet A) (hB : MeasurableSet B) | |
| (hβ : ∀ p ∈ B, β p = 1) | |
| (hcover : ∀ p ∈ tsupport β, hotCharacteristicEquiv (s,p) ∈ | |
| JetCopyDatum.AttainedCapSequence.coldCylinderSet a U R) | |
| (K : Kernel (ℝ × WeakTime.Phase) (ℝ × WeakTime.Phase)) (C : ℝ) (N : ℕ) | |
| (hmass : 0 < hotPhaseSlice f s B) | |
| (hdom : WeakTime.phaseEndpointKernel C t ∘ₘ | |
| (∑ j ∈ Finset.range (N+1), (K^j) ∘ₘ WeakTime.phaseSeed s | |
| (WeakTime.phaseSlice (WeakTime.phaseWeight β (cylinderPullback a U R f)) s)) ≤ | |
| WeakTime.phaseSlice (WeakTime.phaseWeight β (cylinderPullback a U R f)) t) | |
| (hpoint : ∀ p ∈ B, 0 < (WeakTime.phaseEndpointKernel C t ∘ₖ (K^N)) (s,p) A) : | |
| 0 < hotPhaseSlice f t A := by | |
| have heq := cylinder_phaseSlice_eq_on (f := f) hB hβ hcover | |
| have hm : 0 < WeakTime.phaseSlice (WeakTime.phaseWeight β (cylinderPullback a U R f)) s B := | |
| heq.symm ▸ hmass | |
| exact (positive_endpoint_of_pointwise _ _ _ s hA hm | |
| (single_endpoint_history_le K _ _ _ N hdom) hpoint).trans_le | |
| (cylinder_phaseSlice_le hf hβ₁ a U R t A) | |
| end BoltzmannNonuniqueness | |
| end | |
| end | |
| end OAI | |