Download data/lean/OAI/Probability/SKFluctuations/ClockTestAbsLeMul.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 37 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/SKFluctuations/ClockTestAbsLeMul.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/SKFluctuations/ClockTestAbsLeMul.lean
-
curl -L -o ClockTestAbsLeMul.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/SKFluctuations/ClockTestAbsLeMul.lean
37 kB
| import Mathlib | |
| import OAI.Probability.SKFluctuations.PowerTraceRelativeAbsLe | |
| namespace OAI | |
| /-! Clock Test Abs Le Mul. -/ | |
| noncomputable section | |
| open MeasureTheory ProbabilityTheory Filter | |
| open scoped BigOperators Topology | |
| open MeasureTheory Filter Set | |
| open scoped Topology | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| namespace SKFluctuations.Hierarchy | |
| open MeasureTheory ProbabilityTheory Filter Set GaussianCalculus | |
| open scoped Topology NNReal BigOperators | |
| theorem clockTest_abs_le_mul {ΞΉ : Type*} [Fintype ΞΉ] {F A B : (ΞΉ β β) β β} {C : ββ₯0} | |
| (hF : LipschitzWith C F) (hA : BddSmooth 0 A) (hB : BddSmooth 0 B) | |
| {c : β} (hb : β y, |A y| β€ c*B y) (m t : β) (x : ΞΉ β β) : | |
| |clockTest m F A t x| β€ c*clockTest m F B t x := | |
| shiftedMean_abs_le_mul hA hB hb | |
| ((exponentialIncrement_gaussian (fun _ : ΞΉ => Real.toNNReal t)).integrable_shift hF m x) | |
| theorem clockTest_nonneg {ΞΉ : Type*} [Fintype ΞΉ] {F A : (ΞΉ β β) β β} {C : ββ₯0} | |
| (hF : LipschitzWith C F) (hA : β y, 0 β€ A y) (m t : β) (x : ΞΉ β β) : | |
| 0 β€ clockTest m F A t x := | |
| shiftedMean_nonneg hA | |
| ((exponentialIncrement_gaussian (fun _ : ΞΉ => Real.toNNReal t)).integrable_shift hF m x) | |
| theorem clockGradient_relative_abs_le {ΞΉ : Type*} [Fintype ΞΉ] {F G A Aβ : (ΞΉ β β) β β} | |
| {C : ββ₯0} (hF : LipschitzWith C F) (hG : BddSmooth 0 G) (hA : BddSmooth 0 A) | |
| (hAβ : BddSmooth 0 Aβ) {D E : β} (hAp : β y, 0 β€ A y) | |
| (hbG : β y, |G y| β€ D) (hbAβ : β y, |Aβ y| β€ E*A y) | |
| (m t : β) (x : ΞΉ β β) : | |
| |clockGradient m F G A Aβ t x| β€ (E+2*|m| *D)*clockTest m F A t x := by | |
| have hp := clockTest_nonneg hF hAp m t x | |
| have hAG : β y, |A y*G y| β€ D*A y := by | |
| intro y | |
| rw [abs_mul,abs_of_nonneg (hAp y),mul_comm D] | |
| exact mul_le_mul_of_nonneg_left (hbG y) (hAp y) | |
| have h1 := clockTest_abs_le_mul hF hAβ hA hbAβ m t x | |
| have h2 := clockTest_abs_le_mul hF (hA.mul hG) hA hAG m t x | |
| have h4 := clockTest_abs_le hF hG hbG m t x | |
| have h34 : |clockTest m F A t x*clockTest m F G t x| β€ D*clockTest m F A t x := by | |
| rw [abs_mul,abs_of_nonneg hp,mul_comm D] | |
| exact mul_le_mul_of_nonneg_left h4 hp | |
| have hcov := (abs_sub (clockTest m F (fun y => A y*G y) t x) | |
| (clockTest m F A t x*clockTest m F G t x)).trans (add_le_add h2 h34) | |
| unfold clockGradient | |
| apply (abs_add_le _ _).trans | |
| rw [abs_mul] | |
| nlinarith [mul_le_mul_of_nonneg_left hcov (abs_nonneg m)] | |
| theorem HeatJet.massSplitResponse_relative_abs_le {n : β} (J : HeatJet n) (D : Fin (n+1) β β) | |
| {k a b : β} (hD : β i, 0 β€ D i) | |
| (hA : β y, 0 β€ J.A y) (hG : β i y, |J.G i y| β€ D i) | |
| (hAβ : β i y, |J.Aβ i y| β€ k*D i*J.A y) | |
| (ha : 0 β€ a) (ha1 : a β€ 1) (hb : 0 < b) (hb1 : b β€ 1) | |
| (T t : β) (x : Fin (n+1) β β) : | |
| |J.massSplitResponse a hb T t x| β€ (|a-b| *(k+3)*β i, (D i)^2)*J.massSplit a hb T t x := by | |
| let K := J.evolve hb (T-t) | |
| let Q := β i, (D i)^2 | |
| have hQ : 0 β€ Q := Finset.sum_nonneg fun i _ => sq_nonneg _ | |
| have hAK : β y, 0 β€ K.A y := clockTest_nonneg J.lipschitz hA b (T-t) | |
| have hGK : β i y, |K.G i y| β€ D i := fun i => | |
| clockTest_abs_le J.lipschitz (J.smoothG i) (hG i) b (T-t) | |
| have hAβK : β i y, |K.Aβ i y| β€ ((k+2)*D i)*K.A y := by | |
| intro i y | |
| have hh := clockGradient_relative_abs_le J.lipschitz (J.smoothG i) J.smoothA (J.smoothAβ i) | |
| hA (hG i) (hAβ i) b (T-t) y | |
| rw [abs_of_pos hb] at hh | |
| apply hh.trans | |
| apply mul_le_mul_of_nonneg_right _ (hAK y) | |
| nlinarith [mul_le_mul_of_nonneg_right hb1 (hD i)] | |
| have hGP (y) : |K.gradientPair y| β€ ((k+2)*Q)*K.A y := by | |
| apply (Finset.abs_sum_le_sum_abs _ _).trans | |
| calc | |
| _ β€ β i, D i*(((k+2)*D i)*K.A y) := by | |
| apply Finset.sum_le_sum | |
| intro i _ | |
| rw [abs_mul] | |
| exact mul_le_mul (hGK i y) (hAβK i y) (abs_nonneg _) (hD i) | |
| _ = _ := by | |
| dsimp only [Q] | |
| rw [Finset.mul_sum,Finset.sum_mul] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| ring | |
| have hAP (y) : |K.A y*K.potentialEnergy y| β€ Q*K.A y := by | |
| rw [abs_mul,abs_of_nonneg (hAK y),mul_comm Q] | |
| exact mul_le_mul_of_nonneg_left (K.potentialEnergy_abs_le D hD hGK y) (hAK y) | |
| have hp := clockTest_nonneg K.lipschitz hAK a t x | |
| have hg := clockTest_abs_le_mul K.lipschitz K.smoothGradientPair K.smoothA hGP a t x | |
| have he := clockTest_abs_le K.lipschitz K.smoothPotentialEnergy | |
| (K.potentialEnergy_abs_le D hD hGK) a t x | |
| have hae := clockTest_abs_le_mul K.lipschitz (K.smoothA.mul K.smoothPotentialEnergy) K.smoothA hAP a t x | |
| have hm : |clockTest a K.F K.A t x*clockTest a K.F K.potentialEnergy t x| β€ Q*clockTest a K.F K.A t x := by | |
| rw [abs_mul,abs_of_nonneg hp,mul_comm Q] | |
| exact mul_le_mul_of_nonneg_left he hp | |
| have hc := (abs_sub (clockTest a K.F (fun y => K.A y*K.potentialEnergy y) t x) | |
| (clockTest a K.F K.A t x*clockTest a K.F K.potentialEnergy t x)).trans (add_le_add hae hm) | |
| change |(a-b)*clockTest a K.F K.gradientPair t x+ | |
| (a*(a-b)/2)*(clockTest a K.F (fun y => K.A y*K.potentialEnergy y) t x- | |
| clockTest a K.F K.A t x*clockTest a K.F K.potentialEnergy t x)| β€ _ | |
| apply (abs_add_le _ _).trans | |
| simp only [abs_mul,abs_div,abs_of_nonneg ha,abs_of_pos (by norm_num : (0:β)<2)] | |
| change _ β€ (|a-b| *(k+3)*Q)*clockTest a K.F K.A t x | |
| have h1 := mul_le_mul_of_nonneg_left hg (abs_nonneg (a-b)) | |
| have h2 := mul_le_mul_of_nonneg_left hc (show 0 β€ a*|a-b|/2 by positivity) | |
| have h3 := mul_le_mul_of_nonneg_right ha1 (show 0 β€ |a-b| *Q*clockTest a K.F K.A t x by positivity) | |
| nlinarith | |
| theorem HeatJet.massSplit_exp_comparison {n : β} (J : HeatJet n) (D : Fin (n+1) β β) | |
| {k a b : β} (hD : β i, 0 β€ D i) | |
| (hA : β y, 0 β€ J.A y) (hG : β i y, |J.G i y| β€ D i) | |
| (hAβ : β i y, |J.Aβ i y| β€ k*D i*J.A y) | |
| (ha : 0 β€ a) (ha1 : a β€ 1) (hb : 0 < b) (hb1 : b β€ 1) | |
| {T s t : β} (hs : s β Icc 0 T) (ht : t β Icc 0 T) (x : Fin (n+1) β β) : | |
| let c := |a-b| *(k+3)*β i, (D i)^2 | |
| Real.exp (-c*|t-s|)*J.massSplit a hb T s x β€ J.massSplit a hb T t x β§ | |
| J.massSplit a hb T t x β€ Real.exp (c*|t-s|)*J.massSplit a hb T s x := by | |
| apply relative_derivative_exp_bound_on (convex_Icc 0 T) (J.continuous_massSplit a hb T x).continuousOn | |
| (fun u hu => (J.hasDerivAt_massSplit a hb (by simpa only [interior_Icc] using hu) x).hasDerivWithinAt) | |
| (fun u _ => J.massSplitResponse_relative_abs_le D hD hA hG hAβ ha ha1 hb hb1 T u x) hs ht | |
| end SKFluctuations.Hierarchy | |
| namespace SKFluctuations.Hierarchy | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped Topology NNReal BigOperators | |
| variable {ΞΉ S : Type*} [Fintype ΞΉ] [Fintype S] [Nonempty S] {n : β} | |
| theorem replicaFeatureJet_Aβ_relative_abs_le {w : S β β} (hw : β Ο, 0 < w Ο) | |
| (Ο : S β (ΞΉ β β) βL[β] β) (L : (Fin (n+1) β β) βL[β] (ΞΉ β β)) | |
| {steps : List (GaussianStep ΞΉ)} (T : ReplicaTree ΞΉ S steps) {a : β} | |
| (ha : OrderedSteps a steps) {P : T.Assignment β β} (hp : β Ο, 0 β€ P Ο) | |
| (x : ΞΉ β β) (D : Fin (n+1) β β) (hD : β i, 0 β€ D i) | |
| (hB : β i Ο, |Ο Ο (L (Pi.single i 1))| β€ D i) (i : Fin (n+1)) (y : Fin (n+1) β β) : | |
| |(replicaFeatureJet hw Ο L T ha P x).Aβ i y| β€ | |
| (2*(T.leaves:β))*D i*(replicaFeatureJet hw Ο L T ha P x).A y := by | |
| rw [replicaFeatureJet_Aβ,replicaFeatureJet_A] | |
| have hh := T.sourceJet_relative_abs_le hw Ο [L (Pi.single i 1)] ha le_rfl P (hD i) | |
| (by intro v hv Ο; simpa only [List.mem_singleton.mp hv] using hB i Ο) (x+L y) | |
| simp only [List.length_singleton,ReplicaTree.attachmentCount,Nat.cast_mul,Nat.cast_ofNat, | |
| mul_one,pow_one,abs_of_nonneg (hp _)] at hh | |
| nlinarith | |
| theorem ReplicaTree.linearTestSplit_exp_comparison {w : S β β} (hw : β Ο, 0 < w Ο) | |
| (Ο : S β (ΞΉ β β) βL[β] β) (L : (Fin (n+1) β β) βL[β] (ΞΉ β β)) | |
| {steps : List (GaussianStep ΞΉ)} (R : ReplicaTree ΞΉ S steps) {a b : β} | |
| (ho : OrderedSteps b steps) {P : R.Assignment β β} (hp : β Ο, 0 β€ P Ο) | |
| (D : Fin (n+1) β β) (hD : β i, 0 β€ D i) | |
| (hB : β i Ο, |Ο Ο (L (Pi.single i 1))| β€ D i) | |
| (ha : 0 β€ a) (ha1 : a β€ 1) (hb : 0 < b) (hb1 : b β€ 1) | |
| {T s t : β} (hs : s β Icc (0:β) T) (ht : t β Icc (0:β) T) (x : ΞΉ β β) : | |
| let c := |a-b| *(2*(R.leaves:β)+3)*β i, (D i)^2 | |
| let f := fun u => linearTestSplit L a b (gaussianHierarchy w Ο steps) (R.expect w Ο P) T u x | |
| Real.exp (-c*|t-s|)*f s β€ f t β§ f t β€ Real.exp (c*|t-s|)*f s := by | |
| let J := replicaFeatureJet hw Ο L R ho P x | |
| have hh := J.massSplit_exp_comparison D hD | |
| (fun y => R.expect_nonneg hw Ο ho hp (x+L y)) | |
| (replicaFeatureJet_G_abs_le hw Ο L R ho P x D hB) | |
| (replicaFeatureJet_Aβ_relative_abs_le hw Ο L R ho hp x D hD hB) ha ha1 hb hb1 hs ht 0 | |
| have hF := (gaussianHierarchy_regular hw Ο steps ho 0).1.choose_spec | |
| have hA := R.expect_smooth hw Ο ho P 0 | |
| simpa only [J,HeatJet.massSplit,HeatJet.evolve,replicaFeatureJet_F,replicaFeatureJet_A, | |
| β linearTestSplit_eq L hF hA a hb] using hh | |
| end SKFluctuations.Hierarchy | |
| namespace SKFluctuations.Hierarchy | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped Topology NNReal BigOperators | |
| variable {ΞΉ S Ξ² : Type*} [Fintype ΞΉ] [Fintype S] [Nonempty S] {n : β} | |
| theorem ReplicaTree.linearClock_mass_relative {w : S β β} (hw : β Ο, 0 < w Ο) | |
| (Ο : S β (ΞΉ β β) βL[β] β) (L : (Fin (n+1) β β) βL[β] (ΞΉ β β)) | |
| {steps : List (GaussianStep ΞΉ)} (R : ReplicaTree ΞΉ S steps) {a b : β} | |
| (ho : OrderedSteps b steps) {P : R.Assignment β β} (hp : β Ο, 0 β€ P Ο) | |
| (D : Fin (n+1) β β) (hD : β i, 0 β€ D i) | |
| (hB : β i Ο, |Ο Ο (L (Pi.single i 1))| β€ D i) | |
| (ha : 0 β€ a) (ha1 : a β€ 1) (hb : 0 < b) (hb1 : b β€ 1) | |
| {t : β} (ht : 0 β€ t) (x : ΞΉ β β) : | |
| linearClockTest L a (gaussianHierarchy w Ο steps) (R.expect w Ο P) t x β€ | |
| Real.exp ((|a-b| *(2*(R.leaves:β)+3)*β i, (D i)^2)*t)* | |
| linearClockTest L b (gaussianHierarchy w Ο steps) (R.expect w Ο P) t x := by | |
| let J := replicaFeatureJet hw Ο L R ho P x | |
| have hh := (J.massSplit_exp_comparison D hD | |
| (fun y => R.expect_nonneg hw Ο ho hp (x+L y)) | |
| (replicaFeatureJet_G_abs_le hw Ο L R ho P x D hB) | |
| (replicaFeatureJet_Aβ_relative_abs_le hw Ο L R ho hp x D hD hB) ha ha1 hb hb1 | |
| (show (0:β) β Icc 0 t from β¨le_rfl,htβ©) (show t β Icc 0 t from β¨ht,le_rflβ©) 0).2 | |
| rw [J.massSplit_zero,J.massSplit_terminal,sub_zero,abs_of_nonneg ht] at hh | |
| have hF := (gaussianHierarchy_regular hw Ο steps ho 0).1.choose_spec.continuous | |
| have hA := (R.expect_smooth hw Ο ho P 0).continuous | |
| simpa only [J,replicaFeatureJet_F,replicaFeatureJet_A,β linearClockTest_eq L hF hA] using hh | |
| theorem BoundaryTree.actual_mass_relative {w : S β β} (hw : β Ο, 0 < w Ο) | |
| (Ο : S β (ΞΉ β β) βL[β] β) (L : (Fin (n+1) β β) βL[β] (ΞΉ β β)) | |
| {steps : List (GaussianStep ΞΉ)} (R : Ξ² β ReplicaTree ΞΉ S steps) {a b c : β} | |
| (hoa : OrderedSteps a steps) (hob : OrderedSteps b steps) | |
| (ha : 0 < a) (hb : 0 < b) (ha1 : a β€ 1) (hb1 : b β€ 1) | |
| (D : Fin (n+1) β β) (hD : β i, 0 β€ D i) | |
| (hB : β i Ο, |Ο Ο (L (Pi.single i 1))| β€ D i) | |
| {front : List (GaussianStep ΞΉ)} (T : BoundaryTree ΞΉ Ξ² front) (hO : PrefixOrdered 0 c front) | |
| {t : β} (ht : 0 β€ t) (Ο : T.Assignment (fun d => (R d).Assignment)) (x : ΞΉ β β) : | |
| T.weight (fun _ => linearClockContinuation L a (gaussianHierarchy w Ο steps) t) | |
| (fun d Ο _ => (R d).atomicClock w Ο L a Ο t) Ο 0 x β€ | |
| Real.exp (T.budget (fun d => (|a-b| *(2*((R d).leaves:β)+3)*β i, (D i)^2)*t+ | |
| 2*c*((|a-b| /2*β i, (D i)^2)*t)))* | |
| T.weight (fun _ => linearClockContinuation L b (gaussianHierarchy w Ο steps) t) | |
| (fun d Ο _ => (R d).atomicClock w Ο L b Ο t) Ο 0 x := by | |
| classical | |
| have hF := gaussianHierarchy_regular hw Ο steps hob 0 | |
| have hi (m : β) := (exponentialIncrement_linearGaussian L (Real.toNNReal t)).integrable_shift hF.1.choose_spec m | |
| have hc (m : β) (d : Ξ²) (Ο : (R d).Assignment) : BddSmooth 0 ((R d).atomicClock w Ο L m Ο t) := | |
| ((R d).expect_smooth hw Ο hob _ 0).shiftedMean hF (hi m) | |
| exact T.finite_relative | |
| (lipschitzWith_shiftedContinuation hF.1.choose_spec hb (hi b)) | |
| (lipschitzWith_shiftedContinuation hF.1.choose_spec ha (hi a)) (by positivity) | |
| (fun y => (ReplicaTree.single steps).linearPotential_mass_difference hw Ο L hob D hB ha hb ht y) | |
| (hc b) (hc a) | |
| (fun d Ο y => ((R d).atomic_clockTest_probability hw Ο L hob t y).1 Ο) | |
| (fun d Ο y => ((R d).atomic_clockTest_probability hw Ο L hoa t y).1 Ο) | |
| (fun d => (|a-b| *(2*((R d).leaves:β)+3)*β i, (D i)^2)*t) | |
| (fun d Ο y => (R d).linearClock_mass_relative hw Ο L hob | |
| (P := fun v => if v = Ο then 1 else 0) (by intro v; split_ifs <;> norm_num) | |
| D hD hB ha.le ha1 hb hb1 ht y) hO Ο x | |
| end SKFluctuations.Hierarchy | |
| namespace SKFluctuations.Hierarchy | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped Topology NNReal BigOperators | |
| variable {S Ξ² : Type*} [Fintype S] [Nonempty S] {n : β} | |
| theorem ClockTree.atomicHead_mass_close {w : S β β} (hw : β Ο, 0 < w Ο) | |
| (Ο : S β (Fin (n+1) β β) βL[β] β) {as : List PositiveMass} (T : ClockTree S as) | |
| {a b : β} (hoa : MassOrdered a as) (hob : MassOrdered b as) | |
| (ha : 0 < a) (ha1 : a β€ 1) (hb : 0 < b) (hb1 : b β€ 1) | |
| (D : Fin (n+1) β β) (hD : β i, 0 β€ D i) (hB : β i Ο, |Ο Ο (Pi.single i 1)| β€ D i) | |
| (q : β β Fin (n+1) β ββ₯0) (v : Fin (n+1) β ββ₯0) (Ο : T.Assignment) (x : Fin (n+1) β β) : | |
| ExpClose (|a-b| *(2*(T.leaves:β)+3)*β i, (v i:β)*(D i)^2) | |
| (T.atomicHead w Ο q v a Ο x) (T.atomicHead w Ο q v b Ο x) := by | |
| classical | |
| have hd (i : Fin (n+1)) (Ο : S) : |Ο Ο (diagonalDriver v (Pi.single i 1))| β€ Real.sqrt (v i)*D i := by | |
| rw [diagonalDriver_single,map_smul,smul_eq_mul,abs_mul,abs_of_nonneg (Real.sqrt_nonneg _)] | |
| exact mul_le_mul_of_nonneg_left (hB i Ο) (Real.sqrt_nonneg _) | |
| have hβ := (T.realize q).linearClock_mass_relative hw Ο (diagonalDriver v) | |
| (clockSteps_ordered hob q) (P := fun Ο => if Ο = T.assignmentEquiv q Ο then 1 else 0) | |
| (by intro Ο; split_ifs <;> norm_num) (fun i => Real.sqrt (v i)*D i) | |
| (fun i => mul_nonneg (Real.sqrt_nonneg _) (hD i)) hd ha.le ha1 hb hb1 | |
| (by norm_num : (0:β) β€ 1) x | |
| have hβ := (T.realize q).linearClock_mass_relative hw Ο (diagonalDriver v) | |
| (clockSteps_ordered hoa q) (P := fun Ο => if Ο = T.assignmentEquiv q Ο then 1 else 0) | |
| (by intro Ο; split_ifs <;> norm_num) (fun i => Real.sqrt (v i)*D i) | |
| (fun i => mul_nonneg (Real.sqrt_nonneg _) (hD i)) hd hb.le hb1 ha ha1 | |
| (by norm_num : (0:β) β€ 1) x | |
| refine β¨(T.atomicHead_probability hw Ο hoa ha q v x).1 Ο, | |
| (T.atomicHead_probability hw Ο hob hb q v x).1 Ο,?_,?_β© | |
| Β· rw [T.atomicHead_eq_clock,T.atomicHead_eq_clock] | |
| simpa only [ReplicaTree.atomicClock,mul_one,mul_pow,Real.sq_sqrt (v _).coe_nonneg,ClockTree.realize_leaves] using hβ | |
| Β· rw [T.atomicHead_eq_clock,T.atomicHead_eq_clock] | |
| simpa only [ReplicaTree.atomicClock,mul_one,mul_pow,Real.sq_sqrt (v _).coe_nonneg,ClockTree.realize_leaves,abs_sub_comm b a] using hβ | |
| theorem ClockTree.atomicHead_transfer_close {w : S β β} (hw : β Ο, 0 < w Ο) | |
| (Ο : S β (Fin (n+1) β β) βL[β] β) {b : PositiveMass} {bs : List PositiveMass} | |
| (T : ClockTree S (b::bs)) (ho : MassOrdered b.val bs) {a : β} (ha : 0 < a) (hab : a β€ b.val) | |
| (D : Fin (n+1) β β) (hD : β i, 0 β€ D i) (hB : β i Ο, |Ο Ο (Pi.single i 1)| β€ D i) | |
| (q : β β Fin (n+1) β ββ₯0) (v : Fin (n+1) β ββ₯0) (Ο : T.Assignment) (x : Fin (n+1) β β) : | |
| ExpClose ((|a-b.val| *(2*(T.leaves:β)+3)+8*(T.leaves:β)*(T.leaves+1:β)*T.rootForks)* | |
| β i, (v i:β)*(D i)^2) | |
| (T.atomicHead w Ο q v a Ο x) (T.weight w Ο (addHeadClock q v) Ο x) := by | |
| have hb1 : b.val β€ 1 := (massOrdered_bounds ho).2 | |
| have hβ := T.atomicHead_mass_close hw Ο β¨ha.le,hab,hoβ© β¨b.property.le,le_rfl,hoβ© | |
| ha (hab.trans hb1) b.property hb1 D hD hB q v Ο x | |
| have hβ := T.atomicHead_crossing_close hw Ο rfl ho D hD hB q v Ο x | |
| convert hβ.trans hβ using 1 | |
| ring | |
| theorem BoundaryTree.head_transfer_close {w : S β β} (hw : β Ο, 0 < w Ο) | |
| (Ο : S β (Fin (n+1) β β) βL[β] β) {b : PositiveMass} {bs : List PositiveMass} | |
| (R : Ξ² β ClockTree S (b::bs)) (ho : MassOrdered b.val bs) | |
| {a c : β} (ha : 0 < a) (hab : a β€ b.val) | |
| (D : Fin (n+1) β β) (hD : β i, 0 β€ D i) (hB : β i Ο, |Ο Ο (Pi.single i 1)| β€ D i) | |
| (q : β β Fin (n+1) β ββ₯0) (v : Fin (n+1) β ββ₯0) | |
| {front : List (GaussianStep (Fin (n+1)))} (T : BoundaryTree (Fin (n+1)) Ξ² front) | |
| (hO : PrefixOrdered 0 c front) (Ο : T.Assignment (fun d => (R d).Assignment)) (x : Fin (n+1) β β) : | |
| ExpClose (T.budget (fun d => ((|a-b.val| *(2*((R d).leaves:β)+3)+ | |
| 8*((R d).leaves:β)*((R d).leaves+1:β)*(R d).rootForks)+c*|a-b.val|)* | |
| β i, (v i:β)*(D i)^2)) | |
| (T.weight | |
| (fun _ => shiftedContinuation (Measure.pi fun i => gaussianReal 0 (v i)) a | |
| (gaussianHierarchy w Ο (clockSteps (b::bs) q))) | |
| (fun d Ο _ => (R d).atomicHead w Ο q v a Ο) Ο 0 x) | |
| (T.weight (fun _ => gaussianHierarchy w Ο (clockSteps (b::bs) (addHeadClock q v))) | |
| (fun d Ο _ => (R d).weight w Ο (addHeadClock q v) Ο) Ο 0 x) := by | |
| classical | |
| have hA : MassOrdered a (b::bs) := β¨ha.le,hab,hoβ© | |
| have hBβ : MassOrdered b.val (b::bs) := β¨b.property.le,le_rfl,hoβ© | |
| have hF := (gaussianHierarchy_regular hw Ο _ (clockSteps_ordered hA q) 0).1.choose_spec | |
| have hG := (gaussianHierarchy_regular hw Ο _ (clockSteps_ordered hBβ (addHeadClock q v)) 0).1.choose_spec | |
| have hd (i : Fin (n+1)) (Ο : S) : |Ο Ο (diagonalDriver v (Pi.single i 1))| β€ Real.sqrt (v i)*D i := by | |
| rw [diagonalDriver_single,map_smul,smul_eq_mul,abs_mul,abs_of_nonneg (Real.sqrt_nonneg _)] | |
| exact mul_le_mul_of_nonneg_left (hB i Ο) (Real.sqrt_nonneg _) | |
| have hP (y : Fin (n+1) β β) : | |
| |shiftedContinuation (Measure.pi fun i => gaussianReal 0 (v i)) a | |
| (gaussianHierarchy w Ο (clockSteps (b::bs) q)) y- | |
| gaussianHierarchy w Ο (clockSteps (b::bs) (addHeadClock q v)) y| β€ | |
| |a-b.val|/2*β i, (v i:β)*(D i)^2 := by | |
| rw [gaussianHierarchy_addHeadClock hw Ο ho q v] | |
| have hh := (ReplicaTree.single (clockSteps (b::bs) q)).linearPotential_mass_difference hw Ο | |
| (diagonalDriver v) (clockSteps_ordered hBβ q) (fun i => Real.sqrt (v i)*D i) hd ha b.property | |
| (by norm_num : (0:β) β€ 1) y | |
| simpa only [linearClockContinuation,Real.toNNReal_one,linearGaussian_diagonal, | |
| mul_pow,Real.sq_sqrt (v _).coe_nonneg,mul_one] using hh | |
| have hh := T.finite_close hG | |
| (lipschitzWith_shiftedContinuation hF ha ((exponentialIncrement_gaussian v).integrable_shift hF a)) | |
| (by positivity : 0 β€ |a-b.val|/2*β i, (v i:β)*(D i)^2) hP | |
| (fun d Ο => (R d).weight_smooth hw Ο hBβ (addHeadClock q v) Ο 0) | |
| (fun d Ο => (R d).atomicHead_smooth hw Ο hA ha q v Ο 0) | |
| (fun d => (|a-b.val| *(2*((R d).leaves:β)+3)+ | |
| 8*((R d).leaves:β)*((R d).leaves+1:β)*(R d).rootForks)*β i, (v i:β)*(D i)^2) | |
| (fun d Ο y => (R d).atomicHead_transfer_close hw Ο ho ha hab D hD hB q v Ο y) hO Ο x | |
| convert hh using 1 | |
| congr 1 | |
| funext d | |
| ring | |
| end SKFluctuations.Hierarchy | |
| namespace SKFluctuations.Hierarchy | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped Topology NNReal BigOperators | |
| variable {S : Type*} [Fintype S] [Nonempty S] {n : β} | |
| def prependClock {ΞΉ : Type*} (u : ΞΉ β ββ₯0) (q : β β ΞΉ β ββ₯0) : β β ΞΉ β ββ₯0 | |
| | 0 => u | |
| | j+1 => q j | |
| theorem ClockTree.step_head_transfer {w : S β β} (hw : β Ο, 0 < w Ο) | |
| (Ο : S β (Fin (n+1) β β) βL[β] β) {a b : PositiveMass} {bs : List PositiveMass} | |
| (T : ClockTree S (b::bs)) (ho : MassOrdered a.val (b::bs)) | |
| (D : Fin (n+1) β β) (hD : β i, 0 β€ D i) (hB : β i Ο, |Ο Ο (Pi.single i 1)| β€ D i) | |
| (q : β β Fin (n+1) β ββ₯0) (u v : Fin (n+1) β ββ₯0) (x : Fin (n+1) β β) : | |
| β Ο, |(T.step a).weight w Ο (prependClock (fun i => u i+v i) q) Ο x- | |
| (T.step a).weight w Ο (prependClock u (addHeadClock q v)) Ο x| β€ | |
| ((|a.val-b.val| *(2*(T.leaves:β)+3)+8*(T.leaves:β)*(T.leaves+1:β)*T.rootForks)+ | |
| a.val*|a.val-b.val|)*β i, (v i:β)*(D i)^2 := by | |
| classical | |
| let P : BoundaryTree (Fin (n+1)) Unit [(a.val,u)] := | |
| (BoundaryTree.leaf () : BoundaryTree (Fin (n+1)) Unit []).step (a.val,u) | |
| have hO : PrefixOrdered 0 a.val [(a.val,u)] := β¨le_rfl,a.property.le,a.property,a.property.le,le_rflβ© | |
| have hh := P.head_transfer hw Ο (fun _ => T) ho.2.2 a.property ho.2.1 D hD hB q v hO x | |
| have hF := (gaussianHierarchy_regular hw Ο _ (clockSteps_ordered ho q) 0).1.choose_spec | |
| have hl (Ο : T.Assignment) : shiftedMean (Measure.pi fun i => gaussianReal 0 (u i)) a.val | |
| (shiftedContinuation (Measure.pi fun i => gaussianReal 0 (v i)) a.val | |
| (gaussianHierarchy w Ο (clockSteps (b::bs) q))) | |
| (T.atomicHead w Ο q v a.val Ο) x = | |
| (T.step a).weight w Ο (prependClock (fun i => u i+v i) q) Ο x := | |
| shiftedMean_productGaussian_add hF (T.weight_smooth hw Ο ho q Ο 0) a.property.ne' u v x | |
| dsimp only [P,BoundaryTree.weight,BoundaryTree.budget,prefixContinuation] at hh | |
| simp_rw [hl] at hh | |
| exact hh | |
| theorem ClockTree.local_boundary_transfer {w : S β β} (hw : β Ο, 0 < w Ο) | |
| (Ο : S β (Fin (n+1) β β) βL[β] β) {as : List PositiveMass} (T : ClockTree S as) | |
| {a b : PositiveMass} {bs : List PositiveMass} (he : as = a::b::bs) | |
| (ho : MassOrdered a.val (b::bs)) (D : Fin (n+1) β β) (hD : β i, 0 β€ D i) | |
| (hB : β i Ο, |Ο Ο (Pi.single i 1)| β€ D i) | |
| (q : β β Fin (n+1) β ββ₯0) (u v : Fin (n+1) β ββ₯0) (x : Fin (n+1) β β) : | |
| β Ο, |T.weight w Ο (prependClock (fun i => u i+v i) q) Ο x- | |
| T.weight w Ο (prependClock u (addHeadClock q v)) Ο x| β€ | |
| (6*(T.leaves:β)*|a.val-b.val|+8*(T.leaves:β)*(T.leaves+1:β)*T.forksAt 1)* | |
| β i, (v i:β)*(D i)^2 := by | |
| classical | |
| have hv : 0 β€ β i, (v i:β)*(D i)^2 := Finset.sum_nonneg fun i _ => mul_nonneg (v i).coe_nonneg (sq_nonneg _) | |
| induction T generalizing a b bs with | |
| | leaf => cases he | |
| | @step c cs T ih => | |
| cases he | |
| have hh := T.step_head_transfer hw Ο ho D hD hB q u v x | |
| apply hh.trans | |
| apply mul_le_mul_of_nonneg_right _ hv | |
| simp only [ClockTree.leaves,ClockTree.forksAt,ClockTree.forksAt_zero] | |
| have hr : (1:β) β€ T.leaves := by exact_mod_cast T.leaves_pos | |
| have ha1 : c.val β€ 1 := (massOrdered_bounds ho).2 | |
| have hgap : 0 β€ |c.val-b.val| := abs_nonneg _ | |
| nlinarith [mul_nonneg hgap (sub_nonneg.mpr ha1),mul_nonneg hgap (sub_nonneg.mpr hr)] | |
| | @fork cs T U ihT ihU => | |
| have hO : MassOrdered a.val cs := he βΈ β¨a.property.le,le_rfl,hoβ© | |
| have hpT := T.weight_probability hw Ο hO (prependClock u (addHeadClock q v)) x | |
| have hpU := U.weight_probability hw Ο hO (prependClock (fun i => u i+v i) q) x | |
| have hp := finite_probability_product_distance hpT.1 hpU.1 hpT.2 hpU.2 | |
| (p := fun Ο => T.weight w Ο (prependClock (fun i => u i+v i) q) Ο x) | |
| (s := fun Ο => U.weight w Ο (prependClock u (addHeadClock q v)) Ο x) | |
| change (β Ο : T.Assignment Γ U.Assignment, | |
| |T.weight w Ο (prependClock (fun i => u i+v i) q) Ο.1 x* | |
| U.weight w Ο (prependClock (fun i => u i+v i) q) Ο.2 x- | |
| T.weight w Ο (prependClock u (addHeadClock q v)) Ο.1 x* | |
| U.weight w Ο (prependClock u (addHeadClock q v)) Ο.2 x|) β€ _ | |
| apply (hp.trans (add_le_add (ihT he ho) (ihU he ho))).trans | |
| rw [β add_mul] | |
| apply mul_le_mul_of_nonneg_right _ hv | |
| simp only [ClockTree.leaves,ClockTree.forksAt,show (1:β) β 0 from by omega,ite_false,zero_add,Nat.cast_add] | |
| have hT : 0 β€ (T.leaves:β) := Nat.cast_nonneg _ | |
| have hU : 0 β€ (U.leaves:β) := Nat.cast_nonneg _ | |
| have hTpoly : (T.leaves:β)*(T.leaves+1:β) β€ (T.leaves+U.leaves:β)*(T.leaves+U.leaves+1:β) := by nlinarith | |
| have hUpoly : (U.leaves:β)*(U.leaves+1:β) β€ (T.leaves+U.leaves:β)*(T.leaves+U.leaves+1:β) := by nlinarith | |
| have hTf := mul_le_mul_of_nonneg_right hTpoly (show (0:β) β€ T.forksAt 1 from Nat.cast_nonneg _) | |
| have hUf := mul_le_mul_of_nonneg_right hUpoly (show (0:β) β€ U.forksAt 1 from Nat.cast_nonneg _) | |
| nlinarith | |
| theorem gaussianHierarchy_local_boundary_transfer {w : S β β} (hw : β Ο, 0 < w Ο) | |
| (Ο : S β (Fin (n+1) β β) βL[β] β) {a b : PositiveMass} {bs : List PositiveMass} | |
| (ho : MassOrdered b.val bs) (D : Fin (n+1) β β) (hB : β i Ο, |Ο Ο (Pi.single i 1)| β€ D i) | |
| (q : β β Fin (n+1) β ββ₯0) (u v : Fin (n+1) β ββ₯0) (x : Fin (n+1) β β) : | |
| |gaussianHierarchy w Ο (clockSteps (a::b::bs) (prependClock (fun i => u i+v i) q)) x- | |
| gaussianHierarchy w Ο (clockSteps (a::b::bs) (prependClock u (addHeadClock q v))) x| β€ | |
| |a.val-b.val|/2*β i, (v i:β)*(D i)^2 := by | |
| have hh := gaussianHierarchy_covariance_transfer hw Ο | |
| (clockSteps_ordered ho (fun j => q (j+1))) D hB a.property b.property u v (q 0) x | |
| simpa only [clockSteps,prependClock,addHeadClock,add_comm] using hh | |
| end SKFluctuations.Hierarchy | |
| namespace SKFluctuations.Hierarchy | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped Topology NNReal BigOperators | |
| variable {S : Type*} [Fintype S] [Nonempty S] {n : β} | |
| theorem ClockTree.step_head_close {w : S β β} (hw : β Ο, 0 < w Ο) | |
| (Ο : S β (Fin (n+1) β β) βL[β] β) {a b : PositiveMass} {bs : List PositiveMass} | |
| (T : ClockTree S (b::bs)) (ho : MassOrdered a.val (b::bs)) | |
| (D : Fin (n+1) β β) (hD : β i, 0 β€ D i) (hB : β i Ο, |Ο Ο (Pi.single i 1)| β€ D i) | |
| (q : β β Fin (n+1) β ββ₯0) (u v : Fin (n+1) β ββ₯0) (Ο : T.Assignment) (x : Fin (n+1) β β) : | |
| ExpClose (((|a.val-b.val| *(2*(T.leaves:β)+3)+8*(T.leaves:β)*(T.leaves+1:β)*T.rootForks)+ | |
| a.val*|a.val-b.val|)*β i, (v i:β)*(D i)^2) | |
| ((T.step a).weight w Ο (prependClock (fun i => u i+v i) q) Ο x) | |
| ((T.step a).weight w Ο (prependClock u (addHeadClock q v)) Ο x) := by | |
| classical | |
| let P : BoundaryTree (Fin (n+1)) Unit [(a.val,u)] := | |
| (BoundaryTree.leaf () : BoundaryTree (Fin (n+1)) Unit []).step (a.val,u) | |
| have hO : PrefixOrdered 0 a.val [(a.val,u)] := β¨le_rfl,a.property.le,a.property,a.property.le,le_rflβ© | |
| have hh := P.head_transfer_close hw Ο (fun _ => T) ho.2.2 a.property ho.2.1 D hD hB q v hO Ο x | |
| have hF := (gaussianHierarchy_regular hw Ο _ (clockSteps_ordered ho q) 0).1.choose_spec | |
| have hl (Ο : T.Assignment) : shiftedMean (Measure.pi fun i => gaussianReal 0 (u i)) a.val | |
| (shiftedContinuation (Measure.pi fun i => gaussianReal 0 (v i)) a.val | |
| (gaussianHierarchy w Ο (clockSteps (b::bs) q))) | |
| (T.atomicHead w Ο q v a.val Ο) x = | |
| (T.step a).weight w Ο (prependClock (fun i => u i+v i) q) Ο x := | |
| shiftedMean_productGaussian_add hF (T.weight_smooth hw Ο ho q Ο 0) a.property.ne' u v x | |
| dsimp only [P,BoundaryTree.weight,BoundaryTree.budget,prefixContinuation] at hh | |
| simp_rw [hl] at hh | |
| exact hh | |
| theorem ClockTree.local_boundary_close {w : S β β} (hw : β Ο, 0 < w Ο) | |
| (Ο : S β (Fin (n+1) β β) βL[β] β) {as : List PositiveMass} (T : ClockTree S as) | |
| {a b : PositiveMass} {bs : List PositiveMass} (he : as = a::b::bs) | |
| (ho : MassOrdered a.val (b::bs)) (D : Fin (n+1) β β) (hD : β i, 0 β€ D i) | |
| (hB : β i Ο, |Ο Ο (Pi.single i 1)| β€ D i) | |
| (q : β β Fin (n+1) β ββ₯0) (u v : Fin (n+1) β ββ₯0) (Ο : T.Assignment) (x : Fin (n+1) β β) : | |
| ExpClose ((6*(T.leaves:β)*|a.val-b.val|+8*(T.leaves:β)*(T.leaves+1:β)*T.forksAt 1)* | |
| β i, (v i:β)*(D i)^2) | |
| (T.weight w Ο (prependClock (fun i => u i+v i) q) Ο x) | |
| (T.weight w Ο (prependClock u (addHeadClock q v)) Ο x) := by | |
| classical | |
| have hv : 0 β€ β i, (v i:β)*(D i)^2 := Finset.sum_nonneg fun i _ => mul_nonneg (v i).coe_nonneg (sq_nonneg _) | |
| induction T generalizing a b bs with | |
| | leaf => cases he | |
| | @step c cs T ih => | |
| cases he | |
| have hh := T.step_head_close hw Ο ho D hD hB q u v Ο x | |
| apply hh.mono | |
| apply mul_le_mul_of_nonneg_right _ hv | |
| simp only [ClockTree.leaves,ClockTree.forksAt,ClockTree.forksAt_zero] | |
| have hr : (1:β) β€ T.leaves := by exact_mod_cast T.leaves_pos | |
| have ha1 : c.val β€ 1 := (massOrdered_bounds ho).2 | |
| have hgap : 0 β€ |c.val-b.val| := abs_nonneg _ | |
| nlinarith [mul_nonneg hgap (sub_nonneg.mpr ha1),mul_nonneg hgap (sub_nonneg.mpr hr)] | |
| | @fork cs T U ihT ihU => | |
| have hh := (ihT he ho Ο.1).mul (ihU he ho Ο.2) | |
| apply hh.mono | |
| rw [β add_mul] | |
| apply mul_le_mul_of_nonneg_right _ hv | |
| simp only [ClockTree.leaves,ClockTree.forksAt,show (1:β) β 0 from by omega,ite_false,zero_add,Nat.cast_add] | |
| have hT : 0 β€ (T.leaves:β) := Nat.cast_nonneg _ | |
| have hU : 0 β€ (U.leaves:β) := Nat.cast_nonneg _ | |
| have hTpoly : (T.leaves:β)*(T.leaves+1:β) β€ (T.leaves+U.leaves:β)*(T.leaves+U.leaves+1:β) := by nlinarith | |
| have hUpoly : (U.leaves:β)*(U.leaves+1:β) β€ (T.leaves+U.leaves:β)*(T.leaves+U.leaves+1:β) := by nlinarith | |
| have hTf := mul_le_mul_of_nonneg_right hTpoly (show (0:β) β€ T.forksAt 1 from Nat.cast_nonneg _) | |
| have hUf := mul_le_mul_of_nonneg_right hUpoly (show (0:β) β€ U.forksAt 1 from Nat.cast_nonneg _) | |
| nlinarith | |
| end SKFluctuations.Hierarchy | |
| namespace SKFluctuations.Hierarchy | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped Topology NNReal BigOperators | |
| variable {S ΞΉ Ξ² : Type*} | |
| theorem BoundaryTree.budget_nonneg {front : List (GaussianStep ΞΉ)} (T : BoundaryTree ΞΉ Ξ² front) | |
| {f : Ξ² β β} (hf : β b, 0 β€ f b) : 0 β€ T.budget f := by | |
| induction T with | |
| | leaf b => exact hf b | |
| | step _ _ ih => exact ih | |
| | fork _ _ ihT ihU => exact add_nonneg ihT ihU | |
| theorem BoundaryTree.budget_quadratic {front : List (GaussianStep ΞΉ)} (T : BoundaryTree ΞΉ Ξ² front) | |
| {f g : Ξ² β β} (hf : β b, 0 β€ f b) (hg : β b, 0 β€ g b) : | |
| T.budget (fun b => f b*(f b+1)*g b) β€ T.budget f*(T.budget f+1)*T.budget g := by | |
| induction T with | |
| | leaf => exact le_rfl | |
| | step _ _ ih => exact ih | |
| | fork T U ihT ihU => | |
| have hT := T.budget_nonneg hf | |
| have hU := U.budget_nonneg hf | |
| have hTpoly : T.budget f*(T.budget f+1) β€ (T.budget f+U.budget f)*(T.budget f+U.budget f+1) := by nlinarith | |
| have hUpoly : U.budget f*(U.budget f+1) β€ (T.budget f+U.budget f)*(T.budget f+U.budget f+1) := by nlinarith | |
| have hTf := mul_le_mul_of_nonneg_right hTpoly (T.budget_nonneg hg) | |
| have hUf := mul_le_mul_of_nonneg_right hUpoly (U.budget_nonneg hg) | |
| simp only [BoundaryTree.budget] | |
| nlinarith | |
| theorem ClockTree.cut_budget_one {as : List PositiveMass} (T : ClockTree S as) | |
| (j : β) (q : β β ΞΉ β ββ₯0) (hj : j β€ as.length) : | |
| (T.cut j q).budget (fun _ => (1:β)) β€ T.leaves := by | |
| rw [β T.cut_budget_leaves j q hj] | |
| exact (T.cut j q).budget_mono (fun U => by exact_mod_cast U.leaves_pos) | |
| theorem ClockTree.cut_budget_forksAt {as : List PositiveMass} (T : ClockTree S as) | |
| (j k : β) (q : β β ΞΉ β ββ₯0) (hj : j β€ as.length) : | |
| (T.cut j q).budget (fun U => (U.forksAt k:β)) = T.forksAt (j+k) := by | |
| induction T generalizing j q with | |
| | leaf => | |
| have : j = 0 := by simpa using hj | |
| subst j | |
| rfl | |
| | @step a cs T ih => | |
| cases j with | |
| | zero => simp only [Nat.zero_add,ClockTree.cut,BoundaryTree.budget]; rfl | |
| | succ j => | |
| have hj' : j β€ cs.length := by simpa using hj | |
| change (T.cut j (fun r => q (r+1))).budget (fun U => (U.forksAt k:β)) = | |
| (T.step a).forksAt (j+1+k) | |
| rw [ih j (fun r => q (r+1)) hj',show j+1+k = (j+k)+1 by omega] | |
| rfl | |
| | @fork cs T U ihT ihU => | |
| cases j with | |
| | zero => simp only [Nat.zero_add,ClockTree.cut,BoundaryTree.budget]; rfl | |
| | succ j => | |
| change (T.cut (j+1) q).budget (fun U => (U.forksAt k:β))+ | |
| (U.cut (j+1) q).budget (fun V => (V.forksAt k:β)) = _ | |
| rw [ihT (j+1) q hj,ihU (j+1) q hj] | |
| have hz : j+1+k β 0 := by omega | |
| simp only [ClockTree.forksAt,hz,ite_false,zero_add,Nat.cast_add] | |
| theorem ClockTree.cut_budget_quadratic_forks {as : List PositiveMass} (T : ClockTree S as) | |
| (j k : β) (q : β β ΞΉ β ββ₯0) (hj : j β€ as.length) : | |
| (T.cut j q).budget (fun U => (U.leaves:β)*(U.leaves+1:β)*U.forksAt k) β€ | |
| (T.leaves:β)*(T.leaves+1:β)*T.forksAt (j+k) := by | |
| have h := (T.cut j q).budget_quadratic | |
| (fun U => (Nat.cast_nonneg U.leaves : (0:β) β€ U.leaves)) | |
| (fun U => (Nat.cast_nonneg (U.forksAt k) : (0:β) β€ U.forksAt k)) | |
| rwa [T.cut_budget_leaves j q hj,T.cut_budget_forksAt j k q hj] at h | |
| end SKFluctuations.Hierarchy | |
| namespace SKFluctuations.Hierarchy | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped Topology NNReal BigOperators | |
| variable {S : Type*} [Fintype S] [Nonempty S] {n : β} | |
| theorem ClockTree.cut_boundary_transfer {w : S β β} (hw : β Ο, 0 < w Ο) | |
| (Ο : S β (Fin (n+1) β β) βL[β] β) {as : List PositiveMass} (T : ClockTree S as) | |
| (j : β) {a b : PositiveMass} {bs : List PositiveMass} (he : as.drop j = a::b::bs) | |
| (ho : MassOrdered a.val (b::bs)) | |
| (D : Fin (n+1) β β) (hD : β i, 0 β€ D i) (hB : β i Ο, |Ο Ο (Pi.single i 1)| β€ D i) | |
| (p q : β β Fin (n+1) β ββ₯0) (u v : Fin (n+1) β ββ₯0) | |
| {c : β} (hO : PrefixOrdered 0 c (clockSteps (as.take j) p)) (hc : c β€ 1) | |
| (x : Fin (n+1) β β) : | |
| β Ο, |T.weight w Ο (mixClocks j p (prependClock (fun i => u i+v i) q)) Ο x- | |
| T.weight w Ο (mixClocks j p (prependClock u (addHeadClock q v))) Ο x| β€ | |
| (7*(T.leaves:β)*|a.val-b.val|+8*(T.leaves:β)*(T.leaves+1:β)*T.forksAt (j+1))* | |
| β i, (v i:β)*(D i)^2 := by | |
| classical | |
| have hj : j β€ as.length := by | |
| have hl := congrArg List.length he | |
| simp only [List.length_drop,List.length_cons] at hl | |
| omega | |
| have hv : 0 β€ β i, (v i:β)*(D i)^2 := Finset.sum_nonneg fun i _ => mul_nonneg (v i).coe_nonneg (sq_nonneg _) | |
| have hc0 : 0 β€ c := (hO.bounds).2 | |
| have ha : MassOrdered a.val (as.drop j) := he βΈ β¨a.property.le,le_rfl,hoβ© | |
| have hP (y : Fin (n+1) β β) : | |
| |gaussianHierarchy w Ο (clockSteps (as.drop j) (prependClock (fun i => u i+v i) q)) y- | |
| gaussianHierarchy w Ο (clockSteps (as.drop j) (prependClock u (addHeadClock q v))) y| β€ | |
| |a.val-b.val|/2*β i, (v i:β)*(D i)^2 := by | |
| rw [he] | |
| exact gaussianHierarchy_local_boundary_transfer hw Ο ho.2.2 D hB q u v y | |
| have hh := T.cut_mix_stability hw Ο j p | |
| (prependClock (fun i => u i+v i) q) (prependClock u (addHeadClock q v)) hj ha | |
| (by positivity : 0 β€ |a.val-b.val|/2*β i, (v i:β)*(D i)^2) hP | |
| (fun U => (6*(U.leaves:β)*|a.val-b.val|+8*(U.leaves:β)*(U.leaves+1:β)*U.forksAt 1)* | |
| β i, (v i:β)*(D i)^2) | |
| (fun U y => U.local_boundary_transfer hw Ο he ho D hD hB q u v y) hO x | |
| apply hh.trans | |
| let V : β := β i, (v i:β)*(D i)^2 | |
| have heq : (T.cut j p).budget (fun U => | |
| (6*(U.leaves:β)*|a.val-b.val|+8*(U.leaves:β)*(U.leaves+1:β)*U.forksAt 1)*V+ | |
| 2*c*(|a.val-b.val|/2*V)) = | |
| (T.cut j p).budget (fun U => (U.leaves:β))*(6*|a.val-b.val| *V)+ | |
| (T.cut j p).budget (fun U => (U.leaves:β)*(U.leaves+1:β)*U.forksAt 1)*(8*V)+ | |
| (T.cut j p).budget (fun _ => (1:β))*(c*|a.val-b.val| *V) := by | |
| calc | |
| _ = (T.cut j p).budget (fun U => | |
| (U.leaves:β)*(6*|a.val-b.val| *V)+ | |
| ((U.leaves:β)*(U.leaves+1:β)*U.forksAt 1)*(8*V)+(1:β)*(c*|a.val-b.val| *V)) := by | |
| congr 1 | |
| funext U | |
| ring | |
| _ = _ := by rw [BoundaryTree.budget_add,BoundaryTree.budget_add, | |
| BoundaryTree.budget_mul,BoundaryTree.budget_mul,BoundaryTree.budget_mul] | |
| change (T.cut j p).budget _ β€ _ | |
| rw [heq,T.cut_budget_leaves j p hj] | |
| have hfork := mul_le_mul_of_nonneg_right (T.cut_budget_quadratic_forks j 1 p hj) | |
| (show 0 β€ 8*V by positivity) | |
| have hone := mul_le_mul_of_nonneg_right (T.cut_budget_one j p hj) | |
| (show 0 β€ c*|a.val-b.val| *V by positivity) | |
| have hlast : (T.leaves:β)*(c*|a.val-b.val| *V) β€ (T.leaves:β)*(|a.val-b.val| *V) := by | |
| apply mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg _) | |
| nlinarith [mul_nonneg (sub_nonneg.mpr hc) (mul_nonneg (abs_nonneg (a.val-b.val)) hv)] | |
| dsimp only [V] at hfork hone hlast β’ | |
| nlinarith | |
| end SKFluctuations.Hierarchy | |
| end | |
| end OAI | |