| import Mathlib |
| import OAI.Probability.SKFluctuations.CumulativeIncrements |
|
|
| namespace OAI |
|
|
| /-! Chain. -/ |
|
|
| 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 |
| open scoped Topology NNReal BigOperators |
|
|
| theorem ExpClose.chain (p : ℕ → ℝ) (E : ℕ → ℝ) (N : ℕ) (hp : 0 ≤ p 0) |
| (hE : ∀ j < N, ExpClose (E j) (p j) (p (j+1))) : |
| ExpClose (∑ j ∈ Finset.range N, E j) (p 0) (p N) := by |
| induction N with |
| | zero => simpa only [Finset.range_zero,Finset.sum_empty] using ExpClose.refl hp |
| | succ N ih => |
| simpa only [Finset.sum_range_succ] using |
| (ih (fun j hj => hE j (Nat.lt_succ_of_lt hj))).trans (hE N (Nat.lt_succ_self _)) |
|
|
| variable {S : Type*} {as : List PositiveMass} |
| variable [Fintype S] [Nonempty S] {n : ℕ} |
|
|
| |
|
|
| theorem ClockTree.cumulative_lowering_close {w : S → ℝ} (hw : ∀ σ, 0 < w σ) |
| (φ : S → (Fin (n+1) → ℝ) →L[ℝ] ℝ) (T : ClockTree S as) |
| (ho : MassOrdered 0 as) (D M : Fin (n+1) → ℝ) |
| (hD : ∀ i, 0 ≤ D i) (hB : ∀ i σ, |φ σ (Pi.single i 1)| ≤ D i) |
| (l : Fin (n+1) → ℝ) (q r : ℕ → Fin (n+1) → ℝ) |
| (hq : ∀ i, Monotone (fun j => q j i)) (hr : ∀ i, Monotone (fun j => r j i)) |
| (hql : ∀ i, l i ≤ q 0 i) (hrl : ∀ i, l i ≤ r 0 i) |
| (hM : ∀ i, 0 ≤ M i) (hm : ∀ i j, j < as.length → |q j i-r j i| ≤ M i) |
| (σ : T.Assignment) (x : Fin (n+1) → ℝ) : |
| ExpClose ((7*(T.leaves:ℝ)+8*(T.leaves:ℝ)^2*(T.leaves+1:ℝ))*∑ i, M i*(D i)^2) |
| (T.weight w φ (cumulativeIncrements l q) σ x) |
| (T.weight w φ (cumulativeIncrements l (loweredBoundary (as.length-1) q r)) σ x) := by |
| let K : ℝ := ∑ i, M i*(D i)^2 |
| have hK : 0 ≤ K := Finset.sum_nonneg fun i _ => mul_nonneg (hM i) (sq_nonneg _) |
| let E := fun j => (7*(T.leaves:ℝ)*massGap as j+8*(T.leaves:ℝ)*(T.leaves+1:ℝ)*T.forksAt (j+1))*K |
| have hstep (j : ℕ) (hj : j < as.length-1) : |
| ExpClose (E j) (T.weight w φ (cumulativeIncrements l (loweredBoundary j q r)) σ x) |
| (T.weight w φ (cumulativeIncrements l (loweredBoundary (j+1) q r)) σ x) := by |
| have hh := T.cumulative_boundary_close_at hw φ ho j (by omega) D hD hB l (loweredBoundary j q r) |
| (fun i => min (q j i) (r j i)) (loweredBoundary_previous hq hr hql hrl j) |
| (fun i => by simp only [loweredBoundary,lt_self_iff_false,ite_false]; exact min_le_left _ _) |
| (fun i => loweredBoundary_mono hq hr j i (Nat.le_succ j)) σ x |
| rw [←loweredBoundary_update] at hh |
| apply hh.mono |
| apply mul_le_mul_of_nonneg_left _ (by |
| have hg := massGap_nonneg as j |
| positivity) |
| exact Finset.sum_le_sum fun i _ => mul_le_mul_of_nonneg_right |
| ((loweredBoundary_difference j i).trans (hm i j (by omega))) (sq_nonneg _) |
| have hh := ExpClose.chain |
| (fun j => T.weight w φ (cumulativeIncrements l (loweredBoundary j q r)) σ x) |
| E (as.length-1) ((T.weight_probability hw φ ho _ x).1 σ) hstep |
| rw [loweredBoundary_zero] at hh |
| apply hh.mono |
| have hg := massGap_sum_prefix_le_one ho (as.length-1) (by omega) |
| have hf := T.forks_sum_shift_le (as.length-1) (by omega) |
| have hgm := mul_le_mul_of_nonneg_left hg (show 0 ≤ 7*(T.leaves:ℝ) by positivity) |
| have hfm := mul_le_mul_of_nonneg_left hf (show 0 ≤ 8*(T.leaves:ℝ)*(T.leaves+1:ℝ) by positivity) |
| dsimp only [E] |
| rw [←Finset.sum_mul,Finset.sum_add_distrib,←Finset.mul_sum,←Finset.mul_sum] |
| apply mul_le_mul_of_nonneg_right _ hK |
| nlinarith |
|
|
| |
|
|
| theorem ClockTree.cumulative_uniform_close {w : S → ℝ} (hw : ∀ σ, 0 < w σ) |
| (φ : S → (Fin (n+1) → ℝ) →L[ℝ] ℝ) (T : ClockTree S as) |
| (ho : MassOrdered 0 as) (D M : Fin (n+1) → ℝ) |
| (hD : ∀ i, 0 ≤ D i) (hB : ∀ i σ, |φ σ (Pi.single i 1)| ≤ D i) |
| (l : Fin (n+1) → ℝ) (q r : ℕ → Fin (n+1) → ℝ) |
| (hq : ∀ i, Monotone (fun j => q j i)) (hr : ∀ i, Monotone (fun j => r j i)) |
| (hql : ∀ i, l i ≤ q 0 i) (hrl : ∀ i, l i ≤ r 0 i) |
| (hend : q (as.length-1) = r (as.length-1)) |
| (hM : ∀ i, 0 ≤ M i) (hm : ∀ i j, j < as.length → |q j i-r j i| ≤ M i) |
| (σ : T.Assignment) (x : Fin (n+1) → ℝ) : |
| ExpClose (2*(7*(T.leaves:ℝ)+8*(T.leaves:ℝ)^2*(T.leaves+1:ℝ))*∑ i, M i*(D i)^2) |
| (T.weight w φ (cumulativeIncrements l q) σ x) (T.weight w φ (cumulativeIncrements l r) σ x) := by |
| have hQ := T.cumulative_lowering_close hw φ ho D M hD hB l q r hq hr hql hrl hM hm σ x |
| have hR := T.cumulative_lowering_close hw φ ho D M hD hB l r q hr hq hrl hql hM |
| (fun i j hj => by rw [abs_sub_comm]; exact hm i j hj) σ x |
| have he (σ : T.Assignment) : |
| T.weight w φ (cumulativeIncrements l (loweredBoundary (as.length-1) q r)) σ x = |
| T.weight w φ (cumulativeIncrements l (loweredBoundary (as.length-1) r q)) σ x := by |
| apply T.cumulative_weight_congr w φ l _ σ x |
| intro k hk |
| funext i |
| by_cases hkl : k < as.length-1 |
| · simp only [loweredBoundary,hkl,ite_true,min_comm] |
| · have hek : k=as.length-1 := by omega |
| subst k |
| simp only [loweredBoundary,lt_self_iff_false,ite_false] |
| exact congrFun hend i |
| rw [he σ] at hQ |
| convert hQ.trans hR.symm using 1 |
| ring |
|
|
| 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_close {w : S → ℝ} (hw : ∀ σ, 0 < w σ) |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) (L : (Fin (n+1) → ℝ) →L[ℝ] (ι → ℝ)) |
| {steps : List (GaussianStep ι)} (R : ReplicaTree ι S steps) {a b : ℝ} |
| (hoa : OrderedSteps a steps) (hob : 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 : ι → ℝ) : |
| ExpClose ((|a-b| *(2*(R.leaves:ℝ)+3)*∑ i, (D i)^2)*t) |
| (linearClockTest L a (gaussianHierarchy w φ steps) (R.expect w φ P) t x) |
| (linearClockTest L b (gaussianHierarchy w φ steps) (R.expect w φ P) t x) := by |
| apply ExpClose.of_bounds (R.clock_nonneg hw φ L hoa hp t x) (R.clock_nonneg hw φ L hob hp t x) |
| let J := replicaFeatureJet hw φ L R hob P x |
| have hh := J.massSplit_exp_comparison D hD |
| (fun y => R.expect_nonneg hw φ hob hp (x+L y)) |
| (replicaFeatureJet_G_abs_le hw φ L R hob P x D hB) |
| (replicaFeatureJet_A₁_relative_abs_le hw φ L R hob 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 |
| rw [J.massSplit_zero,J.massSplit_terminal,sub_zero,abs_of_nonneg ht] at hh |
| have hF := (gaussianHierarchy_regular hw φ steps hob 0).1.choose_spec.continuous |
| have hA := (R.expect_smooth hw φ hob P 0).continuous |
| simpa only [J,replicaFeatureJet_F,replicaFeatureJet_A,← linearClockTest_eq L hF hA,neg_mul] using hh |
|
|
| theorem ClockTree.atomicHead_mass_close_nonneg {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 hh := (T.realize q).linearClock_mass_close hw φ (diagonalDriver v) |
| (clockSteps_ordered hoa q) (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 ha1 hb hb1 |
| (by norm_num : (0:ℝ) ≤ 1) x |
| 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 hh |
|
|
| |
|
|
| theorem ClockTree.atomicHead_root_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) |
| (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 ((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 0 σ x) (T.weight w φ (addHeadClock q v) σ x) := by |
| have hb1 : b.val ≤ 1 := (massOrdered_bounds ho).2 |
| have h₁ := T.atomicHead_mass_close_nonneg hw φ ⟨le_rfl,b.property.le,ho⟩ ⟨b.property.le,le_rfl,ho⟩ |
| le_rfl (by norm_num) b.property hb1 D hD hB q v σ x |
| have h₂ := T.atomicHead_crossing_close hw φ rfl ho D hD hB q v σ x |
| simp only [zero_sub,abs_neg,abs_of_pos b.property] at h₁ |
| convert h₁.trans h₂ using 1 |
| ring |
|
|
| end SKFluctuations.Hierarchy |
|
|
| namespace SKFluctuations.Hierarchy |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped Topology NNReal BigOperators |
|
|
| theorem ExpClose.integral {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} |
| {c : ℝ} {p q : Ω → ℝ} (hp : Integrable p μ) (hq : Integrable q μ) |
| (h : ∀ x, ExpClose c (p x) (q x)) : ExpClose c (∫ x, p x ∂μ) (∫ x, q x ∂μ) := by |
| refine ⟨integral_nonneg fun x => (h x).left_nonneg,integral_nonneg fun x => (h x).right_nonneg,?_,?_⟩ |
| · calc |
| _ ≤ ∫ x, Real.exp c*q x ∂μ := integral_mono hp (hq.const_mul _) fun x => (h x).le_mul |
| _ = _ := integral_const_mul _ _ |
| · calc |
| _ ≤ ∫ x, Real.exp c*p x ∂μ := integral_mono hq (hp.const_mul _) fun x => (h x).rev_le_mul |
| _ = _ := integral_const_mul _ _ |
|
|
| variable {S : Type*} [Fintype S] [Nonempty S] {n : ℕ} {as : List PositiveMass} |
|
|
| omit [Nonempty S] in |
| theorem ClockTree.expect_close (w : S → ℝ) (φ : S → (Fin (n+1) → ℝ) →L[ℝ] ℝ) |
| (T : ClockTree S as) (q r : ℕ → Fin (n+1) → ℝ≥0) (P : T.Assignment → ℝ) |
| (hP : ∀ σ, 0 ≤ P σ) {C : ℝ} (x : Fin (n+1) → ℝ) |
| (h : ∀ σ, ExpClose C (T.weight w φ q σ x) (T.weight w φ r σ x)) : |
| ExpClose C (T.expect w φ q P x) (T.expect w φ r P x) := by |
| unfold ClockTree.expect |
| apply ExpClose.finset_sum |
| intro σ _ |
| simpa only [add_zero] using (h σ).mul (ExpClose.refl (hP σ)) |
|
|
| |
|
|
| theorem ClockTree.root_close {w : S → ℝ} (hw : ∀ σ, 0 < w σ) |
| (φ : S → (Fin (n+1) → ℝ) →L[ℝ] ℝ) (T : ClockTree S as) (ho : MassOrdered 0 as) |
| (q r : ℕ → Fin (n+1) → ℝ≥0) (v : Fin (n+1) → ℝ≥0) {C : ℝ} |
| (h : ∀ σ x, ExpClose C (T.weight w φ q σ x) (T.weight w φ r σ x)) |
| (σ : T.Assignment) (x : Fin (n+1) → ℝ) : |
| ExpClose C (T.atomicHead w φ q v 0 σ x) (T.atomicHead w φ r v 0 σ x) := by |
| simp only [ClockTree.atomicHead,shiftedMean_zero,zeroContinuation] |
| exact ExpClose.integral ((T.weight_smooth hw φ ho q σ 0).integrable_zero_shift x) |
| ((T.weight_smooth hw φ ho r σ 0).integrable_zero_shift x) (fun z => h σ (x+z)) |
|
|
| theorem ClockTree.cumulative_uniform_expect_close {w : S → ℝ} (hw : ∀ σ, 0 < w σ) |
| (φ : S → (Fin (n+1) → ℝ) →L[ℝ] ℝ) (T : ClockTree S as) |
| (ho : MassOrdered 0 as) (D M : Fin (n+1) → ℝ) |
| (hD : ∀ i, 0 ≤ D i) (hB : ∀ i σ, |φ σ (Pi.single i 1)| ≤ D i) |
| (l : Fin (n+1) → ℝ) (q r : ℕ → Fin (n+1) → ℝ) |
| (hq : ∀ i, Monotone (fun j => q j i)) (hr : ∀ i, Monotone (fun j => r j i)) |
| (hql : ∀ i, l i ≤ q 0 i) (hrl : ∀ i, l i ≤ r 0 i) |
| (hend : q (as.length-1) = r (as.length-1)) |
| (hM : ∀ i, 0 ≤ M i) (hm : ∀ i j, j < as.length → |q j i-r j i| ≤ M i) |
| (P : T.Assignment → ℝ) (hP : ∀ σ, 0 ≤ P σ) (x : Fin (n+1) → ℝ) : |
| ExpClose (2*(7*(T.leaves:ℝ)+8*(T.leaves:ℝ)^2*(T.leaves+1:ℝ))*∑ i, M i*(D i)^2) |
| (T.expect w φ (cumulativeIncrements l q) P x) (T.expect w φ (cumulativeIncrements l r) P x) := |
| T.expect_close w φ _ _ P hP x (fun σ => T.cumulative_uniform_close hw φ ho D M hD hB l q r |
| hq hr hql hrl hend hM hm σ x) |
|
|
| end SKFluctuations.Hierarchy |
|
|
| namespace SKFluctuations.Hierarchy |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped Topology NNReal BigOperators |
|
|
| theorem ExpClose.limit_cost {α : Type*} {l : Filter α} [NeBot l] |
| {c : α → ℝ} {C p q : ℝ} (hc : Tendsto c l (𝓝 C)) |
| (h : ∀ᶠ a in l, ExpClose (c a) p q) : ExpClose C p q := by |
| obtain ⟨a,ha⟩ := h.exists |
| refine ⟨ha.left_nonneg,ha.right_nonneg,?_,?_⟩ |
| · exact ge_of_tendsto (((Real.continuous_exp.tendsto C).comp hc).mul_const q) (h.mono fun _ hs => hs.le_mul) |
| · exact ge_of_tendsto (((Real.continuous_exp.tendsto C).comp hc).mul_const p) (h.mono fun _ hs => hs.rev_le_mul) |
|
|
| theorem MassOrdered.exists_positive_lower {as : List PositiveMass} (ho : MassOrdered 0 as) : |
| ∃ δ : ℝ, 0 < δ ∧ ∀ e : ℝ, 0 ≤ e → e ≤ δ → MassOrdered e as := by |
| cases as with |
| | nil => exact ⟨1,by norm_num,fun _ he he1 => ⟨he,he1⟩⟩ |
| | cons a as => exact ⟨a.val,a.property,fun _ he hea => ⟨he,hea,ho.2.2⟩⟩ |
|
|
| variable {S : Type*} [Fintype S] [Nonempty S] {n : ℕ} {as : List PositiveMass} |
|
|
| |
|
|
| def ClockTree.rootWeight (w : S → ℝ) (φ : S → (Fin (n+1) → ℝ) →L[ℝ] ℝ) |
| (T : ClockTree S as) (l : Fin (n+1) → ℝ) (q : ℕ → Fin (n+1) → ℝ) |
| (σ : T.Assignment) (x : Fin (n+1) → ℝ) : ℝ := |
| T.atomicHead w φ (cumulativeIncrements (q 0) (fun k => q (k+1))) |
| (fun i => Real.toNNReal (q 0 i-l i)) 0 σ x |
|
|
| |
|
|
| theorem ClockTree.rootCumulative_uniform_close {w : S → ℝ} (hw : ∀ σ, 0 < w σ) |
| (φ : S → (Fin (n+1) → ℝ) →L[ℝ] ℝ) (T : ClockTree S as) |
| (ho : MassOrdered 0 as) (D M : Fin (n+1) → ℝ) |
| (hD : ∀ i, 0 ≤ D i) (hB : ∀ i σ, |φ σ (Pi.single i 1)| ≤ D i) |
| (l : Fin (n+1) → ℝ) (q r : ℕ → Fin (n+1) → ℝ) |
| (hq : ∀ i, Monotone (fun j => q j i)) (hr : ∀ i, Monotone (fun j => r j i)) |
| (hql : ∀ i, l i ≤ q 0 i) (hrl : ∀ i, l i ≤ r 0 i) |
| (hend : q as.length = r as.length) |
| (hM : ∀ i, 0 ≤ M i) (hm : ∀ i j, j ≤ as.length → |q j i-r j i| ≤ M i) |
| (σ : T.Assignment) (x : Fin (n+1) → ℝ) : |
| ExpClose (2*(7*(T.leaves:ℝ)+8*(T.leaves:ℝ)^2*(T.leaves+1:ℝ))*∑ i, M i*(D i)^2) |
| (T.rootWeight w φ l q σ x) (T.rootWeight w φ l r σ x) := by |
| let C := 2*(7*(T.leaves:ℝ)+8*(T.leaves:ℝ)^2*(T.leaves+1:ℝ))*∑ i, M i*(D i)^2 |
| let Kq := (2*(T.leaves:ℝ)+3)*∑ i, (Real.toNNReal (q 0 i-l i):ℝ)*(D i)^2 |
| let Kr := (2*(T.leaves:ℝ)+3)*∑ i, (Real.toNNReal (r 0 i-l i):ℝ)*(D i)^2 |
| obtain ⟨δ,hδ,hd⟩ := ho.exists_positive_lower |
| have hc : Continuous (fun e : ℝ => (e*Kq+C)+e*Kr) := by fun_prop |
| apply ExpClose.limit_cost (l := 𝓝[>] (0:ℝ)) |
| (c := fun e => (e*Kq+C)+e*Kr) |
| (by simpa only [zero_mul,zero_add,add_zero] using |
| ((hc.tendsto (0:ℝ)).mono_left nhdsWithin_le_nhds)) |
| filter_upwards [self_mem_nhdsWithin, |
| (Iio_mem_nhds hδ : Iio δ ∈ 𝓝 (0:ℝ)) |> mem_nhdsWithin_of_mem_nhds] with e he heδ |
| have hep : 0 < e := he |
| have hoe := hd e hep.le heδ.le |
| have he1 := (massOrdered_bounds hoe).2 |
| let a : PositiveMass := ⟨e,hep⟩ |
| have hQ := T.atomicHead_mass_close_nonneg hw φ ho hoe le_rfl (by norm_num) hep he1 D hD hB |
| (cumulativeIncrements (q 0) (fun k => q (k+1))) (fun i => Real.toNNReal (q 0 i-l i)) σ x |
| have hR := T.atomicHead_mass_close_nonneg hw φ ho hoe le_rfl (by norm_num) hep he1 D hD hB |
| (cumulativeIncrements (r 0) (fun k => r (k+1))) (fun i => Real.toNNReal (r 0 i-l i)) σ x |
| have hE := (T.step a).cumulative_uniform_close hw φ ⟨le_rfl,hep.le,hoe⟩ D M hD hB l q r |
| hq hr hql hrl (by simpa only [List.length_cons,Nat.add_sub_cancel] using hend) hM |
| (fun i j hj => hm i j (by simpa only [List.length_cons,Nat.lt_add_one_iff] using hj)) σ x |
| simp only [ClockTree.weight_step,cumulativeIncrements_shift,ClockTree.leaves] at hE |
| change ExpClose C (T.atomicHead w φ _ _ e σ x) (T.atomicHead w φ _ _ e σ x) at hE |
| simp only [zero_sub,abs_neg,abs_of_pos hep] at hQ hR |
| convert (hQ.trans hE).trans hR.symm using 1 <;> |
| dsimp only [Kq,Kr,ClockTree.rootWeight] |
| ring |
|
|
| end SKFluctuations.Hierarchy |
|
|
| namespace SKFluctuations.Hierarchy |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped Topology NNReal BigOperators |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [MeasurableSpace E] [BorelSpace E] {ν : Measure E} |
|
|
| omit [NormedSpace ℝ E] [BorelSpace E] in |
| theorem shiftedMean_add_const (F A : E → ℝ) (m c : ℝ) (x : E) : |
| shiftedMean ν m (fun y => F y+c) A x = shiftedMean ν m F A x := by |
| simp only [shiftedMean,tiltedMean,mul_add,Real.exp_add,← mul_assoc] |
| rw [integral_mul_const,integral_mul_const] |
| exact mul_div_mul_right _ _ (Real.exp_ne_zero _) |
|
|
| variable {ι S : Type*} [Fintype ι] [DecidableEq ι] [Fintype S] [Nonempty S] |
|
|
| theorem spinWeight_mass_one {w : S → ℝ} (hw : ∀ σ, 0 < w σ) |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) (q : ι → ℝ≥0) (C : ι → ℝ) |
| (hC : ∀ σ i, (φ σ (Pi.single i 1))^2 = C i) (σ : S) (x : ι → ℝ) : |
| shiftedMean (Measure.pi fun i => gaussianReal 0 (q i)) 1 (spinLogPartition w φ) |
| (fun y => spinWeight w φ y σ) x = spinWeight w φ x σ := by |
| have hd := exp_mul_shiftedContinuation (by norm_num : (1:ℝ) ≠ 0) x |
| ((exponentialIncrement_gaussian q).integrable_shift (lipschitzWith_spinLogPartition hw φ) 1 x) |
| rw [spinLogPartition_mass_one hw φ q C hC x,one_mul,Real.exp_add,spinLogPartition, |
| Real.exp_log (spinPartition_pos hw φ x)] at hd |
| unfold shiftedMean tiltedMean |
| rw [← hd] |
| have hn : (∫ z, spinWeight w φ (x+z) σ*Real.exp (1*spinLogPartition w φ (x+z)) |
| ∂Measure.pi fun i => gaussianReal 0 (q i)) = |
| w σ*Real.exp (φ σ x)*Real.exp ((1/2:ℝ)*∑ i, (q i:ℝ)*C i) := by |
| simp only [one_mul,spinLogPartition,Real.exp_log (spinPartition_pos hw φ _),spinWeight, |
| div_mul_cancel₀ _ (spinPartition_pos hw φ _).ne'] |
| simp_rw [map_add,Real.exp_add] |
| rw [integral_const_mul,integral_const_mul,integral_exp_finiteLinear] |
| simp_rw [hC] |
| ring |
| rw [hn,mul_div_mul_right _ _ (Real.exp_ne_zero _)] |
| rfl |
| |
| end SKFluctuations.Hierarchy |
| |
| namespace SKFluctuations.Hierarchy |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped Topology NNReal BigOperators |
| universe vC |
| variable {S : Type vC} {ι : Type*} |
| |
| def terminalMass : PositiveMass := ⟨1,by norm_num⟩ |
| |
| |
| def ClockTree.extendOne : {as : List PositiveMass} → ClockTree S as → ClockTree S (as++[terminalMass]) |
| | _,.leaf => .step terminalMass .leaf |
| | _,.step a T => .step a T.extendOne |
| | _,.fork T U => .fork T.extendOne U.extendOne |
| |
| noncomputable def ClockTree.extendOneEquiv : {as : List PositiveMass} → (T : ClockTree S as) → |
| T.Assignment ≃ T.extendOne.Assignment |
| | _,.leaf => Equiv.refl S |
| | _,.step _ T => T.extendOneEquiv |
| | _,.fork T U => Equiv.prodCongr T.extendOneEquiv U.extendOneEquiv |
| |
| theorem ClockTree.extendOne_leaves {as : List PositiveMass} (T : ClockTree S as) : |
| T.extendOne.leaves = T.leaves := by |
| induction T with |
| | leaf => rfl |
| | step a T ih => exact ih |
| | fork T U ihT ihU => exact congrArg₂ (·+·) ihT ihU |
| |
| theorem MassOrdered.append_one {as : List PositiveMass} {a : ℝ} (ho : MassOrdered a as) : |
| MassOrdered a (as++[terminalMass]) := by |
| induction as generalizing a with |
| | nil => exact ⟨ho.1,ho.2,by norm_num [MassOrdered,terminalMass]⟩ |
| | cons b bs ih => exact ⟨ho.1,ho.2.1,ih ho.2.2⟩ |
| |
| variable [Fintype ι] [DecidableEq ι] [Fintype S] [Nonempty S] |
| |
| |
| |
| theorem ClockTree.weight_extendOne {w : S → ℝ} (hw : ∀ σ, 0 < w σ) |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) (C : ι → ℝ) |
| (hC : ∀ σ i, (φ σ (Pi.single i 1))^2 = C i) |
| {as : List PositiveMass} (T : ClockTree S as) {a : ℝ} (ho : MassOrdered a as) |
| (q : ℕ → ι → ℝ≥0) (σ : T.Assignment) (x : ι → ℝ) : |
| T.extendOne.weight w φ q (T.extendOneEquiv σ) x = T.weight w φ q σ x := by |
| induction T generalizing a q x with |
| | leaf => exact spinWeight_mass_one hw φ (q 0) C hC σ x |
| | @step b bs T ih => |
| change (T.extendOne.step b).weight w φ q (T.extendOneEquiv σ) x = (T.step b).weight w φ q σ x |
| rw [ClockTree.weight_step,ClockTree.weight_step] |
| have he : T.extendOne.weight w φ (fun j => q (j+1)) (T.extendOneEquiv σ) = |
| T.weight w φ (fun j => q (j+1)) σ := funext (ih ho.2.2 _ σ) |
| rw [he,clockSteps_append] |
| simp only [clockSteps,Nat.add_zero,terminalMass] |
| have hg := gaussianHierarchy_append_mass_one hw φ (q (bs.length+1)) C hC |
| (clockSteps bs (fun j => q (j+1))) (clockSteps_ordered ho.2.2 _) |
| rw [show gaussianHierarchy w φ (clockSteps bs (fun j => q (j+1)) ++ [(1,q (bs.length+1))]) = |
| (fun y => gaussianHierarchy w φ (clockSteps bs (fun j => q (j+1))) y+ |
| (1/2:ℝ)*∑ i, (q (bs.length+1) i:ℝ)*C i) from funext hg] |
| exact shiftedMean_add_const _ _ _ _ _ |
| | fork T U ihT ihU => |
| change T.extendOne.weight w φ q (T.extendOneEquiv σ.1) x* |
| U.extendOne.weight w φ q (U.extendOneEquiv σ.2) x = T.weight w φ q σ.1 x*U.weight w φ q σ.2 x |
| rw [ihT ho,ihU ho] |
| |
| end SKFluctuations.Hierarchy |
| |
| namespace SKFluctuations.Hierarchy |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped Topology NNReal BigOperators |
| variable {S : Type*} [Fintype S] [Nonempty S] {n : ℕ} {as : List PositiveMass} |
| |
| omit [Nonempty S] in |
| theorem ClockTree.rootWeight_congr (w : S → ℝ) (φ : S → (Fin (n+1) → ℝ) →L[ℝ] ℝ) |
| (T : ClockTree S as) (l : Fin (n+1) → ℝ) {q r : ℕ → Fin (n+1) → ℝ} |
| (he : ∀ j ≤ as.length, q j = r j) (σ : T.Assignment) (x : Fin (n+1) → ℝ) : |
| T.rootWeight w φ l q σ x = T.rootWeight w φ l r σ x := by |
| simp only [ClockTree.rootWeight,ClockTree.atomicHead,shiftedMean_zero,zeroContinuation] |
| rw [he 0 (Nat.zero_le _)] |
| apply integral_congr_ae |
| filter_upwards [] with z |
| exact T.cumulative_weight_congr w φ (r 0) (fun j hj => he (j+1) (by omega)) σ (x+z) |
| |
| theorem ClockTree.rootWeight_extendOne {w : S → ℝ} (hw : ∀ σ, 0 < w σ) |
| (φ : S → (Fin (n+1) → ℝ) →L[ℝ] ℝ) (C : Fin (n+1) → ℝ) |
| (hC : ∀ σ i, (φ σ (Pi.single i 1))^2 = C i) |
| (T : ClockTree S as) (ho : MassOrdered 0 as) |
| (l : Fin (n+1) → ℝ) (q : ℕ → Fin (n+1) → ℝ) |
| (σ : T.Assignment) (x : Fin (n+1) → ℝ) : |
| T.extendOne.rootWeight w φ l q (T.extendOneEquiv σ) x = T.rootWeight w φ l q σ x := by |
| simp only [ClockTree.rootWeight,ClockTree.atomicHead,shiftedMean_zero,zeroContinuation] |
| apply integral_congr_ae |
| filter_upwards [] with z |
| exact T.weight_extendOne hw φ C hC ho _ σ (x+z) |
| |
| |
| |
| theorem ClockTree.rootCumulative_close {w : S → ℝ} (hw : ∀ σ, 0 < w σ) |
| (φ : S → (Fin (n+1) → ℝ) →L[ℝ] ℝ) (C : Fin (n+1) → ℝ) |
| (hC : ∀ σ i, (φ σ (Pi.single i 1))^2 = C i) |
| (T : ClockTree S as) (ho : MassOrdered 0 as) (D M : Fin (n+1) → ℝ) |
| (hD : ∀ i, 0 ≤ D i) (hB : ∀ i σ, |φ σ (Pi.single i 1)| ≤ D i) |
| (l : Fin (n+1) → ℝ) (q r : ℕ → Fin (n+1) → ℝ) |
| (hq : ∀ i, Monotone (fun j => q j i)) (hr : ∀ i, Monotone (fun j => r j i)) |
| (hql : ∀ i, l i ≤ q 0 i) (hrl : ∀ i, l i ≤ r 0 i) |
| (hM : ∀ i, 0 ≤ M i) (hm : ∀ i j, j ≤ as.length → |q j i-r j i| ≤ M i) |
| (σ : T.Assignment) (x : Fin (n+1) → ℝ) : |
| ExpClose (2*(7*(T.leaves:ℝ)+8*(T.leaves:ℝ)^2*(T.leaves+1:ℝ))*∑ i, M i*(D i)^2) |
| (T.rootWeight w φ l q σ x) (T.rootWeight w φ l r σ x) := by |
| let t := fun i => max (q as.length i) (r as.length i) |
| let Q := extendBoundary q as.length t |
| let R := extendBoundary r as.length t |
| have hQ : ∀ j ≤ as.length, Q j = q j := fun j hj => extendBoundary_le _ _ _ hj |
| have hR : ∀ j ≤ as.length, R j = r j := fun j hj => extendBoundary_le _ _ _ hj |
| have hQT : ∀ j, as.length < j → Q j = t := fun j hj => extendBoundary_gt _ _ _ hj |
| have hRT : ∀ j, as.length < j → R j = t := fun j hj => extendBoundary_gt _ _ _ hj |
| have hE := T.extendOne.rootCumulative_uniform_close hw φ ho.append_one D M hD hB l Q R |
| (extendBoundary_monotone hq (fun i => le_max_left _ _)) |
| (extendBoundary_monotone hr (fun i => le_max_right _ _)) |
| (fun i => by rw [hQ 0 (Nat.zero_le _)]; exact hql i) |
| (fun i => by rw [hR 0 (Nat.zero_le _)]; exact hrl i) |
| (by rw [hQT _ (by simp),hRT _ (by simp)]) hM |
| (fun i j _ => by |
| by_cases hj : j ≤ as.length |
| · rw [hQ j hj,hR j hj]; exact hm i j hj |
| · rw [hQT j (lt_of_not_ge hj),hRT j (lt_of_not_ge hj),sub_self,abs_zero]; exact hM i) |
| (T.extendOneEquiv σ) x |
| rw [T.rootWeight_extendOne hw φ C hC ho,T.rootWeight_extendOne hw φ C hC ho, |
| T.rootWeight_congr w φ l hQ σ x,T.rootWeight_congr w φ l hR σ x,ClockTree.extendOne_leaves] at hE |
| exact hE |
| |
| end SKFluctuations.Hierarchy |
| |
| namespace SKFluctuations.Hierarchy.ReplicaTree |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped Topology NNReal BigOperators |
| variable {ι S : Type*} |
| |
| |
| |
| @[reducible] def Slot : {steps : List (GaussianStep ι)} → ReplicaTree ι S steps → Type |
| | _, .leaf => Unit |
| | _, .step _ T => T.Slot |
| | _, .fork T U => T.Slot ⊕ U.Slot |
| |
| def atSlot : {steps : List (GaussianStep ι)} → (T : ReplicaTree ι S steps) → T.Assignment → T.Slot → S |
| | _, .leaf => fun σ _ => σ |
| | _, .step _ T => T.atSlot |
| | _, .fork T U => fun σ s => Sum.elim (T.atSlot σ.1) (U.atSlot σ.2) s |
| |
| def singleSlot : (steps : List (GaussianStep ι)) → (single (S := S) steps).Slot |
| | [] => () |
| | _::tail => singleSlot tail |
| |
| theorem atSlot_single (steps : List (GaussianStep ι)) (σ : (single (S := S) steps).Assignment) : |
| (single steps).atSlot σ (singleSlot steps) = singleEquiv (S := S) steps σ := by |
| induction steps with |
| | nil => rfl |
| | cons st tail ih => exact ih σ |
| |
| |
| |
| structure MarkedPlacement {steps : List (GaussianStep ι)} (T : ReplicaTree ι S steps) extends Placement T where |
| embed : T.Slot → tree.Slot |
| mark : tree.Slot |
| restrict_at : ∀ σ s, T.atSlot (restrict σ) s = tree.atSlot σ (embed s) |
| spin_at : ∀ σ, spin σ = tree.atSlot σ mark |
| |
| namespace MarkedPlacement |
| |
| def fresh {steps : List (GaussianStep ι)} (T : ReplicaTree ι S steps) (c : ℝ) : MarkedPlacement T where |
| toPlacement := Placement.fresh T c |
| embed := Sum.inl |
| mark := Sum.inr (singleSlot steps) |
| restrict_at := fun _ _ => rfl |
| spin_at := fun σ => (atSlot_single steps σ.2).symm |
| |
| def coincide : MarkedPlacement (ReplicaTree.leaf (ι := ι) (S := S)) where |
| toPlacement := Placement.coincide |
| embed := id |
| mark := () |
| restrict_at := fun _ _ => rfl |
| spin_at := fun _ => rfl |
| |
| def step (st : GaussianStep ι) {tail : List (GaussianStep ι)} {T : ReplicaTree ι S tail} |
| (p : MarkedPlacement T) : MarkedPlacement (T.step st) where |
| toPlacement := p.toPlacement.step st |
| embed := p.embed |
| mark := p.mark |
| restrict_at := p.restrict_at |
| spin_at := p.spin_at |
| |
| def left {steps : List (GaussianStep ι)} {T : ReplicaTree ι S steps} |
| (U : ReplicaTree ι S steps) (p : MarkedPlacement T) : MarkedPlacement (T.fork U) where |
| toPlacement := p.toPlacement.left U |
| embed := Sum.map p.embed id |
| mark := Sum.inl p.mark |
| restrict_at := by intro σ s; cases s with |
| | inl s => exact p.restrict_at σ.1 s |
| | inr s => rfl |
| spin_at := fun σ => p.spin_at σ.1 |
| |
| def right {steps : List (GaussianStep ι)} (T : ReplicaTree ι S steps) |
| {U : ReplicaTree ι S steps} (p : MarkedPlacement U) : MarkedPlacement (T.fork U) where |
| toPlacement := p.toPlacement.right T |
| embed := Sum.map id p.embed |
| mark := Sum.inr p.mark |
| restrict_at := by intro σ s; cases s with |
| | inl s => rfl |
| | inr s => exact p.restrict_at σ.2 s |
| spin_at := fun σ => p.spin_at σ.2 |
| end MarkedPlacement |
| |
| def markedAttach : {steps : List (GaussianStep ι)} → (T : ReplicaTree ι S steps) → ℝ → List (MarkedPlacement T) |
| | _, .leaf, a => [MarkedPlacement.coincide,MarkedPlacement.fresh .leaf (a-1)] |
| | _, @ReplicaTree.step _ _ st tail T, a => |
| MarkedPlacement.fresh (.step st T) (a-st.1) :: (T.markedAttach st.1).map (MarkedPlacement.step st) |
| | _, .fork T U, a => MarkedPlacement.fresh (T.fork U) (-a) :: |
| ((T.markedAttach a).map (MarkedPlacement.left U) ++ (U.markedAttach a).map (MarkedPlacement.right T)) |
| |
| theorem markedAttach_forget {steps : List (GaussianStep ι)} (T : ReplicaTree ι S steps) (a : ℝ) : |
| (T.markedAttach a).map MarkedPlacement.toPlacement = T.attach a := by |
| induction T generalizing a with |
| | leaf => rfl |
| | step st T ih => |
| simp only [markedAttach,attach,List.map_cons,List.map_map] |
| rw [← ih st.1,List.map_map] |
| rfl |
| | fork T U ihT ihU => |
| simp only [markedAttach,attach,List.map_cons,List.map_append,List.map_map] |
| rw [← ihT a,← ihU a,List.map_map,List.map_map] |
| rfl |
| |
| theorem markedAttach_mass {steps : List (GaussianStep ι)} (T : ReplicaTree ι S steps) (a : ℝ) : |
| ((T.markedAttach a).map fun p => p.coeff).sum = a := by |
| have h := T.attach_mass a |
| rw [← T.markedAttach_forget a] at h |
| simpa only [mass,List.map_map,Function.comp_def] using h |
| |
| noncomputable def MarkedPlacement.hit {steps : List (GaussianStep ι)} {T : ReplicaTree ι S steps} |
| (p : MarkedPlacement T) (s : T.Slot) : ℝ := by |
| classical |
| exact if p.mark = p.embed s then 1 else 0 |
| |
| theorem MarkedPlacement.hit_fresh {steps : List (GaussianStep ι)} (T : ReplicaTree ι S steps) |
| (c : ℝ) (s : T.Slot) : (MarkedPlacement.fresh T c).hit s = 0 := by |
| classical |
| unfold MarkedPlacement.hit |
| apply ite_eq_right |
| intro h |
| cases h |
| |
| theorem MarkedPlacement.hit_step {steps : List (GaussianStep ι)} {T : ReplicaTree ι S steps} |
| (st : GaussianStep ι) (p : MarkedPlacement T) (s : T.Slot) : (p.step st).hit s = p.hit s := rfl |
| |
| theorem MarkedPlacement.coeff_step {steps : List (GaussianStep ι)} {T : ReplicaTree ι S steps} |
| (st : GaussianStep ι) (p : MarkedPlacement T) : (p.step st).coeff = p.coeff := rfl |
| |
| |
| |
| theorem markedAttach_hit {steps : List (GaussianStep ι)} (T : ReplicaTree ι S steps) (a : ℝ) (s : T.Slot) : |
| ((T.markedAttach a).map fun p => p.coeff*p.hit s).sum = 1 := by |
| classical |
| induction T generalizing a with |
| | leaf => cases s; simp [markedAttach,MarkedPlacement.hit,MarkedPlacement.coincide, |
| MarkedPlacement.fresh,Placement.coincide,Placement.fresh] |
| | step st T ih => |
| simp only [markedAttach,List.map_cons,List.sum_cons,List.map_map,Function.comp_def, |
| MarkedPlacement.hit_fresh,mul_zero,zero_add,MarkedPlacement.hit_step,MarkedPlacement.coeff_step] |
| exact ih st.1 s |
| | fork T U ihT ihU => |
| cases s with |
| | inl s => |
| simpa only [markedAttach,List.map_cons,List.sum_cons,List.map_append,List.sum_append,List.map_map, |
| Function.comp_def,MarkedPlacement.fresh,MarkedPlacement.left,MarkedPlacement.right, |
| Placement.fresh,Placement.left,Placement.right,MarkedPlacement.hit,Sum.map_inl,id_eq, |
| Sum.inr_ne_inl,Sum.inl.injEq,ite_false,mul_zero,List.map_const',List.sum_replicate,nsmul_zero, |
| zero_add,add_zero] using ihT a s |
| | inr s => |
| simpa only [markedAttach,List.map_cons,List.sum_cons,List.map_append,List.sum_append,List.map_map, |
| Function.comp_def,MarkedPlacement.fresh,MarkedPlacement.left,MarkedPlacement.right, |
| Placement.fresh,Placement.left,Placement.right,MarkedPlacement.hit,Sum.map_inr,id_eq, |
| Sum.inr_ne_inl,Sum.inl_ne_inr,Sum.inr.injEq,ite_false,mul_zero,List.map_const',List.sum_replicate,nsmul_zero, |
| zero_add,add_zero] using ihU a s |
| |
| |
| |
| theorem markedAttach_diagonal {steps : List (GaussianStep ι)} (T : ReplicaTree ι S steps) (a : ℝ) : |
| ((T.markedAttach a).map fun p => p.coeff * |
| ((p.tree.markedAttach a).map fun q => q.coeff*q.hit p.mark).sum).sum = a := by |
| simp only [markedAttach_hit,mul_one,markedAttach_mass] |
| |
| end SKFluctuations.Hierarchy.ReplicaTree |
| |
| end |
| |
| end OAI |
| |
