| import Mathlib |
| import OAI.Probability.SKFluctuations.FiniteRetainedGridReady |
|
|
| namespace OAI |
|
|
| /-! Clock Power Path Limit. -/ |
|
|
| noncomputable section |
|
|
|
|
| namespace SKFluctuations.Hierarchy |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped Topology NNReal BigOperators |
| variable {S ι : Type*} [Fintype S] [Nonempty S] [Fintype ι] [Nonempty ι] |
| attribute [local instance] Classical.propDecidable |
|
|
| def stepPathPowerDistance (D : ι → ℝ) (q₀ : ι → ℝ≥0) (A B : List (GaussianStep ι)) |
| (q : ℝ → ι → ℝ≥0) (u : ℝ) (l : ℕ) : ℝ := |
| (2*l:ℕ)*clockCoordinateDistance D (stepClockValues (fun i => (q₀ i:ℝ)) A A.length) (fun i => (q u i:ℝ))+ |
| 2*stepPathClockDistance D q₀ (A++B) q+ |
| clockCoordinateDistance D (stepClockValues (fun i => (q₀ i:ℝ)) (A++B) (A++B).length) |
| (fun i => (q 1 i:ℝ)) |
|
|
| theorem stepPowerDisorder_sample_comparison {w : S → ℝ} (hw : ∀ σ, 0<w σ) |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) (D : ι → ℝ) (hD : ∀ i, 0≤D i) |
| (hφ : ∀ σ i, |φ σ (Pi.single i 1)|≤D i) |
| (q₀ : ι → ℝ≥0) (A B : List (GaussianStep ι)) {u : ℝ} |
| (hu : 0≤u) (hA : OrderedSteps 0 A) (hB : OrderedSteps u B) (hAu : ∀ s ∈ A, s.1≤u) |
| (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1)) |
| (as bs : List PositiveMass) (ha : MassOrdered 0 as) (hb : MassOrdered u bs) |
| (hau : ∀ a ∈ as, a.val≤u) (heA : partitionEnd 0 as=u) (hetB : partitionEnd u bs=1) |
| {h : ℝ} (hmesh : PartitionMesh h 0 (as++bs)) |
| (l : ℕ) (P : S → S → ℝ) {K : ℝ} (hK : 0≤K) (hP : ∀ σ τ, |P σ τ|≤K) (x : ι → ℝ) : |
| |stepPowerDisorder w φ q₀ A B P l x-sampledPowerDisorder w φ q u as bs P l x| ≤ |
| ClockTree.errorJetVariation (2*l+1) 0 0*K^l* |
| (stepPathPowerDistance D q₀ A B q u l+2*h*clockVariationBound D q) := by |
| have hoa : MassOrdered 0 (as++bs) := ha.append_end (heA.symm ▸ hb) |
| have ht := stepPowerDisorder_l1_comparison hw φ D hD hφ q₀ (q 0) |
| A B (sampleClockSteps q 0 as) (sampleClockSteps q u bs) hu hA hB |
| (sampleClockSteps_ordered q as ha) (sampleClockSteps_ordered q bs hb) |
| hAu (sampleClockSteps_mass_le q 0 as hau) l P hK hP x |
| rw [sampleClockSteps_terminal q hq 0 as ha,heA] at ht |
| have hAB : sampleClockSteps q 0 as++sampleClockSteps q u bs=sampleClockSteps q 0 (as++bs) := by |
| rw [sampleClockSteps_append,heA] |
| rw [hAB,sampleClockSteps_terminal q hq 0 (as++bs) hoa, |
| partitionEnd_append,heA,hetB] at ht |
| have hfun : stepClockFunction (fun i => (q 0 i:ℝ)) (sampleClockSteps q 0 (as++bs)) = |
| fun u i => partitionSample (fun v => (q v i:ℝ)) 0 (as++bs) u := by |
| funext u i |
| exact sampleClockSteps_function q hq _ hoa u i |
| rw [hfun] at ht |
| apply ht.trans |
| apply mul_le_mul_of_nonneg_left _ (mul_nonneg (ClockTree.errorJetVariation_nonneg (2*l+1) 0 0) (pow_nonneg hK l)) |
| have hh := stepClock_sample_distance D q₀ (A++B) (hA.append_bound hu hAu hB) q hq (as++bs) hoa hmesh |
| dsimp only [stepPathPowerDistance] |
| linarith |
|
|
| theorem stepPowerDisorder_path_comparison {w : S → ℝ} (hw : ∀ σ, 0<w σ) |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) (D : ι → ℝ) (hD : ∀ i, 0≤D i) |
| (hφ : ∀ σ i, |φ σ (Pi.single i 1)|≤D i) |
| (q₀ : ι → ℝ≥0) (A B : List (GaussianStep ι)) (u : PositiveMass) (hu : u.val≤1) |
| (hA : OrderedSteps 0 A) (hB : OrderedSteps u.val B) (hAu : ∀ s ∈ A, s.1≤u.val) |
| (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1)) |
| (l : ℕ) (P : S → S → ℝ) {K : ℝ} (hK : 0≤K) (hP : ∀ σ τ, |P σ τ|≤K) (x : ι → ℝ) : |
| |stepPowerDisorder w φ q₀ A B P l x-pathPowerDisorder w φ q u P l x| ≤ |
| ClockTree.errorJetVariation (2*l+1) 0 0*K^l*stepPathPowerDistance D q₀ A B q u.val l := by |
| have hb (n : ℕ) : |stepPowerDisorder w φ q₀ A B P l x- |
| retainedPowerSample w φ q u (uniformMasses n) P l x| ≤ |
| ClockTree.errorJetVariation (2*l+1) 0 0*K^l* |
| (stepPathPowerDistance D q₀ A B q u.val l+2*((n+1:ℕ):ℝ)⁻¹*clockVariationBound D q) := by |
| have ho := retainedMasses_ordered u hu (uniformMasses n) (uniformMasses_ordered n) |
| exact stepPowerDisorder_sample_comparison hw φ D hD hφ q₀ A B u.property.le hA hB hAu |
| q hq _ _ ho.1 ho.2 (retainedBefore_bounds u _) (retainedBefore_end u _) (retainedAfter_end u _) |
| (retainedMasses_mesh u hu _ (uniformMasses_ordered n) (by positivity) (uniformMasses_mesh n)) l P hK hP x |
| have hl := ((tendsto_const_nhds (x := stepPowerDisorder w φ q₀ A B P l x)).sub (retainedPowerSample_tendsto hw φ D hD hφ q hq u hu l P hK hP x)).abs |
| have hr : Tendsto (fun n : ℕ => ClockTree.errorJetVariation (2*l+1) 0 0*K^l* |
| (stepPathPowerDistance D q₀ A B q u.val l+2*((n+1:ℕ):ℝ)⁻¹*clockVariationBound D q)) atTop |
| (𝓝 (ClockTree.errorJetVariation (2*l+1) 0 0*K^l*stepPathPowerDistance D q₀ A B q u.val l)) := by |
| simpa using (tendsto_const_nhds.add ((uniformMasses_mesh_tendsto.const_mul 2).mul_const |
| (clockVariationBound D q))).const_mul (ClockTree.errorJetVariation (2*l+1) 0 0*K^l) |
| exact le_of_tendsto_of_tendsto hl hr (Eventually.of_forall hb) |
|
|
| theorem stepPowerDisorder_tendsto_path {w : S → ℝ} (hw : ∀ σ, 0<w σ) |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) (D : ι → ℝ) (hD : ∀ i, 0≤D i) |
| (hφ : ∀ σ i, |φ σ (Pi.single i 1)|≤D i) |
| (q₀ : ℕ → ι → ℝ≥0) (A B : ℕ → List (GaussianStep ι)) (u : PositiveMass) (hu : u.val≤1) |
| (hA : ∀ n, OrderedSteps 0 (A n)) (hB : ∀ n, OrderedSteps u.val (B n)) |
| (hAu : ∀ n s, s ∈ A n → s.1≤u.val) |
| (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1)) |
| (l : ℕ) |
| (hpath : Tendsto (fun n => stepPathPowerDistance D (q₀ n) (A n) (B n) q u.val l) atTop (𝓝 0)) |
| (P : S → S → ℝ) {K : ℝ} (hK : 0≤K) (hP : ∀ σ τ, |P σ τ|≤K) (x : ι → ℝ) : |
| Tendsto (fun n => stepPowerDisorder w φ (q₀ n) (A n) (B n) P l x) atTop |
| (𝓝 (pathPowerDisorder w φ q u P l x)) := by |
| rw [tendsto_iff_norm_sub_tendsto_zero] |
| simp only [Real.norm_eq_abs] |
| apply squeeze_zero (fun _ => abs_nonneg _) (fun n => |
| stepPowerDisorder_path_comparison hw φ D hD hφ (q₀ n) (A n) (B n) u hu (hA n) (hB n) (hAu n) q hq l P hK hP x) |
| simpa using hpath.const_mul (ClockTree.errorJetVariation (2*l+1) 0 0*K^l) |
|
|
| end SKFluctuations.Hierarchy |
|
|
| |
|
|
| |
|
|
| namespace SKFluctuations.Hierarchy |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped Topology NNReal BigOperators |
| variable {S ι : Type*} [Fintype S] [Nonempty S] [Fintype ι] [Nonempty ι] |
| attribute [local instance] Classical.propDecidable |
|
|
| def stepPowerMoment (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ) |
| (q₀ : ι → ℝ≥0) (L : List (GaussianStep ι)) (P : S → S → ℝ) (l : ℕ) (u : ℝ) : ℝ := |
| stepPowerDisorder w φ q₀ (splitClockSteps u L).1 (splitClockSteps u L).2 P l 0 |
|
|
| def pathPowerMoment (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ) |
| (q : ℝ → ι → ℝ≥0) (P : S → S → ℝ) (l : ℕ) (u : ℝ) : ℝ := |
| if h : 0<u then pathPowerDisorder w φ q ⟨u,h⟩ P l 0 else 0 |
|
|
| theorem stepPowerMoment_path_comparison {w : S → ℝ} (hw : ∀ σ, 0<w σ) |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) (D : ι → ℝ) (hD : ∀ i, 0≤D i) |
| (hφ : ∀ σ i, |φ σ (Pi.single i 1)|≤D i) |
| (q₀ : ι → ℝ≥0) (L : List (GaussianStep ι)) (hL : OrderedSteps 0 L) |
| (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1)) |
| (l : ℕ) (P : S → S → ℝ) {K : ℝ} (hK : 0≤K) (hP : ∀ σ τ, |P σ τ|≤K) |
| {u : ℝ} (hu : u ∈ Ioc (0:ℝ) 1) : |
| |stepPowerMoment w φ q₀ L P l u-pathPowerMoment w φ q P l u| ≤ |
| ClockTree.errorJetVariation (2*l+1) 0 0*K^l*( |
| (2*l:ℕ)*clockCoordinateDistance D (stepClockFunction (fun i => (q₀ i:ℝ)) L u) |
| (fun i => (q u i:ℝ))+2*stepPathClockDistance D q₀ L q+ |
| clockCoordinateDistance D (stepClockValues (fun i => (q₀ i:ℝ)) L L.length) |
| (fun i => (q 1 i:ℝ))) := by |
| have ho := splitClockSteps_ordered u ⟨hu.1.le,hu.2⟩ L hL hu.1.le |
| rw [stepPowerMoment, pathPowerMoment,dite_eq_left hu.1] |
| have hb := stepPowerDisorder_path_comparison hw φ D hD hφ q₀ |
| (splitClockSteps u L).1 (splitClockSteps u L).2 ⟨u,hu.1⟩ hu.2 |
| ho.1 ho.2.1 ho.2.2 q hq l P hK hP 0 |
| simpa only [stepPathPowerDistance,splitClockSteps_append,←stepClockFunction_split _ _ _ hL] using hb |
|
|
| end SKFluctuations.Hierarchy |
|
|
| |
|
|
| |
|
|
| namespace SKFluctuations.Hierarchy |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped Topology NNReal BigOperators |
| variable {S ι : Type*} [Fintype S] [Nonempty S] [Fintype ι] [Nonempty ι] |
| attribute [local instance] Classical.propDecidable |
|
|
| theorem retainedPowerMoment_tendsto {w : S → ℝ} (hw : ∀ σ, 0<w σ) |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) (D : ι → ℝ) (hD : ∀ i, 0≤D i) |
| (hφ : ∀ σ i, |φ σ (Pi.single i 1)|≤D i) |
| (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1)) |
| (as : ℕ → List PositiveMass) (h : ℕ → ℝ) |
| (ho : ∀ n, MassOrdered 0 (as n)) (hm : ∀ n, PartitionMesh (h n) 0 (as n)) |
| (he : ∀ n, partitionEnd 0 (as n)=1) (hh : Tendsto h atTop (𝓝 0)) |
| (u : PositiveMass) (hu : u.val≤1) (hnode : ∀ n, u ∈ as n) |
| (l : ℕ) (P : S → S → ℝ) {K : ℝ} (hK : 0≤K) (hP : ∀ σ τ, |P σ τ|≤K) : |
| Tendsto (fun n => stepPowerMoment w φ (q 0) (sampleClockSteps q 0 (as n)) |
| P l u.val) |
| atTop (𝓝 (pathPowerMoment w φ q P l u.val)) := by |
| have ht (n : ℕ) : clockCoordinateDistance D |
| (stepClockFunction (fun i => (q 0 i:ℝ)) (sampleClockSteps q 0 (as n)) u.val) |
| (fun i => (q u.val i:ℝ))=0 := by |
| unfold clockCoordinateDistance |
| simp_rw [sampleClockSteps_function q hq _ (ho n),partitionSample_at_node _ _ (ho n) (hnode n)] |
| simp |
| have hl : Tendsto (fun n => stepPathClockDistance D (q 0) |
| (sampleClockSteps q 0 (as n)) q) atTop (𝓝 0) := |
| squeeze_zero (fun _ => stepPathClockDistance_nonneg _ _ _ _) (fun n => |
| sample_stepPathClockDistance_le D q hq _ (ho n) (hm n)) |
| (by simpa using hh.mul_const (clockVariationBound D q)) |
| rw [tendsto_iff_norm_sub_tendsto_zero] |
| simp only [Real.norm_eq_abs] |
| apply squeeze_zero (fun _ => abs_nonneg _) (fun n => stepPowerMoment_path_comparison hw φ D hD hφ |
| (q 0) _ (sampleClockSteps_ordered q _ (ho n)) q hq l P hK hP ⟨u.property,hu⟩) |
| simp_rw [ht,sampleClockSteps_terminal q hq _ _ (ho _),he] |
| simpa [clockCoordinateDistance] using (hl.const_mul 2).const_mul (ClockTree.errorJetVariation (2*l+1) 0 0*K^l) |
|
|
| theorem retainedPowerMoment_tendsto_all {w : S → ℝ} (hw : ∀ σ, 0<w σ) |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) |
| (q : ℝ → ι → ℝ≥0) (hq : ∀ i, MonotoneOn (fun u => q u i) (Icc (0:ℝ) 1)) |
| (as : ℕ → List PositiveMass) (h : ℕ → ℝ) |
| (ho : ∀ n, MassOrdered 0 (as n)) (hm : ∀ n, PartitionMesh (h n) 0 (as n)) |
| (he : ∀ n, partitionEnd 0 (as n)=1) (hh : Tendsto h atTop (𝓝 0)) |
| (u : PositiveMass) (hu : u.val≤1) (hnode : ∀ n, u ∈ as n) (l : ℕ) (P : S → S → ℝ) : |
| Tendsto (fun n => stepPowerMoment w φ (q 0) (sampleClockSteps q 0 (as n)) |
| P l u.val) |
| atTop (𝓝 (pathPowerMoment w φ q P l u.val)) := by |
| let D : ι → ℝ := fun i => ∑ σ, |φ σ (Pi.single i 1)| |
| have hD : ∀ i, 0≤D i := by intro i; exact Finset.sum_nonneg fun σ _ => abs_nonneg _ |
| have hφ : ∀ σ i, |φ σ (Pi.single i 1)|≤D i := by |
| intro σ i |
| exact Finset.single_le_sum (fun τ _ => abs_nonneg (φ τ (Pi.single i 1))) (Finset.mem_univ σ) |
| let K : ℝ := ∑ σ, ∑ τ, |P σ τ| |
| have hK : 0≤K := by dsimp [K]; positivity |
| have hP (σ τ : S) : |P σ τ|≤K := by |
| exact (Finset.single_le_sum (fun ρ _ => abs_nonneg (P σ ρ)) (Finset.mem_univ τ)).trans |
| (Finset.single_le_sum (fun ρ _ => Finset.sum_nonneg fun η _ => abs_nonneg (P ρ η)) (Finset.mem_univ σ)) |
| exact retainedPowerMoment_tendsto hw φ D hD hφ q hq as h ho hm he hh u hu hnode l P hK hP |
|
|
| end SKFluctuations.Hierarchy |
|
|
| |
|
|
| |
|
|
| namespace SKFluctuations |
| open MeasureTheory ProbabilityTheory Filter Set Hierarchy |
| open scoped Topology NNReal BigOperators |
|
|
| def physicalPathPowerMoment (n l : ℕ) (steps : List (GaussianStep (FeatureIndex n))) |
| (q₀ : FeatureIndex n → ℝ≥0) (j : ℕ) : ℝ := |
| ∫ p, ‖actualSpinPath n steps id j p‖^(2*l) |
| ∂rootedHierarchyPathLaw (uniformWeight n) (finiteFeature n) q₀ steps |
|
|
| theorem physicalPowerMoment_eq_stepPowerMoment (n l : ℕ) (hn : 0<n) |
| (steps : List (GaussianStep (FeatureIndex n))) (ha : OrderedSteps 0 steps) |
| (q₀ : FeatureIndex n → ℝ≥0) (u : ℝ) : |
| physicalPathPowerMoment n l steps q₀ (splitClockSteps u steps).1.length= |
| stepPowerMoment (uniformWeight n) (finiteFeature n) q₀ steps (orderedOverlap n) l u := by |
| let : NeZero n := ⟨Nat.ne_of_gt hn⟩ |
| have ho : OrderedSteps 0 ((splitClockSteps u steps).1++(splitClockSteps u steps).2) := by |
| simpa only [splitClockSteps_append] using ha |
| have he := physicalPowerMoment_eq_stepPowerDisorder n l (splitClockSteps u steps).1 |
| (splitClockSteps u steps).2 ho q₀ |
| change physicalPathPowerMoment n l ((splitClockSteps u steps).1++(splitClockSteps u steps).2) |
| q₀ (splitClockSteps u steps).1.length = _ at he |
| rw [splitClockSteps_append] at he |
| exact he |
|
|
| theorem physicalRetainedPowerMoment_tendsto (n l : ℕ) (hn : 0<n) |
| (b h : ℝ → ℝ≥0) (hb : MonotoneOn b (Icc (0:ℝ) 1)) (hh : MonotoneOn h (Icc (0:ℝ) 1)) |
| (as : ℕ → List PositiveMass) (mesh : ℕ → ℝ) |
| (ho : ∀ k, MassOrdered 0 (as k)) (hm : ∀ k, PartitionMesh (mesh k) 0 (as k)) |
| (he : ∀ k, partitionEnd 0 (as k)=1) (hmesh : Tendsto mesh atTop (𝓝 0)) |
| (u : PositiveMass) (hu : u.val≤1) (hnode : ∀ k, u ∈ as k) : |
| let q := completedPathClock n b h |
| Tendsto (fun k => let steps := sampleClockSteps q 0 (as k) |
| physicalPathPowerMoment n l steps (q 0) (splitClockSteps u.val steps).1.length) |
| atTop (𝓝 (pathPowerMoment (uniformWeight n) (finiteFeature n) q (orderedOverlap n) l u.val)) := by |
| let : NeZero n := ⟨Nat.ne_of_gt hn⟩ |
| dsimp only |
| simp_rw [physicalPowerMoment_eq_stepPowerMoment n l hn _ (sampleClockSteps_ordered _ _ (ho _))] |
| exact retainedPowerMoment_tendsto_all (uniformWeight_pos n) (finiteFeature n) (completedPathClock n b h) |
| (completedPathClock_monotone n hb hh) as mesh ho hm he hmesh u hu hnode l (orderedOverlap n) |
|
|
| end SKFluctuations |
|
|
| |
|
|
| namespace SKFluctuations |
| open MeasureTheory ProbabilityTheory Filter Set Hierarchy |
| open scoped Topology NNReal ENNReal BigOperators |
|
|
| theorem eventually_physical_band_window (k : ℕ) (B : ℝ) : |
| ∀ᶠ n : ℕ in atTop, ∀ (P : Type) [MeasurableSpace P] |
| (steps : List (GaussianStep (FeatureIndex n))) (_ha : OrderedSteps 0 steps) |
| (xs : ℝ) (_hxs : 0 < xs) (w : PhysicalBandWindow n steps xs) |
| (μ : Measure P) [IsProbabilityMeasure μ] (x : P → FeatureIndex n → ℝ) (hx : Measurable x) |
| (d : GaussianStep (FeatureIndex n) → ℝ≥0), |
| (∀ st ∈ steps, ∀ i : Fin n, st.2 (Sum.inl i) = d st) → |
| physicalFieldDuration d steps ≤ B → |
| (∀ s ∈ Ioc w.a w.b, w.D₀ ≤ |
| physicalFieldDuration d (steps.take (radiusGridCut w.radius (s+w.η))) - |
| physicalFieldDuration d (steps.take (radiusGridCut w.radius s))) → |
| (∀ r ∈ Icc (2*w.a) ((2:ℝ)^w.depth*w.b), w.D₀ ≤ |
| physicalFieldDuration d (steps.take (radiusGridCut w.radius r)) - |
| physicalFieldDuration d (steps.take (radiusGridCut w.radius (3*r/4)))) → |
| (∫ p, (physicalSusceptibilityMassIntegral n steps x w.measure (radiusGridCut w.radius) p)^(k+1) |
| ∂physicalPathLaw μ n steps x hx)^(((k+1:ℕ):ℝ)⁻¹) ≤ |
| w.coefficient k*(physicalRawRatio n (k+1) steps 0 xs μ x hx)^4 := by |
| filter_upwards [eventually_physical_dyadic_band k B] with n hn |
| intro P _ steps ha xs hxs w μ _ x hx d hd hB hfirst hdyad |
| have hh := hn P steps 0 w.c₀ xs w.D₀ w.C w.R w.F ha w.c₀_pos hxs w.D₀_pos |
| w.C_nonneg w.R_pos w.F_mass w.F_radius μ x hx (radiusGridCut w.radius) |
| (radiusGridCut_monotone w.radius) (radiusGridCut_le w.radius) |
| w.a w.b w.η w.xa w.ab w.η_pos w.η_le w.depth w.depth_pos w.last_radius |
| w.measure w.A w.A_nonneg w.measure_cap d hd hB w.mass_comparable hfirst hdyad |
| rw [w.measure_mass ha] at hh |
| let Q := physicalRawRatio n (k+1) steps 0 xs μ x hx |
| have hQ : 1 ≤ Q := physicalRawRatio_one_le n (k+1) steps 0 xs μ x hx |
| have h24 : Q^2 ≤ Q^4 := by nlinarith [sq_nonneg (Q^2-1)] |
| have hfar : 0 ≤ w.mass*w.farCoefficient k := |
| mul_nonneg w.mass_pos.le (w.farCoefficient_nonneg k) |
| calc |
| _ ≤ (w.depth+3:ℕ)^3*(w.nearCoefficient k*Q^4 + |
| w.mass*w.farCoefficient k*Q^2) := by |
| convert hh using 1; dsimp [PhysicalBandWindow.nearCoefficient,PhysicalBandWindow.farCoefficient]; ring |
| _ ≤ (w.depth+3:ℕ)^3*(w.nearCoefficient k*Q^4 + |
| w.mass*w.farCoefficient k*Q^4) := by |
| exact mul_le_mul_of_nonneg_left (add_le_add_right (mul_le_mul_of_nonneg_left h24 hfar) _) (by positivity) |
| _ = _ := by unfold PhysicalBandWindow.coefficient; ring |
|
|
| end SKFluctuations |
|
|
| |
|
|
| namespace SKFluctuations |
| open MeasureTheory ProbabilityTheory Filter Set Hierarchy |
| open scoped Topology NNReal ENNReal BigOperators |
|
|
| theorem physical_window_bound_of_energy (n k : ℕ) |
| (steps : List (GaussianStep (FeatureIndex n))) (ha : OrderedSteps 0 steps) |
| (q₀ : FeatureIndex n → ℝ≥0) {xs : ℝ} (hxs : 0 < xs) |
| (w : PhysicalBandWindow n steps xs) {i : ℕ} (hi : ∀ j ∈ w.selected, i ≤ j.val) |
| {M Q : ℝ} |
| (hS : ∀ j ∈ w.selected, (∫ z, ‖actualSpinPath n steps id j.val z‖^2 |
| ∂rootedHierarchyPathLaw (uniformWeight n) (finiteFeature n) q₀ steps) ≤ M) |
| (hE : (∫ z, (physicalSusceptibilityMassIntegral n steps id w.measure |
| (radiusGridCut w.radius) z)^(k+1) |
| ∂rootedHierarchyPathLaw (uniformWeight n) (finiteFeature n) q₀ steps)^(((k+1:ℕ):ℝ)⁻¹) ≤ |
| w.coefficient k*Q^4) : |
| ((∫ z, ‖actualSpinPath n steps id i z‖^(4*(k+1)) |
| ∂rootedHierarchyPathLaw (uniformWeight n) (finiteFeature n) q₀ steps)^(((4*(k+1):ℕ):ℝ)⁻¹))^2 ≤ |
| M+w.loss k*Q^2 := by |
| have hh := physical_raw_window_bound n (k+1) (by omega) steps ha q₀ w.selected w.mass_pos |
| w.radius w.radius_mono w.cell_pos hi hS |
| dsimp only at hh |
| change _ ≤ M+2*Real.sqrt ((1+(2*((k+1:ℕ):ℝ))^2/3)*w.mass⁻¹^2* |
| (∫ z, (physicalSusceptibilityMassIntegral n steps id w.measure (radiusGridCut w.radius) z)^(k+1) |
| ∂rootedHierarchyPathLaw (uniformWeight n) (finiteFeature n) q₀ steps)^(((k+1:ℕ):ℝ)⁻¹)) at hh |
| have hpos : 0 ≤ (1+(2*((k+1:ℕ):ℝ))^2/3)*w.mass⁻¹^2 := by positivity |
| have hs := Real.sqrt_le_sqrt (mul_le_mul_of_nonneg_left hE hpos) |
| have hroot : Real.sqrt ((1+(2*((k+1:ℕ):ℝ))^2/3)*w.mass⁻¹^2*(w.coefficient k*Q^4)) = |
| Real.sqrt ((1+(2*((k+1:ℕ):ℝ))^2/3)*w.mass⁻¹^2*w.coefficient k)*Q^2 := by |
| rw [← mul_assoc,Real.sqrt_mul (mul_nonneg hpos (w.coefficient_nonneg hxs k))] |
| congr 1 |
| rw [show Q^4=(Q^2)^2 by ring,Real.sqrt_sq (sq_nonneg Q)] |
| rw [hroot] at hs |
| calc |
| _ ≤ M+2*Real.sqrt ((1+(2*((k+1:ℕ):ℝ))^2/3)*w.mass⁻¹^2* |
| (∫ z, (physicalSusceptibilityMassIntegral n steps id w.measure (radiusGridCut w.radius) z)^(k+1) |
| ∂rootedHierarchyPathLaw (uniformWeight n) (finiteFeature n) q₀ steps)^(((k+1:ℕ):ℝ)⁻¹)) := hh |
| _ ≤ M+2*(Real.sqrt ((1+(2*((k+1:ℕ):ℝ))^2/3)*w.mass⁻¹^2*w.coefficient k)*Q^2) := by linarith |
| _ = _ := by unfold PhysicalBandWindow.loss; push_cast; ring |
|
|
| end SKFluctuations |
|
|
| |
|
|
| |
|
|
| namespace SKFluctuations |
| open MeasureTheory ProbabilityTheory Filter Set Hierarchy |
| open scoped Topology NNReal ENNReal BigOperators |
|
|
| theorem physicalRawRatio_close (n l : ℕ) |
| (steps : List (GaussianStep (FeatureIndex n))) (ha : OrderedSteps 0 steps) |
| {xs C : ℝ} (hxs : 0 < xs) (hC : 1 ≤ C) |
| {P : Type} [MeasurableSpace P] (μ : Measure P) |
| (x : P → FeatureIndex n → ℝ) (hx : Measurable x) |
| (h : ∀ i ≤ steps.length+1, |
| ((∫ p, ‖actualSpinPath n steps x i p‖^(4*l) ∂physicalPathLaw μ n steps x hx) |
| ^(((4*l:ℕ):ℝ)⁻¹))^2 ≤ |
| C*(xs+physicalCutMass 0 steps i)+ |
| (physicalRawRatio n l steps 0 xs μ x hx)^2/2*(xs+physicalCutMass 0 steps i)) : |
| (physicalRawRatio n l steps 0 xs μ x hx)^2 ≤ 2*C := by |
| let f : ℕ → ℝ := fun i => |
| (∫ p, ‖actualSpinPath n steps x i p‖^(4*l) ∂physicalPathLaw μ n steps x hx) |
| ^(((4*l:ℕ):ℝ)⁻¹)/Real.sqrt (xs+physicalCutMass 0 steps i) |
| let S := (Finset.range (steps.length+2)).sup' (by simp) f |
| by_cases hS : S ≤ 1 |
| · have hQ : physicalRawRatio n l steps 0 xs μ x hx = 1 := max_eq_left hS |
| rw [hQ]; nlinarith |
| · obtain ⟨i,hi,hei⟩ := Finset.exists_mem_eq_sup' (s := Finset.range (steps.length+2)) (by simp) f |
| have hi' : i ≤ steps.length+1 := by have hh := Finset.mem_range.mp hi; omega |
| have hQ : physicalRawRatio n l steps 0 xs μ x hx = f i := by |
| change max 1 S = f i |
| rw [max_eq_right (le_of_not_ge hS)] |
| exact hei |
| have hs : 0 < xs+physicalCutMass 0 steps i := |
| add_pos_of_pos_of_nonneg hxs (physicalCutMass_mem steps ha i).1 |
| have hh := h i hi' |
| have hf : (f i)^2 = |
| ((∫ p, ‖actualSpinPath n steps x i p‖^(4*l) ∂physicalPathLaw μ n steps x hx) |
| ^(((4*l:ℕ):ℝ)⁻¹))^2/(xs+physicalCutMass 0 steps i) := by |
| dsimp [f] |
| rw [div_pow,Real.sq_sqrt hs.le] |
| have hiB : (physicalRawRatio n l steps 0 xs μ x hx)^2 ≤ |
| C+(physicalRawRatio n l steps 0 xs μ x hx)^2/2 := by |
| conv_lhs => rw [hQ,hf] |
| apply (div_le_iff₀ hs).2 |
| nlinarith |
| nlinarith |
|
|
| end SKFluctuations |
|
|
| |
|
|
| |
|
|
| namespace SKFluctuations |
| open MeasureTheory ProbabilityTheory Filter Set Hierarchy |
| open scoped Topology NNReal ENNReal BigOperators |
|
|
| theorem physical_moment_le_one (n l : ℕ) |
| (steps : List (GaussianStep (FeatureIndex n))) (ha : OrderedSteps 0 steps) |
| (q₀ : FeatureIndex n → ℝ≥0) (i : ℕ) : |
| (∫ z, ‖actualSpinPath n steps id i z‖^(4*l) |
| ∂rootedHierarchyPathLaw (uniformWeight n) (finiteFeature n) q₀ steps)^(((4*l:ℕ):ℝ)⁻¹) ≤ 1 := by |
| rw [rootedHierarchyPathLaw_eq_physical] |
| let μ := Measure.pi fun j => gaussianReal 0 (q₀ j) |
| have := hierarchyPathKernel_markov (uniformWeight_pos n) (finiteFeature n) steps ha |
| let : IsProbabilityMeasure (physicalPathLaw μ n steps id measurable_id) := by |
| unfold physicalPathLaw |
| infer_instance |
| have hI : (∫ z, ‖actualSpinPath n steps id i z‖^(4*l) |
| ∂physicalPathLaw μ n steps id measurable_id) ≤ 1 := by |
| calc |
| _ ≤ ∫ _, (1:ℝ) ∂physicalPathLaw μ n steps id measurable_id := by |
| apply integral_mono (physicalCutNormPower_integrable n steps ha μ id measurable_id i (4*l)) (integrable_const 1) |
| intro z |
| exact (pow_le_pow_left₀ (norm_nonneg _) (actualSpinPath_norm_le n steps ha id i z) _).trans_eq (one_pow _) |
| _ = 1 := by simp |
| exact (Real.rpow_le_rpow (integral_nonneg fun z => pow_nonneg (norm_nonneg _) _) hI (by positivity)).trans_eq (by simp) |
|
|
| theorem eventually_physical_raw_bootstrap (k : ℕ) (B : ℝ) : |
| ∀ᶠ n : ℕ in atTop, ∀ (steps : List (GaussianStep (FeatureIndex n))) |
| (_ha : OrderedSteps 0 steps) (q₀ : FeatureIndex n → ℝ≥0) (xs C : ℝ) |
| (_hxs : 0 < xs) (_hC : 1 ≤ C) |
| (d : GaussianStep (FeatureIndex n) → ℝ≥0), |
| (∀ st ∈ steps, ∀ i : Fin n, st.2 (Sum.inl i) = d st) → |
| physicalFieldDuration d steps ≤ B → |
| (∀ i ≤ steps.length+1, 1 ≤ C*(xs+physicalCutMass 0 steps i) ∨ |
| ∃ w : PhysicalBandWindow n steps xs, |
| (∀ j ∈ w.selected, i ≤ j.val) ∧ |
| (∀ j ∈ w.selected, (∫ z, ‖actualSpinPath n steps id j.val z‖^2 |
| ∂rootedHierarchyPathLaw (uniformWeight n) (finiteFeature n) q₀ steps) ≤ |
| C*(xs+physicalCutMass 0 steps i)) ∧ |
| w.loss k ≤ (xs+physicalCutMass 0 steps i)/2 ∧ |
| (∀ s ∈ Ioc w.a w.b, w.D₀ ≤ |
| physicalFieldDuration d (steps.take (radiusGridCut w.radius (s+w.η))) - |
| physicalFieldDuration d (steps.take (radiusGridCut w.radius s))) ∧ |
| (∀ r ∈ Icc (2*w.a) ((2:ℝ)^w.depth*w.b), w.D₀ ≤ |
| physicalFieldDuration d (steps.take (radiusGridCut w.radius r)) - |
| physicalFieldDuration d (steps.take (radiusGridCut w.radius (3*r/4))))) → |
| (physicalRawRatio n (k+1) steps 0 xs (Measure.pi fun j => gaussianReal 0 (q₀ j)) id measurable_id)^2 ≤ 2*C := by |
| filter_upwards [eventually_physical_band_window k B] with n hn |
| intro steps ha q₀ xs C hxs hC d hd hB hcover |
| let μ := Measure.pi fun j => gaussianReal 0 (q₀ j) |
| let Q := physicalRawRatio n (k+1) steps 0 xs μ id measurable_id |
| apply physicalRawRatio_close n (k+1) steps ha hxs hC μ id measurable_id |
| intro i hi |
| rcases hcover i hi with hlarge | ⟨w,hw,hS,hloss,hfirst,hdyad⟩ |
| · have hh := physical_moment_le_one n (k+1) steps ha q₀ i |
| rw [rootedHierarchyPathLaw_eq_physical] at hh |
| have h0 : 0 ≤ (∫ z, ‖actualSpinPath n steps id i z‖^(4*(k+1)) |
| ∂physicalPathLaw μ n steps id measurable_id)^(((4*(k+1):ℕ):ℝ)⁻¹) := by positivity |
| have hscale : 0 ≤ xs+physicalCutMass 0 steps i := |
| add_nonneg hxs.le (physicalCutMass_mem steps ha i).1 |
| have heps : 0 ≤ Q^2/2*(xs+physicalCutMass 0 steps i) := by positivity |
| dsimp [μ] at h0 |
| change _ ≤ C*(xs+physicalCutMass 0 steps i)+Q^2/2*(xs+physicalCutMass 0 steps i) |
| nlinarith |
| · have he := hn (FeatureIndex n → ℝ) steps ha xs hxs w μ id measurable_id d hd hB hfirst hdyad |
| rw [← rootedHierarchyPathLaw_eq_physical] at he |
| have hh := physical_window_bound_of_energy n k steps ha q₀ hxs w hw hS he |
| rw [rootedHierarchyPathLaw_eq_physical] at hh |
| have heps := mul_le_mul_of_nonneg_right hloss (sq_nonneg Q) |
| change _ ≤ C*(xs+physicalCutMass 0 steps i)+Q^2/2*(xs+physicalCutMass 0 steps i) |
| exact hh.trans (by nlinarith) |
|
|
| end SKFluctuations |
|
|
| |
|
|
| |
|
|
| namespace SKFluctuations |
| open MeasureTheory ProbabilityTheory Filter Set Hierarchy |
| open scoped Topology NNReal ENNReal BigOperators |
|
|
| def PhysicalRawWindowCover (n k : ℕ) (steps : List (GaussianStep (FeatureIndex n))) |
| (q₀ : FeatureIndex n → ℝ≥0) (xs C B : ℝ) : Prop := |
| ∃ d : GaussianStep (FeatureIndex n) → ℝ≥0, |
| (∀ st ∈ steps, ∀ i : Fin n, st.2 (Sum.inl i) = d st) ∧ |
| physicalFieldDuration d steps ≤ B ∧ |
| (∀ i ≤ steps.length+1, 1 ≤ C*(xs+physicalCutMass 0 steps i) ∨ |
| ∃ w : PhysicalBandWindow n steps xs, |
| (∀ j ∈ w.selected, i ≤ j.val) ∧ |
| (∀ j ∈ w.selected, (∫ z, ‖actualSpinPath n steps id j.val z‖^2 |
| ∂rootedHierarchyPathLaw (uniformWeight n) (finiteFeature n) q₀ steps) ≤ |
| C*(xs+physicalCutMass 0 steps i)) ∧ |
| w.loss k ≤ (xs+physicalCutMass 0 steps i)/2 ∧ |
| (∀ s ∈ Ioc w.a w.b, w.D₀ ≤ |
| physicalFieldDuration d (steps.take (radiusGridCut w.radius (s+w.η))) - |
| physicalFieldDuration d (steps.take (radiusGridCut w.radius s))) ∧ |
| (∀ r ∈ Icc (2*w.a) ((2:ℝ)^w.depth*w.b), w.D₀ ≤ |
| physicalFieldDuration d (steps.take (radiusGridCut w.radius r)) - |
| physicalFieldDuration d (steps.take (radiusGridCut w.radius (3*r/4))))) |
|
|
| theorem physicalPathPowerMoment_le_of_rawRatio (n l : ℕ) (hl : 0<l) |
| (steps : List (GaussianStep (FeatureIndex n))) (ha : OrderedSteps 0 steps) |
| (q₀ : FeatureIndex n → ℝ≥0) {xs C : ℝ} (hxs : 0<xs) |
| (hQ : (physicalRawRatio n l steps 0 xs (Measure.pi fun i => gaussianReal 0 (q₀ i)) id measurable_id)^2≤2*C) |
| (j : ℕ) (hj : j ≤ steps.length+1) : |
| physicalPathPowerMoment n (2*l) steps q₀ j ≤ (2*C*(xs+physicalCutMass 0 steps j))^(2*l) := by |
| have hbound := physicalRawRatio_moment n l hl steps ha hxs |
| (Measure.pi fun i => gaussianReal 0 (q₀ i)) id measurable_id hj |
| rw [←rootedHierarchyPathLaw_eq_physical] at hbound |
| have hpow := pow_le_pow_left₀ (sq_nonneg _) hQ (2*l) |
| rw [←pow_mul,show 2*(2*l)=4*l by omega] at hpow |
| have hmul := mul_le_mul_of_nonneg_right hpow |
| (pow_nonneg (add_nonneg hxs.le (physicalCutMass_mem steps ha j).1) (2*l)) |
| unfold physicalPathPowerMoment |
| rw [show 2*(2*l)=4*l by omega,mul_pow] |
| exact hbound.trans hmul |
|
|
| theorem eventually_physical_path_raw_bootstrap (k : ℕ) (B : ℝ) : |
| ∀ᶠ n : ℕ in atTop, ∀ (b h : ℝ → ℝ≥0) |
| (_hb : MonotoneOn b (Icc (0:ℝ) 1)) (_hh : MonotoneOn h (Icc (0:ℝ) 1)) |
| (as : ℕ → List PositiveMass) (mesh : ℕ → ℝ) |
| (_ho : ∀ j, MassOrdered 0 (as j)) (_hm : ∀ j, PartitionMesh (mesh j) 0 (as j)) |
| (_he : ∀ j, partitionEnd 0 (as j)=1) (_hmesh : Tendsto mesh atTop (𝓝 0)) |
| (xs C : ℝ) (_hxs : 0<xs) (_hC : 1≤C) |
| (u : PositiveMass) (_hu : u.val≤1) (_hnode : ∀ j, u ∈ as j), |
| (∀ᶠ j : ℕ in atTop, PhysicalRawWindowCover n k |
| (sampleClockSteps (completedPathClock n b h) 0 (as j)) |
| (completedPathClock n b h 0) xs C B) → |
| pathPowerMoment (uniformWeight n) (finiteFeature n) (completedPathClock n b h) |
| (orderedOverlap n) (2*(k+1)) u.val ≤ (2*C*(xs+u.val))^(2*(k+1)) := by |
| filter_upwards [eventually_physical_raw_bootstrap k B,eventually_ge_atTop 1] with n hn hnpos |
| intro b h hb hh as mesh ho hm he hmesh xs C hxs hC u hu hnode hcover |
| have hn0 : 0<n := by omega |
| have ht := physicalRetainedPowerMoment_tendsto n (2*(k+1)) hn0 b h hb hh as mesh |
| ho hm he hmesh u hu hnode |
| apply le_of_tendsto ht |
| filter_upwards [hcover] with j hj |
| obtain ⟨d,hd,hB,hcovers⟩ := hj |
| let q := completedPathClock n b h |
| let steps := sampleClockSteps q 0 (as j) |
| have hs := sampleClockSteps_ordered q (as j) (ho j) |
| have hQ := hn steps hs (q 0) xs C hxs hC d hd hB hcovers |
| have hjlen : (splitClockSteps u.val steps).1.length ≤ steps.length+1 := |
| (splitClockSteps_length_le steps u.val).trans (Nat.le_succ _) |
| have hh := physicalPathPowerMoment_le_of_rawRatio n (k+1) (by omega) steps hs (q 0) hxs hQ _ hjlen |
| rw [sampled_retained_mass q (as j) (ho j) u (hnode j)] at hh |
| exact hh |
|
|
| end SKFluctuations |
|
|
| |
|
|
| |
|
|
| namespace SKFluctuations |
| open MeasureTheory ProbabilityTheory Filter Set Hierarchy |
| open scoped Topology NNReal |
|
|
| theorem eventually_physicalRetainedBand (n : ℕ) (hn : 0<n) |
| (b h : ℝ → ℝ≥0) (hb : MonotoneOn b (Icc (0:ℝ) 1)) (hh : MonotoneOn h (Icc (0:ℝ) 1)) |
| (us : List PositiveMass) (hus : ∀ u ∈ us, u.val≤1) |
| {r₀ u₀ c : ℝ} {k M : ℝ → ℝ} |
| (hr : r₀≤1) (hu : u₀≤1) (hu₀ : 0≤u₀) (hc : 0<c) |
| (hk : ContinuousOn k (Icc r₀ 1)) (hkc : ∀ t ∈ Icc r₀ 1, c≤k t) |
| (hm : MonotoneOn M (Icc (0:ℝ) 1)) (hM : ∀ u ∈ Icc (0:ℝ) 1, 0≤M u) |
| (α : inverseIntegralConstraints r₀ u₀ k M) |
| (p q : PositiveMass) (hpu : p ∈ us) (hqu : q ∈ us) |
| (hp₀ : u₀≤p.val) (hq₁ : q.val≤1) (hpq : p.val<q.val) |
| (xs η cl cu R F κ K Ca v C : ℝ) (J ℓ : ℕ) (e : ℝ → ℝ) |
| (hxs : 0<xs) (hcl : 0<cl) (hcu : 0≤cu) (hR : 0<R) |
| (hκ : 0<κ) (hK : 1≤K) (hCa : 0<Ca) (hC : 0≤C) |
| (hFmass : 1+2*cu≤F) (hFradius : 1+1/R≤F) (hJ : 1≤J) |
| (hmean : orderedPathS n b h q.val<C*v) : |
| let hM₁ := hM 1 (by norm_num) |
| let a := (constrainedQuantile hr hc hk hkc hm hM₁ α ⟨p.val,hp₀,hpq.le.trans hq₁⟩).val |
| let ab := (constrainedQuantile hr hc hk hkc hm hM₁ α ⟨q.val,hp₀.trans hpq.le,hq₁⟩).val |
| let T := (2:ℝ)^J*ab |
| let L := 8*(K+1)/κ |
| xs≤a → a≤Ca*v → ab≤K*a → cl*a≤q.val-p.val → q.val-p.val≤K*cu*a → |
| 0<M q.val → 0<e a → 0<η → η≤a → r₀<a/2 → |
| η=(1/Real.sqrt (M q.val*((n:ℝ)*e a*a^4)))*a → |
| T≤1 → R≤(2:ℝ)^J*a → |
| (∀ t ∈ Icc (a/2) T, cl*t≤α.val.val t ∧ α.val.val t≤cu*t) → |
| (∀ t ∈ Icc (a/2) T, 0≤e t) → AntitoneOn e (Icc (a/2) T) → |
| MonotoneOn (fun t => t*e t) (Icc (a/2) T) → |
| (∀ z ∈ Icc (a/2) T, ∀ t ∈ Icc (a/2) T, z≤t → |
| κ*e t*(t-z)≤(h (α.val.val t):ℝ)-(h (α.val.val z):ℝ)) → |
| ((J+3:ℕ):ℝ)^3*(4*(K+1)*cu*nearPairMomentConstant (ℓ+1)^(((ℓ+1:ℕ):ℝ)⁻¹)* |
| (1+(K+1)*cu)^2 + |
| 4*K*cu*(projectionLpConstant ℓ)^2*(Real.log (n:ℝ))^4*(F^2/((cl/2)/4)^2)*L)* |
| Real.sqrt (M q.val/((n:ℝ)*e a*a^4)) ≤ |
| (cl/(4*Ca))^2/(1+(2*(ℓ+1:ℕ):ℝ)^2/3) → |
| ∀ᶠ j : ℕ in atTop, |
| let steps := sampleClockSteps (completedPathClock n b h) 0 (finiteCutMasses us j) |
| let d := fun st : GaussianStep (FeatureIndex n) => st.2 (Sum.inl ⟨0,hn⟩) |
| ∀ i : ℕ, v≤xs+physicalCutMass 0 steps i → physicalCutMass 0 steps i<p.val → |
| ∃ w : PhysicalBandWindow n steps xs, |
| (∀ z ∈ w.selected, i≤z.val) ∧ |
| (∀ z ∈ w.selected, (∫ t, ‖actualSpinPath n steps id z.val t‖^2 |
| ∂rootedHierarchyPathLaw (uniformWeight n) (finiteFeature n) |
| (completedPathClock n b h 0) steps) ≤ C*(xs+physicalCutMass 0 steps i)) ∧ |
| w.loss ℓ≤(xs+physicalCutMass 0 steps i)/2 ∧ |
| (∀ s ∈ Ioc w.a w.b, w.D₀≤ |
| physicalFieldDuration d (steps.take (radiusGridCut w.radius (s+w.η)))- |
| physicalFieldDuration d (steps.take (radiusGridCut w.radius s))) ∧ |
| (∀ s ∈ Icc (2*w.a) ((2:ℝ)^w.depth*w.b), w.D₀≤ |
| physicalFieldDuration d (steps.take (radiusGridCut w.radius s))- |
| physicalFieldDuration d (steps.take (radiusGridCut w.radius (3*s/4)))) := by |
| dsimp only |
| intro hxa hav hba hmasslo hmasshi hA hea hη hηa hr₀ hηeq hT hRJ hreg he hem her hH hmargin |
| let hM₁ := hM 1 (by norm_num) |
| have hmesh : ∀ᶠ j : ℕ in atTop, (((j+1:ℕ):ℝ)⁻¹)/c≤η/8 := by |
| have ht : Tendsto (fun j : ℕ => (((j+1:ℕ):ℝ)⁻¹)/c) atTop (𝓝 0) := by |
| simpa using (uniformMasses_mesh_tendsto.div_const c) |
| exact (ht.eventually (gt_mem_nhds (show (0:ℝ)<η/8 by positivity))).mono |
| (fun j hj => hj.le) |
| have hmeans := physicalRetainedSecondMoment_eventually_uniform n hn b h hb hh |
| (finiteCutMasses us) (fun j => (((j+1:ℕ):ℝ)⁻¹)) |
| (finiteCutMasses_ordered us hus) (finiteCutMasses_mesh us hus) |
| (finiteCutMasses_end us hus) uniformMasses_mesh_tendsto q hq₁ |
| (fun j => finiteCutMasses_nodes us j hqu) hmean |
| filter_upwards [hmesh,hmeans] with j hj hmeanj |
| dsimp only at hmeanj ⊢ |
| let as := finiteCutMasses us j |
| let has := finiteCutMasses_ordered us hus j |
| let steps := sampleClockSteps (completedPathClock n b h) 0 as |
| let hs := sampleClockSteps_ordered (completedPathClock n b h) as has |
| have hgm : ∀ z : Fin (steps.length+1), |
| physicalQuantileGrid hr hu hc hk hkc hm hM₁ α steps hs z.succ- |
| physicalQuantileGrid hr hu hc hk hkc hm hM₁ α steps hs z.castSucc≤η/8 := by |
| intro z |
| exact (physicalQuantileGrid_mesh hr hu hc hk hkc hm hM₁ α steps hs |
| (sampled_physicalMass_mesh _ _ (finiteCutMasses_mesh us hus j)) z).trans hj |
| obtain ⟨w,hws,hwa,hwb,hwm,hwA,hloss,hclock₀,hclock₁⟩ := |
| physicalReadyRetainedWindow n hn b h hb hh as has hr hu hu₀ hc hk hkc hm hM α p q |
| (finiteCutMasses_nodes us j hpu) (finiteCutMasses_nodes us j hqu) hp₀ hq₁ hpq |
| xs η cl cu R F (η/8) κ K Ca v J ℓ e hxs hcl hcu hR hκ hK hCa hFmass hFradius hJ |
| (by positivity) hgm hxa hav hba hmasslo hmasshi hA hea hη hηa le_rfl hr₀ hηeq hT hRJ |
| hreg he hem her hH hmargin |
| intro i hiv hip |
| have hmn : ∀ z≤(physicalRetainedIndex steps q.val).val, |
| physicalPathSecondMoment n steps (completedPathClock n b h 0) z≤C*v := by |
| intro z hz |
| exact (hmeanj z hz).le |
| obtain ⟨hfut,hmns⟩ := retainedWindow_future_means n (completedPathClock n b h) as has p q |
| (finiteCutMasses_nodes us j hpu) i hip hmn |
| refine ⟨w,?_,?_,?_,hclock₀,hclock₁⟩ |
| · rwa [hws] |
| · intro z hz |
| rw [hws] at hz |
| exact (hmns z hz).trans (mul_le_mul_of_nonneg_left hiv hC) |
| · exact hloss.trans (div_le_div_of_nonneg_right hiv (by norm_num)) |
|
|
| end SKFluctuations |
|
|
| end |
|
|
| end OAI |
|
|
