| import Mathlib | |
| import OAI.Probability.SKFluctuations.ClockPairRepresentation | |
| namespace OAI | |
| /-! Clock Zero Refinement. -/ | |
| noncomputable section | |
| namespace SKFluctuations.Hierarchy | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped Topology NNReal BigOperators | |
| variable {ι S : Type*} [Fintype ι] [Fintype S] | |
| theorem shiftedContinuation_zero_clock (F : (ι → ℝ) → ℝ) {m : ℝ} (hm : m ≠ 0) : | |
| shiftedContinuation (Measure.pi fun _ : ι => gaussianReal 0 0) m F = F := by | |
| funext x | |
| rw [isotropicGaussian_zero] | |
| simp [shiftedContinuation,hm] | |
| theorem shiftedMean_zero_clock (F A : (ι → ℝ) → ℝ) (m : ℝ) : | |
| shiftedMean (Measure.pi fun _ : ι => gaussianReal 0 0) m F A = A := by | |
| funext x | |
| rw [isotropicGaussian_zero] | |
| simp [shiftedMean,tiltedMean] | |
| theorem prefixContinuation_zero_insert (pre post : List (GaussianStep ι)) | |
| (F : (ι → ℝ) → ℝ) {m : ℝ} (hm : m ≠ 0) : | |
| prefixContinuation (pre++(m,0)::post) F = prefixContinuation (pre++post) F := by | |
| rw [prefixContinuation_append,prefixContinuation_append] | |
| simp only [prefixContinuation,Pi.zero_apply,shiftedContinuation_zero_clock _ hm] | |
| theorem prefixTest_zero_insert (pre post : List (GaussianStep ι)) | |
| (F A : (ι → ℝ) → ℝ) {m : ℝ} (hm : m ≠ 0) : | |
| prefixTest (pre++(m,0)::post) F A = prefixTest (pre++post) F A := by | |
| rw [prefixTest_append,prefixTest_append] | |
| simp only [prefixContinuation,prefixTest,Pi.zero_apply, | |
| shiftedContinuation_zero_clock _ hm,shiftedMean_zero_clock] | |
| inductive ZeroClockRefinement : List (GaussianStep ι) → List (GaussianStep ι) → Prop | |
| | refl (L) : ZeroClockRefinement L L | |
| | insert (pre post : List (GaussianStep ι)) (m : ℝ) (hm : 0 < m) : | |
| ZeroClockRefinement (pre++post) (pre++(m,0)::post) | |
| | trans {L M N} : ZeroClockRefinement L M → ZeroClockRefinement M N → ZeroClockRefinement L N | |
| theorem ZeroClockRefinement.continuation_test {L M : List (GaussianStep ι)} | |
| (h : ZeroClockRefinement L M) (F A : (ι → ℝ) → ℝ) : | |
| prefixContinuation L F = prefixContinuation M F ∧ prefixTest L F A = prefixTest M F A := by | |
| induction h with | |
| | refl => exact ⟨rfl,rfl⟩ | |
| | insert pre post m hm => | |
| exact ⟨(prefixContinuation_zero_insert pre post F hm.ne').symm, | |
| (prefixTest_zero_insert pre post F A hm.ne').symm⟩ | |
| | trans h₁ h₂ ih₁ ih₂ => exact ⟨ih₁.1.trans ih₂.1,ih₁.2.trans ih₂.2⟩ | |
| theorem ZeroClockRefinement.hierarchy {L M : List (GaussianStep ι)} | |
| (h : ZeroClockRefinement L M) (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ) (A : S → ℝ) : | |
| gaussianHierarchy w φ L = gaussianHierarchy w φ M ∧ | |
| gaussianHierarchyMean w φ A L = gaussianHierarchyMean w φ A M := by | |
| have hh := h.continuation_test (gaussianHierarchy w φ []) (gaussianHierarchyMean w φ A []) | |
| simpa only [prefixContinuation_hierarchy,gaussianHierarchyMean_prefix,List.append_nil] using hh | |
| end SKFluctuations.Hierarchy | |
| namespace SKFluctuations.Hierarchy | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped Topology NNReal BigOperators | |
| variable {ι : Type*} | |
| theorem ZeroClockRefinement.cons {L M : List (GaussianStep ι)} | |
| (h : ZeroClockRefinement L M) (s : GaussianStep ι) : | |
| ZeroClockRefinement (s::L) (s::M) := by | |
| induction h with | |
| | refl L => exact .refl _ | |
| | insert pre post m hm => | |
| simpa only [List.cons_append] using ZeroClockRefinement.insert (s::pre) post m hm | |
| | trans h₁ h₂ ih₁ ih₂ => exact ih₁.trans ih₂ | |
| abbrev PairedClockStep (ι : Type*) := ℝ × ((ι → ℝ≥0) × (ι → ℝ≥0)) | |
| def commonClockSteps : List (GaussianStep ι) → List (GaussianStep ι) → List (PairedClockStep ι) | |
| | [], B => B.map (fun b => (b.1,0,b.2)) | |
| | A, [] => A.map (fun a => (a.1,a.2,0)) | |
| | a::A, b::B => if a.1 ≤ b.1 then (a.1,a.2,0)::commonClockSteps A (b::B) | |
| else (b.1,0,b.2)::commonClockSteps (a::A) B | |
| termination_by A B => A.length+B.length | |
| def leftClockSteps (L : List (PairedClockStep ι)) : List (GaussianStep ι) := | |
| L.map (fun t => (t.1,t.2.1)) | |
| def rightClockSteps (L : List (PairedClockStep ι)) : List (GaussianStep ι) := | |
| L.map (fun t => (t.1,t.2.2)) | |
| theorem zeroClockSteps_refines (L : List (GaussianStep ι)) | |
| (hL : ∀ s ∈ L, 0 < s.1) : ZeroClockRefinement (ι := ι) [] (L.map fun s => (s.1,0)) := by | |
| induction L with | |
| | nil => exact .refl _ | |
| | cons s L ih => | |
| have ht := ih (fun t ht => hL t (by simp [ht])) | |
| apply ht.trans | |
| simpa using ZeroClockRefinement.insert [] (L.map fun t => (t.1,0)) s.1 (hL s (by simp)) | |
| theorem commonClockSteps_refines (A B : List (GaussianStep ι)) | |
| (hA : ∀ s ∈ A, 0 < s.1) (hB : ∀ s ∈ B, 0 < s.1) : | |
| ZeroClockRefinement A (leftClockSteps (commonClockSteps A B)) ∧ | |
| ZeroClockRefinement B (rightClockSteps (commonClockSteps A B)) := by | |
| cases A with | |
| | nil => | |
| simp only [commonClockSteps,leftClockSteps,rightClockSteps,List.map_map,Function.comp_def] | |
| constructor | |
| · exact zeroClockSteps_refines B hB | |
| · simpa only [Prod.mk.eta,List.map_id_fun', id_eq] using (ZeroClockRefinement.refl B) | |
| | cons a A => | |
| cases B with | |
| | nil => | |
| simp only [commonClockSteps,leftClockSteps,rightClockSteps,List.map_map,Function.comp_def] | |
| constructor | |
| · simpa only [Prod.mk.eta,List.map_id_fun', id_eq] using (ZeroClockRefinement.refl (a::A)) | |
| · exact zeroClockSteps_refines (a::A) hA | |
| | cons b B => | |
| rw [commonClockSteps] | |
| split_ifs with hab | |
| · have ih := commonClockSteps_refines A (b::B) (fun s hs => hA s (by simp [hs])) hB | |
| constructor | |
| · exact ih.1.cons a | |
| · exact ih.2.trans (by simpa [rightClockSteps] using (ZeroClockRefinement.insert [] | |
| (rightClockSteps (commonClockSteps A (b::B))) a.1 (hA a (by simp)))) | |
| · have ih := commonClockSteps_refines (a::A) B hA (fun s hs => hB s (by simp [hs])) | |
| constructor | |
| · exact ih.1.trans (by simpa [leftClockSteps] using (ZeroClockRefinement.insert [] | |
| (leftClockSteps (commonClockSteps (a::A) B)) b.1 (hB b (by simp)))) | |
| · exact ih.2.cons b | |
| termination_by A.length+B.length | |
| theorem commonClockSteps_same_masses (A B : List (GaussianStep ι)) : | |
| (leftClockSteps (commonClockSteps A B)).map Prod.fst = | |
| (rightClockSteps (commonClockSteps A B)).map Prod.fst := by | |
| simp only [leftClockSteps,rightClockSteps,List.map_map,Function.comp_def] | |
| theorem OrderedSteps.map_variance {κ : Type*} {a : ℝ} {L : List (GaussianStep ι)} | |
| (hL : OrderedSteps a L) (f : GaussianStep ι → κ → ℝ≥0) : | |
| OrderedSteps a (L.map fun s => (s.1,f s)) := by | |
| induction L generalizing a with | |
| | nil => exact hL | |
| | cons s L ih => exact ⟨hL.1,hL.2.1,hL.2.2.1,ih hL.2.2.2⟩ | |
| theorem commonClockSteps_ordered {a : ℝ} (A B : List (GaussianStep ι)) | |
| (hA : OrderedSteps a A) (hB : OrderedSteps a B) : | |
| OrderedSteps a (leftClockSteps (commonClockSteps A B)) ∧ | |
| OrderedSteps a (rightClockSteps (commonClockSteps A B)) := by | |
| cases A with | |
| | nil => | |
| simp only [commonClockSteps,leftClockSteps,rightClockSteps,List.map_map,Function.comp_def] | |
| constructor | |
| · exact hB.map_variance (fun _ => 0) | |
| · simpa only [Prod.mk.eta,List.map_id_fun',id_eq] using hB | |
| | cons b A => | |
| cases B with | |
| | nil => | |
| simp only [commonClockSteps,leftClockSteps,rightClockSteps,List.map_map,Function.comp_def] | |
| constructor | |
| · simpa only [Prod.mk.eta,List.map_id_fun',id_eq] using hA | |
| · exact hA.map_variance (fun _ => 0) | |
| | cons c B => | |
| rw [commonClockSteps] | |
| split_ifs with hbc | |
| · have hB' : OrderedSteps b.1 (c::B) := ⟨hA.2.2.1.le,hbc,hB.2.2⟩ | |
| have hh := commonClockSteps_ordered A (c::B) hA.2.2.2 hB' | |
| exact ⟨⟨hA.1,hA.2.1,hA.2.2.1,hh.1⟩,⟨hA.1,hA.2.1,hA.2.2.1,hh.2⟩⟩ | |
| · have hA' : OrderedSteps c.1 (b::A) := ⟨hB.2.2.1.le,(le_of_not_ge hbc),hA.2.2⟩ | |
| have hh := commonClockSteps_ordered (b::A) B hA' hB.2.2.2 | |
| exact ⟨⟨hB.1,hB.2.1,hB.2.2.1,hh.1⟩,⟨hB.1,hB.2.1,hB.2.2.1,hh.2⟩⟩ | |
| termination_by A.length+B.length | |
| end SKFluctuations.Hierarchy | |
| namespace SKFluctuations.Hierarchy | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped Topology NNReal BigOperators | |
| variable {ι : Type*} | |
| def positiveStepMasses : (L : List (GaussianStep ι)) → | |
| (∀ s ∈ L, 0 < s.1) → List PositiveMass | |
| | [], _ => [] | |
| | s::L, h => ⟨s.1,h s (by simp)⟩::positiveStepMasses L (fun t ht => h t (by simp [ht])) | |
| theorem positiveStepMasses_length (L : List (GaussianStep ι)) | |
| (h : ∀ s ∈ L, 0 < s.1) : (positiveStepMasses L h).length=L.length := by | |
| induction L with | |
| | nil => rfl | |
| | cons s L ih => exact congrArg Nat.succ (ih _) | |
| theorem positiveStepMasses_ordered {a : ℝ} {L : List (GaussianStep ι)} | |
| (hL : OrderedSteps a L) (hp : ∀ s ∈ L, 0 < s.1) : | |
| MassOrdered a (positiveStepMasses L hp) := by | |
| induction L generalizing a with | |
| | nil => exact hL | |
| | cons s L ih => exact ⟨hL.1,hL.2.1,ih hL.2.2.2 _⟩ | |
| def stepClockValues (q₀ : ι → ℝ) : List (GaussianStep ι) → ℕ → ι → ℝ | |
| | [], _ => q₀ | |
| | _::_, 0 => q₀ | |
| | s::L, j+1 => stepClockValues (fun i => q₀ i+s.2 i) L j | |
| theorem stepClockValues_zero (q₀ : ι → ℝ) (L : List (GaussianStep ι)) : | |
| stepClockValues q₀ L 0=q₀ := by cases L <;> rfl | |
| theorem stepClockValues_mono (q₀ : ι → ℝ) (L : List (GaussianStep ι)) (i : ι) : | |
| Monotone (fun j => stepClockValues q₀ L j i) := by | |
| induction L generalizing q₀ with | |
| | nil => exact monotone_const | |
| | cons s L ih => | |
| apply monotone_nat_of_le_succ | |
| intro j | |
| cases j with | |
| | zero => simp only [stepClockValues,stepClockValues_zero]; exact le_add_of_nonneg_right (s.2 i).coe_nonneg | |
| | succ j => exact ih (fun i => q₀ i+s.2 i) (Nat.le_succ j) | |
| theorem stepClockValues_initial_le (q₀ : ι → ℝ) (L : List (GaussianStep ι)) (j : ℕ) (i : ι) : | |
| q₀ i ≤ stepClockValues q₀ L j i := by | |
| have h := stepClockValues_mono q₀ L i (Nat.zero_le j) | |
| simpa only [stepClockValues_zero] using h | |
| theorem diagonalBoundarySteps_stepClockValues (q₀ : ι → ℝ) (L : List (GaussianStep ι)) | |
| (hp : ∀ s ∈ L, 0 < s.1) : | |
| diagonalBoundarySteps (positiveStepMasses L hp) q₀ | |
| (fun j => stepClockValues q₀ L (j+1)) = L := by | |
| induction L generalizing q₀ with | |
| | nil => rfl | |
| | cons s L ih => | |
| simp only [positiveStepMasses,diagonalBoundarySteps,stepClockValues,stepClockValues_zero] | |
| have hi : (fun i => Real.toNNReal (q₀ i+(s.2 i:ℝ)-q₀ i)) = s.2 := by | |
| funext i | |
| simp only [add_sub_cancel_left,Real.toNNReal_coe] | |
| rw [hi,ih] | |
| theorem stepClockValues_terminal (q₀ : ι → ℝ) (L : List (GaussianStep ι)) (i : ι) : | |
| stepClockValues q₀ L L.length i = q₀ i+(L.map (fun s => (s.2 i:ℝ))).sum := by | |
| induction L generalizing q₀ with | |
| | nil => simp [stepClockValues] | |
| | cons s L ih => simp only [List.length_cons,stepClockValues,ih,List.map_cons,List.sum_cons]; ring | |
| theorem ZeroClockRefinement.total_variance {L M : List (GaussianStep ι)} | |
| (h : ZeroClockRefinement L M) (i : ι) : | |
| (L.map (fun s => (s.2 i:ℝ))).sum = (M.map (fun s => (s.2 i:ℝ))).sum := by | |
| induction h with | |
| | refl => rfl | |
| | insert pre post m hm => simp | |
| | trans h₁ h₂ ih₁ ih₂ => exact ih₁.trans ih₂ | |
| end SKFluctuations.Hierarchy | |
| namespace SKFluctuations.Hierarchy | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped Topology NNReal BigOperators | |
| variable {S ι : Type*} [Fintype S] [Nonempty S] [Fintype ι] | |
| theorem ClockTree.singleMean_eq_hierarchy {w : S → ℝ} (hw : ∀ σ, 0 < w σ) | |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) {as : List PositiveMass} {a : ℝ} | |
| (ho : MassOrdered a as) (q : ℕ → ι → ℝ≥0) (P : S → ℝ) : | |
| ClockTree.singleMean w φ as q P = gaussianHierarchyMean w φ P (clockSteps as q) := by | |
| funext x | |
| induction as generalizing a q x with | |
| | nil => rfl | |
| | cons b as ih => | |
| rw [ClockTree.singleMean_step hw φ b ho.2.2] | |
| change shiftedMean _ _ _ _ x = shiftedMean _ _ _ _ x | |
| congr 1 | |
| funext y | |
| exact ih ho.2.2 _ y | |
| def stepPairMean (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ) | |
| (pre post : List (GaussianStep ι)) (P : S → S → ℝ) : (ι → ℝ) → ℝ := | |
| prefixTest pre (gaussianHierarchy w φ post) | |
| (fun x => gaussianHierarchyMean w φ | |
| (fun σ => gaussianHierarchyMean w φ (P σ) post x) post x) | |
| theorem ClockTree.pairMean_prefix {w : S → ℝ} (hw : ∀ σ, 0 < w σ) | |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) (as bs : List PositiveMass) {a : ℝ} | |
| (ho : MassOrdered a (as++bs)) (q : ℕ → ι → ℝ≥0) (P : S → S → ℝ) : | |
| ClockTree.pairMean w φ (as++bs) q as.length P = | |
| stepPairMean w φ (clockSteps as q) (clockSteps bs (fun j => q (as.length+j))) P := by | |
| induction as generalizing a q with | |
| | nil => | |
| cases bs with | |
| | nil => rfl | |
| | cons b bs => | |
| funext x | |
| simp only [List.length_nil,Nat.zero_add] | |
| change ClockTree.singleMean w φ (b::bs) q | |
| (fun σ => ClockTree.singleMean w φ (b::bs) q (P σ) x) x = _ | |
| rw [ClockTree.singleMean_eq_hierarchy hw φ (as := b::bs) ho] | |
| congr 1 | |
| funext σ | |
| simpa only [List.length_nil,Nat.zero_add] using | |
| congrFun (ClockTree.singleMean_eq_hierarchy hw φ (as := b::bs) ho q (P σ)) x | |
| | cons b as ih => | |
| funext x | |
| simp only [List.cons_append,List.length_cons,ClockTree.pairMean,clockSteps, | |
| stepPairMean,prefixTest] | |
| have hindex : (fun j => q (as.length+1+j)) = (fun j => q (as.length+j+1)) := by | |
| funext j | |
| congr 1 | |
| omega | |
| rw [hindex] | |
| congr 1 | |
| · rw [prefixContinuation_hierarchy,clockSteps_append] | |
| · exact ih ho.2.2 (fun j => q (j+1)) | |
| omit [Nonempty S] in | |
| theorem ZeroClockRefinement.pairMean {L M A B : List (GaussianStep ι)} | |
| (h₁ : ZeroClockRefinement L M) (h₂ : ZeroClockRefinement A B) | |
| (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ) (P : S → S → ℝ) : | |
| stepPairMean w φ L A P = stepPairMean w φ M B P := by | |
| unfold stepPairMean | |
| rw [(h₁.continuation_test _ _).2,(h₂.hierarchy w φ (fun _ => 0)).1] | |
| congr 1 | |
| funext x | |
| simp_rw [(h₂.hierarchy w φ _).2] | |
| theorem ClockTree.disorderExpect_integral {w : S → ℝ} (hw : ∀ σ, 0 < w σ) | |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) {as : List PositiveMass} (T : ClockTree S as) | |
| {a : ℝ} (ho : MassOrdered a as) (v : ι → ℝ) (q : ℕ → ι → ℝ) | |
| (P : T.Assignment → ℝ) (x : ι → ℝ) : | |
| T.disorderExpect w φ v q P x = | |
| zeroContinuation (Measure.pi fun i => gaussianReal 0 (Real.toNNReal (q 0 i-v i))) | |
| (T.expect w φ (cumulativeIncrements (q 0) (fun j => q (j+1))) P) x := by | |
| unfold ClockTree.disorderExpect ClockTree.disorderWeight zeroContinuation ClockTree.expect | |
| rw [integral_finsetSum] | |
| · simp only [integral_mul_const] | |
| · intro σ hσ | |
| exact ((T.weight_smooth hw φ ho _ σ 0).integrable_zero_shift x).mul_const (P σ) | |
| end SKFluctuations.Hierarchy | |
| namespace SKFluctuations.Hierarchy | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped Topology NNReal BigOperators | |
| variable {S ι : Type*} [Fintype S] [Nonempty S] [Fintype ι] | |
| omit [Fintype ι] in | |
| theorem length_clockSteps (as : List PositiveMass) (q : ℕ → ι → ℝ≥0) : | |
| (clockSteps as q).length=as.length := by | |
| induction as generalizing q with | |
| | nil => rfl | |
| | cons a as ih => exact congrArg Nat.succ (ih _) | |
| omit [Fintype ι] in | |
| theorem positiveStepMasses_append (L M : List (GaussianStep ι)) | |
| (hL : ∀ s ∈ L, 0<s.1) (hM : ∀ s ∈ M, 0<s.1) : | |
| positiveStepMasses (L++M) (fun s hs => (List.mem_append.mp hs).elim (hL s) (hM s)) = | |
| positiveStepMasses L hL ++ positiveStepMasses M hM := by | |
| induction L with | |
| | nil => rfl | |
| | cons s L ih => exact congrArg (List.cons _) (ih _) | |
| omit [Fintype ι] in | |
| theorem clockSteps_stepClockValues (q₀ : ι → ℝ) (L : List (GaussianStep ι)) | |
| (hp : ∀ s ∈ L, 0<s.1) : | |
| clockSteps (positiveStepMasses L hp) | |
| (cumulativeIncrements q₀ (fun j => stepClockValues q₀ L (j+1))) = L := by | |
| rw [clockSteps_cumulative,diagonalBoundarySteps_stepClockValues] | |
| def stepPairDisorder (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ) | |
| (v : ι → ℝ≥0) (pre post : List (GaussianStep ι)) (P : S → S → ℝ) : | |
| (ι → ℝ) → ℝ := | |
| zeroContinuation (Measure.pi fun i => gaussianReal 0 (v i)) | |
| (stepPairMean w φ pre post P) | |
| theorem ClockTree.pairDisorder_coordinates {w : S → ℝ} (hw : ∀ σ, 0<w σ) | |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) (pre post : List (GaussianStep ι)) | |
| (hpre : ∀ s ∈ pre, 0<s.1) (hpost : ∀ s ∈ post, 0<s.1) | |
| (ho : OrderedSteps 0 (pre++post)) (v : ι → ℝ≥0) (P : S → S → ℝ) : | |
| let as := positiveStepMasses pre hpre | |
| let bs := positiveStepMasses post hpost | |
| let q := stepClockValues (fun i => (v i:ℝ)) (pre++post) | |
| (fun x => (pairClock (as++bs) as.length).disorderExpect w φ (fun _ => 0) q | |
| (fun σ => P (pairSpin (as++bs) as.length σ).1 (pairSpin (as++bs) as.length σ).2) x) = | |
| stepPairDisorder w φ v pre post P := by | |
| dsimp only | |
| let as := positiveStepMasses pre hpre | |
| let bs := positiveStepMasses post hpost | |
| let q := stepClockValues (fun i => (v i:ℝ)) (pre++post) | |
| have hpos : ∀ s ∈ pre++post, 0<s.1 := | |
| fun s hs => (List.mem_append.mp hs).elim (hpre s) (hpost s) | |
| have heq : positiveStepMasses (pre++post) hpos=as++bs := positiveStepMasses_append _ _ _ _ | |
| have hordered : MassOrdered 0 (as++bs) := heq ▸ positiveStepMasses_ordered ho hpos | |
| have hc : clockSteps as (cumulativeIncrements (q 0) (fun j => q (j+1))) = pre ∧ | |
| clockSteps bs (fun j => cumulativeIncrements (q 0) (fun j => q (j+1)) (as.length+j)) = post := by | |
| have hc := clockSteps_stepClockValues (fun i => (v i:ℝ)) (pre++post) hpos | |
| rw [heq,clockSteps_append] at hc | |
| have hq : q 0=(fun i => (v i:ℝ)) := stepClockValues_zero _ _ | |
| rw [hq] | |
| apply List.append_inj hc | |
| rw [length_clockSteps,positiveStepMasses_length] | |
| have hex (c : ℕ → ι → ℝ≥0) : | |
| (pairClock (as++bs) as.length).expect w φ c | |
| (fun σ => P (pairSpin (as++bs) as.length σ).1 (pairSpin (as++bs) as.length σ).2) = | |
| pairMean w φ (as++bs) c as.length P := by | |
| funext z | |
| exact pairClock_expect hw φ _ hordered c _ P z | |
| funext x | |
| rw [disorderExpect_integral hw φ _ hordered,hex] | |
| rw [pairMean_prefix hw φ as bs hordered,hc.1,hc.2] | |
| change zeroContinuation _ _ x=zeroContinuation _ _ x | |
| congr 2 | |
| funext i | |
| simp only [stepClockValues_zero,sub_zero,Real.toNNReal_coe] | |
| omit [Nonempty S] in | |
| theorem ZeroClockRefinement.pairDisorder {L M A B : List (GaussianStep ι)} | |
| (h₁ : ZeroClockRefinement L M) (h₂ : ZeroClockRefinement A B) | |
| (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ) (v : ι → ℝ≥0) (P : S → S → ℝ) : | |
| stepPairDisorder w φ v L A P = stepPairDisorder w φ v M B P := by | |
| unfold stepPairDisorder | |
| rw [h₁.pairMean h₂] | |
| end SKFluctuations.Hierarchy | |
| namespace SKFluctuations.Hierarchy | |
| open MeasureTheory ProbabilityTheory Filter Set GaussianCalculus | |
| open scoped Topology NNReal BigOperators | |
| variable {S ι : Type*} [Fintype S] [Nonempty S] [Fintype ι] [Nonempty ι] | |
| theorem ClockTree.disorderProfileJets_oneError_pointwise {w : S → ℝ} | |
| (hw : ∀ σ, 0 < w σ) (φ : S → (ι → ℝ) →L[ℝ] ℝ) | |
| {as : List PositiveMass} (ho : MassOrdered 0 as) | |
| (pre post : List (ℕ → S → S → ℝ)) (E : ℕ → S → S → ℝ) | |
| (T : ClockTree S as) {r : ℕ} (hT : T.leaves ≤ r) | |
| (P : T.Assignment → ℝ) {C M : ℝ} (hC : 0 ≤ C) (hM : 0 ≤ M) | |
| (hP : ∀ σ, |P σ| ≤ C) | |
| (hpre : ∀ K ∈ pre, ∀ j σ τ, |K j σ τ| ≤ M) | |
| (hpost : ∀ K ∈ post, ∀ j σ τ, |K j σ τ| ≤ M) | |
| {f : ℕ → ℝ} (hf : ∀ j, 0 ≤ f j) (hE : ∀ j σ τ, |E j σ τ| ≤ f j) | |
| (v : ι → ℝ) (q : ℕ → ι → ℝ) (x : ι → ℝ) : | |
| |ClockTree.disorderProfileJets w φ v q x (pre++E::post) T P| ≤ | |
| ClockTree.errorJetVariation r pre.length post.length*C*M^(pre.length+post.length)* | |
| (T.forkCost f+ClockTree.edgeBudget 0 as f+f as.length) := by | |
| let e := finiteJetEquiv ι | |
| have he (j : ℕ) : ClockTree.pairRootMean w (reindexFeature e φ) as | |
| (fun i => q 0 (e i)-v (e i)) (fun j i => q (j+1) (e i)-q j (e i)) j | |
| (fun σ τ => |E j σ τ|) ((coordinateEquiv e).symm x) ≤ f j := by | |
| rw [ClockTree.pairRootMean_eq_rootExpect hw (reindexFeature e φ) as ho] | |
| exact (le_abs_self _).trans ((ClockTree.pairClock as j).rootExpect_abs_le hw | |
| (reindexFeature e φ) ho (fun σ => by simpa only [abs_abs] using hE j _ _) _ _ _) | |
| have hd := ClockTree.rootProfileJets_oneError_abs_le hw (reindexFeature e φ) ho pre post E T hT P | |
| hC hM hP hpre hpost (fun i => q 0 (e i)-v (e i)) | |
| (fun j i => q (j+1) (e i)-q j (e i)) hf (hf as.length) | |
| (fun σ => hE as.length σ σ) ((coordinateEquiv e).symm x) he | |
| rw [T.rootProfileJets_eq_disorderProfileJets hw (reindexFeature e φ) ho (pre++E::post) P | |
| (fun i => v (e i)) (fun j i => q j (e i)), | |
| T.disorderProfileJets_reindex e w φ (pre++E::post) P v q, | |
| ContinuousLinearEquiv.apply_symm_apply] at hd | |
| exact hd | |
| theorem ClockTree.disorderProfileJets_l1_comparison {w : S → ℝ} | |
| (hw : ∀ σ, 0 < w σ) (φ : S → (ι → ℝ) →L[ℝ] ℝ) | |
| {as : List PositiveMass} (ho : MassOrdered 0 as) | |
| (Ks : List (ℕ → S → S → ℝ)) (T : ClockTree S as) | |
| {r : ℕ} (hT : T.leaves ≤ r) (P : T.Assignment → ℝ) | |
| {C M : ℝ} (hC : 0 ≤ C) (hM : 0 ≤ M) (hP : ∀ σ, |P σ| ≤ C) | |
| (hKs : ∀ K ∈ Ks, ∀ j σ τ, |K j σ τ| ≤ M) | |
| (v : ι → ℝ) (q K : ℕ → ι → ℝ) {a b : ℝ} | |
| (hp : ∀ u ∈ Ioo a b, ∀ i, Monotone (fun j => q j i+u*K j i)) | |
| (hr : ∀ u ∈ Ioo a b, ∀ i, v i ≤ q 0 i+u*K 0 i) | |
| {f : ℕ → ℝ} (hf : ∀ j, 0 ≤ f j) | |
| (hE : ∀ j σ τ, |ReplicaTree.coordinateProfile φ K j σ τ| ≤ f j) | |
| (x : ι → ℝ) {s t : ℝ} (hs : s ∈ Icc a b) (ht : t ∈ Icc a b) : | |
| |ClockTree.disorderProfileJets w φ v (fun j i => q j i+s*K j i) x Ks T P - | |
| ClockTree.disorderProfileJets w φ v (fun j i => q j i+t*K j i) x Ks T P| ≤ | |
| (ClockTree.errorJetVariation r Ks.length 0*C*M^Ks.length* | |
| (T.forkCost f+ClockTree.edgeBudget 0 as f+f as.length))*|s-t| := by | |
| have hc := ClockTree.disorderProfileJets_continuous hw φ ho v | |
| (fun u j i => q j i+u*K j i) (by intro j; fun_prop) (fun _ => x) continuous_const Ks T P | |
| have hd (u : ℝ) (hu : u ∈ Ioo a b) := | |
| ClockTree.hasDerivAt_finiteProfileJets hw φ ho v q K hp hr Ks T P x hu | |
| apply abs_sub_le_of_bounded_derivative hc.continuousOn hd _ hs ht | |
| intro u hu | |
| simpa only [List.length_nil,add_zero] using | |
| T.disorderProfileJets_oneError_pointwise hw φ ho Ks [] (ReplicaTree.coordinateProfile φ K) | |
| hT P hC hM hP hKs (by simp) hf hE v (fun j i => q j i+u*K j i) x | |
| attribute [local instance] Classical.propDecidable | |
| omit [Fintype S] [Nonempty S] [Nonempty ι] in | |
| theorem ReplicaTree.coordinateProfile_abs_le_sum (φ : S → (ι → ℝ) →L[ℝ] ℝ) | |
| (K : ℕ → ι → ℝ) (D : ι → ℝ) (hD : ∀ i, 0 ≤ D i) | |
| (hφ : ∀ σ i, |φ σ (Pi.single i 1)| ≤ D i) (j : ℕ) (σ τ : S) : | |
| |ReplicaTree.coordinateProfile φ K j σ τ| ≤ ∑ i, |K j i| *(D i)^2 := by | |
| classical | |
| unfold ReplicaTree.coordinateProfile | |
| apply (Finset.abs_sum_le_sum_abs _ _).trans | |
| apply Finset.sum_le_sum | |
| intro i hi | |
| rw [abs_mul,abs_mul, mul_assoc] | |
| have hh := mul_le_mul (hφ σ i) (hφ τ i) (abs_nonneg _) (hD i) | |
| simpa only [sq] using mul_le_mul_of_nonneg_left hh (abs_nonneg (K j i)) | |
| 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 ι] | |
| omit [Fintype S] [Nonempty S] in | |
| theorem ClockTree.single_leaves_exact (as : List PositiveMass) : | |
| (ClockTree.single (S:=S) as).leaves = 1 := by | |
| induction as with | |
| | nil => rfl | |
| | cons a as ih => exact ih | |
| omit [Fintype S] [Nonempty S] in | |
| theorem ClockTree.pairClock_leaves (as : List PositiveMass) (j : ℕ) : | |
| (ClockTree.pairClock (S:=S) as j).leaves = 2 := by | |
| induction as generalizing j with | |
| | nil => rfl | |
| | cons a as ih => | |
| cases j with | |
| | zero => simp [ClockTree.pairClock,ClockTree.leaves,ClockTree.single_leaves_exact] | |
| | succ j => exact ih j | |
| omit [Fintype S] [Nonempty S] in | |
| theorem ClockTree.pairClock_forkCost (as : List PositiveMass) (j : ℕ) (f : ℕ → ℝ) : | |
| (ClockTree.pairClock (S:=S) as j).forkCost f = f (min j as.length) := by | |
| induction as generalizing j f with | |
| | nil => simp [ClockTree.pairClock,ClockTree.forkCost] | |
| | cons a as ih => | |
| cases j with | |
| | zero => simp [ClockTree.pairClock,ClockTree.forkCost,ClockTree.single_forkCost] | |
| | succ j => | |
| change (pairClock as j).forkCost (fun k => f (1+k)) = f (min (j+1) (as.length+1)) | |
| rw [ih] | |
| congr 1 | |
| omega | |
| theorem ClockTree.pairDisorder_l1_comparison {w : S → ℝ} | |
| (hw : ∀ σ, 0 < w σ) (φ : S → (ι → ℝ) →L[ℝ] ℝ) | |
| {as : List PositiveMass} (ho : MassOrdered 0 as) (j : ℕ) (P : S → S → ℝ) | |
| {C : ℝ} (hC : 0 ≤ C) (hP : ∀ σ τ, |P σ τ| ≤ C) | |
| (v : ι → ℝ) (q K : ℕ → ι → ℝ) {a b : ℝ} | |
| (hp : ∀ u ∈ Ioo a b, ∀ i, Monotone (fun j => q j i+u*K j i)) | |
| (hr : ∀ u ∈ Ioo a b, ∀ i, v i ≤ q 0 i+u*K 0 i) | |
| {f : ℕ → ℝ} (hf : ∀ j, 0 ≤ f j) | |
| (hE : ∀ j σ τ, |ReplicaTree.coordinateProfile φ K j σ τ| ≤ f j) | |
| (x : ι → ℝ) {s t : ℝ} (hs : s ∈ Icc a b) (ht : t ∈ Icc a b) : | |
| |(ClockTree.pairClock as j).disorderExpect w φ v (fun j i => q j i+s*K j i) | |
| (fun σ => P (ClockTree.pairSpin as j σ).1 (ClockTree.pairSpin as j σ).2) x - | |
| (ClockTree.pairClock as j).disorderExpect w φ v (fun j i => q j i+t*K j i) | |
| (fun σ => P (ClockTree.pairSpin as j σ).1 (ClockTree.pairSpin as j σ).2) x| ≤ | |
| ClockTree.errorJetVariation 2 0 0*C* | |
| (f (min j as.length)+ClockTree.edgeBudget 0 as f+f as.length)*|s-t| := by | |
| have h := ClockTree.disorderProfileJets_l1_comparison hw φ ho [] | |
| (ClockTree.pairClock as j) (by rw [ClockTree.pairClock_leaves]) | |
| (fun σ => P (ClockTree.pairSpin as j σ).1 (ClockTree.pairSpin as j σ).2) | |
| hC (show 0 ≤ (1:ℝ) by norm_num) (fun σ => hP _ _) (by simp) | |
| v q K hp hr hf hE x hs ht | |
| simpa only [ClockTree.disorderProfileJets,List.length_nil,pow_zero,mul_one, | |
| ClockTree.pairClock_forkCost] using h | |
| end SKFluctuations.Hierarchy | |
| namespace SKFluctuations.Hierarchy | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped Topology NNReal BigOperators | |
| variable {ι S : Type*} [Fintype ι] [Fintype S] | |
| def stepDisorderPressure (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ) | |
| (C : ι → ℝ) (q₀ : ι → ℝ≥0) (L : List (GaussianStep ι)) (x : ι → ℝ) : ℝ := | |
| zeroContinuation (Measure.pi fun i => gaussianReal 0 (q₀ i)) (gaussianHierarchy w φ L) x - | |
| (1/2:ℝ)*∑ i, ((q₀ i:ℝ)+(L.map fun s => (s.2 i:ℝ)).sum)*C i | |
| theorem stepDisorderPressure_eq (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ) | |
| (C : ι → ℝ) (q₀ : ι → ℝ≥0) (L : List (GaussianStep ι)) (hp : ∀ s ∈ L, 0 < s.1) | |
| (x : ι → ℝ) : | |
| stepDisorderPressure w φ C q₀ L x = disorderPressure w φ C (positiveStepMasses L hp) | |
| 0 (stepClockValues (fun i => (q₀ i:ℝ)) L) x := by | |
| simp only [disorderPressure,stepClockValues_zero,Pi.zero_apply,sub_zero, | |
| Real.toNNReal_coe,diagonalBoundarySteps_stepClockValues,positiveStepMasses_length, | |
| stepClockValues_terminal,stepDisorderPressure] | |
| theorem ZeroClockRefinement.pressure {L M : List (GaussianStep ι)} | |
| (h : ZeroClockRefinement L M) (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ) | |
| (C : ι → ℝ) (q₀ : ι → ℝ≥0) (x : ι → ℝ) : | |
| stepDisorderPressure w φ C q₀ L x = stepDisorderPressure w φ C q₀ M x := by | |
| unfold stepDisorderPressure | |
| rw [(h.hierarchy w φ (fun _ => 0)).1] | |
| simp_rw [h.total_variance] | |
| omit [Fintype ι] in | |
| theorem positiveStepMasses_values (L : List (GaussianStep ι)) (hp : ∀ s ∈ L, 0 < s.1) : | |
| (positiveStepMasses L hp).map Subtype.val=L.map Prod.fst := by | |
| induction L with | |
| | nil => rfl | |
| | cons s L ih => exact congrArg (List.cons s.1) (ih _) | |
| omit [Fintype ι] in | |
| theorem positiveStepMasses_eq {A B : List (GaussianStep ι)} | |
| (hA : ∀ s ∈ A, 0 < s.1) (hB : ∀ s ∈ B, 0 < s.1) | |
| (he : A.map Prod.fst=B.map Prod.fst) : positiveStepMasses A hA=positiveStepMasses B hB := by | |
| apply (List.map_injective_iff.mpr Subtype.val_injective) | |
| rw [positiveStepMasses_values,positiveStepMasses_values,he] | |
| theorem stepDisorderPressure_comparison [Nonempty S] [Nonempty ι] [DecidableEq ι] | |
| {w : S → ℝ} (hw : ∀ σ, 0 < w σ) (φ : S → (ι → ℝ) →L[ℝ] ℝ) | |
| (C D : ι → ℝ) (hC : ∀ σ i, (φ σ (Pi.single i 1))^2 = C i) | |
| (hD : ∀ i σ, |φ σ (Pi.single i 1)| ≤ D i) | |
| (q₀ r₀ : ι → ℝ≥0) (A B : List (GaussianStep ι)) | |
| (hA : OrderedSteps 0 A) (hB : OrderedSteps 0 B) (x : ι → ℝ) : | |
| |stepDisorderPressure w φ C q₀ A x-stepDisorderPressure w φ C r₀ B x| ≤ | |
| (1/2:ℝ)*∑ i, (D i)^2*rootBoundaryCost | |
| ((positiveStepMasses (leftClockSteps (commonClockSteps A B)) | |
| (commonClockSteps_ordered A B hA hB).1.mem_pos)++[⟨1,by norm_num⟩]) | |
| (fun j => stepClockValues (fun i => (q₀ i:ℝ)) (leftClockSteps (commonClockSteps A B)) j i) | |
| (fun j => stepClockValues (fun i => (r₀ i:ℝ)) (rightClockSteps (commonClockSteps A B)) j i) := by | |
| have hadd := commonClockSteps_refines A B hA.mem_pos hB.mem_pos | |
| rw [hadd.1.pressure w φ C q₀ x,hadd.2.pressure w φ C r₀ x] | |
| have ho := commonClockSteps_ordered A B hA hB | |
| rw [stepDisorderPressure_eq w φ C q₀ _ ho.1.mem_pos, | |
| stepDisorderPressure_eq w φ C r₀ _ ho.2.mem_pos, | |
| ← positiveStepMasses_eq ho.1.mem_pos ho.2.mem_pos (commonClockSteps_same_masses A B)] | |
| have hx := positiveStepMasses_ordered ho.1 ho.1.mem_pos | |
| exact disorderPressure_comparison hw φ C D hC hD _ hx.pairwise | |
| hx.members_le_one | |
| (stepClockValues_mono _ _) (stepClockValues_mono _ _) | |
| (fun i => by simp only [stepClockValues_zero,Pi.zero_apply]; exact (q₀ i).coe_nonneg) | |
| (fun i => by simp only [stepClockValues_zero,Pi.zero_apply]; exact (r₀ i).coe_nonneg) x | |
| end SKFluctuations.Hierarchy | |
| end | |
| end OAI | |