| import Mathlib |
| import OAI.Probability.SKFluctuations.FilledSquare |
|
|
| namespace OAI |
|
|
| /-! Feature Clock Response. -/ |
|
|
| 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 |
| variable {ι S : Type*} [Fintype ι] [Fintype S] [Nonempty S] {n : ℕ} |
|
|
| noncomputable def featureClockResponse (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ) |
| (L : (Fin (n+1) → ℝ) →L[ℝ] (ι → ℝ)) (steps : List (GaussianStep ι)) (m : ℝ) : ℝ → (ι → ℝ) → ℝ := |
| linearClockDerivative L m (gaussianHierarchy w φ steps) |
| (fun i => gaussianHierarchyMean w φ (fun σ => φ σ (L (Pi.single i 1))) steps) |
| (fun i => gaussianHierarchyResponse w φ (fun σ => φ σ (L (Pi.single i 1))) (L (Pi.single i 1)) steps) |
|
|
| theorem featureClockResponse_bound {w : S → ℝ} (hw : ∀ σ, 0 < w σ) |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) (L : (Fin (n+1) → ℝ) →L[ℝ] (ι → ℝ)) {Q m : ℝ} |
| (hQ : ∀ σ, ∑ i, (φ σ (L (Pi.single i 1)))^2 = Q) |
| (steps : List (GaussianStep ι)) (ha : OrderedSteps m steps) (t : ℝ) (x : ι → ℝ) : |
| |featureClockResponse w φ L steps m t x| ≤ Q/2 := by |
| obtain ⟨C,hF⟩ := (gaussianHierarchy_regular hw φ steps ha 0).1 |
| have hi := (exponentialIncrement_linearGaussian L (Real.toNNReal t)).integrable_shift hF m x |
| have hP := linearFeaturePenalty_smooth hw φ L steps ha 0 |
| have hp : 0 ≤ linearClockTest L m (gaussianHierarchy w φ steps) (linearFeaturePenalty w φ L m steps) t x := |
| shiftedMean_nonneg (fun y => (linearFeaturePenalty_bounds hw φ L hQ steps ha y).1) hi |
| have hb : linearClockTest L m (gaussianHierarchy w φ steps) (linearFeaturePenalty w φ L m steps) t x ≤ Q := by |
| have hh := shiftedMean_mono hP (BddSmooth.const 0 Q) |
| (fun y => (le_abs_self _).trans (linearFeaturePenalty_abs_le hw φ L hQ steps ha y)) hi |
| rwa [shiftedMean_const Q hi] at hh |
| unfold featureClockResponse |
| rw [linearClockDerivative_feature_trace hw φ L hQ steps ha t x] |
| rw [abs_of_nonneg (mul_nonneg (by norm_num) (sub_nonneg.mpr hb))] |
| linarith |
|
|
| theorem parametric_featureClock {w : S → ℝ} (hw : ∀ σ, 0 < w σ) |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) (L : (Fin (n+1) → ℝ) →L[ℝ] (ι → ℝ)) {Q m : ℝ} |
| (hQ : ∀ σ, ∑ i, (φ σ (L (Pi.single i 1)))^2 = Q) |
| (steps : List (GaussianStep ι)) (ha : OrderedSteps m steps) (hm : 0 < m) (r : ℝ) : |
| ParametricRegular 0 r (Q/2) (linearClockContinuation L m (gaussianHierarchy w φ steps)) |
| (featureClockResponse w φ L steps m) := by |
| obtain ⟨C,hC⟩ := (gaussianHierarchy_regular hw φ steps ha 0).1 |
| obtain ⟨K,hK⟩ := parametric_linear_clock L hC |
| (fun i => gaussianHierarchyMean_smooth hw φ _ steps ha 0) |
| (fun i => gaussianHierarchyResponse_smooth hw φ _ _ steps ha 0) |
| (fun y => (gaussianHierarchy_linear_feature_derivatives hw φ L steps ha y).1) |
| (fun y => (gaussianHierarchy_linear_feature_derivatives hw φ L steps ha y).2) hm |
| have hQ0 : 0 ≤ Q := by |
| obtain ⟨σ⟩ := ‹Nonempty S› |
| rw [← hQ σ] |
| exact Finset.sum_nonneg fun i _ => sq_nonneg _ |
| exact ⟨by positivity,(hK r).spatial,(hK r).continuous, |
| fun t _ x => featureClockResponse_bound hw φ L hQ steps ha t x,(hK r).derivative⟩ |
|
|
| namespace ReplicaTree |
|
|
| theorem clockResponse_smooth0 {w : S → ℝ} (hw : ∀ σ, 0 < w σ) |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) (L : (Fin (n+1) → ℝ) →L[ℝ] (ι → ℝ)) |
| {steps : List (GaussianStep ι)} (T : ReplicaTree ι S steps) {m : ℝ} (ha : OrderedSteps m steps) |
| (P : T.Assignment → ℝ) (t : ℝ) : BddSmooth 0 (T.clockResponse w φ L m P t) := by |
| have hF := gaussianHierarchy_regular hw φ steps ha 0 |
| have hi := (exponentialIncrement_linearGaussian L (Real.toNNReal t)).integrable_shift hF.1.choose_spec m |
| exact (((T.powerTrace_smooth hw φ L ha P 0).shiftedMean hF hi).sub |
| (((T.expect_smooth hw φ ha P 0).shiftedMean hF hi).mul |
| ((T.powerTrace_smooth hw φ L ha (fun _ => 1) 0).shiftedMean hF hi))).const_mul (1/2) |
|
|
| theorem parametric_clockTest {w : S → ℝ} (hw : ∀ σ, 0 < w σ) |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) (L : (Fin (n+1) → ℝ) →L[ℝ] (ι → ℝ)) |
| {steps : List (GaussianStep ι)} (T : ReplicaTree ι S steps) {m : ℝ} (ha : OrderedSteps m steps) |
| {P : T.Assignment → ℝ} {C : ℝ} (D : Fin (n+1) → ℝ) |
| (hC : 0 ≤ C) (hD : ∀ i, 0 ≤ D i) (hP : ∀ σ, |P σ| ≤ C) |
| (hB : ∀ i σ, |φ σ (L (Pi.single i 1))| ≤ D i) (r : ℝ) : |
| ParametricTest 0 r (C+4*(T.leaves:ℝ)*(T.leaves+1:ℝ)*C*∑ i, (D i)^2) |
| (linearClockTest L m (gaussianHierarchy w φ steps) (T.expect w φ P)) |
| (T.clockResponse w φ L m P) := by |
| have hK : 0 ≤ 4*(T.leaves:ℝ)*(T.leaves+1:ℝ)*C*∑ i, (D i)^2 := by positivity |
| refine ⟨by positivity,?_,fun t _ => (T.clockResponse_smooth0 hw φ L ha P t).continuous,?_,?_,?_⟩ |
| · intro t _ |
| have hF := gaussianHierarchy_regular hw φ steps ha 0 |
| exact ((T.expect_smooth hw φ ha P 0).shiftedMean hF |
| ((exponentialIncrement_linearGaussian L (Real.toNNReal t)).integrable_shift hF.1.choose_spec m)).continuous |
| · intro t _ x |
| exact (T.clock_abs_le hw φ L ha hP t x).trans (le_add_of_nonneg_right hK) |
| · intro t _ x |
| exact (T.clockResponse_abs_le hw φ L ha D hC hD hP hB t x).trans (le_add_of_nonneg_left hC) |
| · intro t ht x |
| exact (T.hasDerivWithinAt_linearClockTest hw φ L ha P x ht.1.le).hasDerivAt (Ici_mem_nhds ht.1) |
|
|
| end ReplicaTree |
| end SKFluctuations.Hierarchy |
|
|
| namespace SKFluctuations.Hierarchy |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped Topology NNReal BigOperators |
|
|
| theorem finite_law_variation_dual {κ : Type*} [Fintype κ] {R : κ → ℝ} {K : ℝ} |
| (h : ∀ P : κ → ℝ, (∀ σ, |P σ| ≤ 1) → |∑ σ, P σ*R σ| ≤ K) : |
| ∑ σ, |R σ| ≤ K := by |
| classical |
| let P : κ → ℝ := fun σ => if 0 ≤ R σ then 1 else -1 |
| have hP : ∀ σ, |P σ| ≤ 1 := by intro σ; dsimp [P]; split_ifs <;> norm_num |
| have he : ∑ σ, P σ*R σ = ∑ σ, |R σ| := by |
| apply Finset.sum_congr rfl |
| intro σ _ |
| dsimp [P] |
| split_ifs with hh |
| · rw [one_mul,abs_of_nonneg hh] |
| · rw [neg_one_mul,abs_of_neg (lt_of_not_ge hh)] |
| have hh := h P hP |
| rw [he,abs_of_nonneg (Finset.sum_nonneg fun σ _ => abs_nonneg _)] at hh |
| exact hh |
|
|
| variable {ι S : Type*} [Fintype ι] [Fintype S] [Nonempty S] {n : ℕ} |
| namespace ReplicaTree |
|
|
| theorem clockTest_atomic {w : S → ℝ} (hw : ∀ σ, 0 < w σ) |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) (L : (Fin (n+1) → ℝ) →L[ℝ] (ι → ℝ)) |
| {steps : List (GaussianStep ι)} (T : ReplicaTree ι S steps) {m : ℝ} (ha : OrderedSteps m steps) |
| [DecidableEq T.Assignment] (P : T.Assignment → ℝ) (t : ℝ) (x : ι → ℝ) : |
| linearClockTest L m (gaussianHierarchy w φ steps) (T.expect w φ P) t x = |
| ∑ σ, P σ*linearClockTest L m (gaussianHierarchy w φ steps) |
| (T.expect w φ (fun τ => if τ = σ then 1 else 0)) t x := by |
| have hF := gaussianHierarchy_regular hw φ steps ha 0 |
| have hi := (exponentialIncrement_linearGaussian L (Real.toNNReal t)).integrable_shift hF.1.choose_spec m x |
| have he : T.expect w φ P = fun y => ∑ σ, P σ*T.expect w φ (fun τ => if τ = σ then 1 else 0) y := by |
| funext y |
| simp_rw [T.expect_indicator] |
| unfold expect |
| apply Finset.sum_congr rfl |
| intro σ _ |
| ring |
| change shiftedMean _ _ _ _ _ = _ |
| rw [he,shiftedMean_finsetSum Finset.univ |
| (fun σ _ => (T.expect_smooth hw φ ha (fun τ => if τ = σ then 1 else 0) 0).const_mul (P σ)) hi] |
| simp only [shiftedMean_const_mul,linearClockTest] |
|
|
| theorem clockResponse_atomic {w : S → ℝ} (hw : ∀ σ, 0 < w σ) |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) (L : (Fin (n+1) → ℝ) →L[ℝ] (ι → ℝ)) |
| {steps : List (GaussianStep ι)} (T : ReplicaTree ι S steps) {m : ℝ} (ha : OrderedSteps m steps) |
| [DecidableEq T.Assignment] (P : T.Assignment → ℝ) {t : ℝ} (ht : 0 < t) (x : ι → ℝ) : |
| T.clockResponse w φ L m P t x = |
| ∑ σ, P σ*T.clockResponse w φ L m (fun τ => if τ = σ then 1 else 0) t x := by |
| have hd (P : T.Assignment → ℝ) := |
| (T.hasDerivWithinAt_linearClockTest hw φ L ha P x ht.le).hasDerivAt (Ici_mem_nhds ht) |
| have hs := HasDerivAt.fun_sum (u := Finset.univ) (fun σ _ => (hd (fun τ => if τ = σ then 1 else 0)).const_mul (P σ)) |
| have hh : HasDerivAt (fun s => linearClockTest L m (gaussianHierarchy w φ steps) (T.expect w φ P) s x) |
| (∑ σ, P σ*T.clockResponse w φ L m (fun τ => if τ = σ then 1 else 0) t x) t := by |
| have he : (fun s => linearClockTest L m (gaussianHierarchy w φ steps) (T.expect w φ P) s x) = |
| (fun s => ∑ σ, P σ*linearClockTest L m (gaussianHierarchy w φ steps) |
| (T.expect w φ (fun τ => if τ = σ then 1 else 0)) s x) := |
| funext fun s => T.clockTest_atomic hw φ L ha P s x |
| rw [he] |
| exact hs |
| exact (hd P).unique hh |
|
|
| theorem atomic_clockResponse_variation {w : S → ℝ} (hw : ∀ σ, 0 < w σ) |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) (L : (Fin (n+1) → ℝ) →L[ℝ] (ι → ℝ)) |
| {steps : List (GaussianStep ι)} (T : ReplicaTree ι S steps) {m : ℝ} (ha : OrderedSteps m steps) |
| [DecidableEq T.Assignment] (D : Fin (n+1) → ℝ) |
| (hD : ∀ i, 0 ≤ D i) (hB : ∀ i σ, |φ σ (L (Pi.single i 1))| ≤ D i) |
| {t : ℝ} (ht : 0 < t) (x : ι → ℝ) : |
| ∑ σ, |T.clockResponse w φ L m (fun τ => if τ = σ then 1 else 0) t x| ≤ |
| 4*(T.leaves:ℝ)*(T.leaves+1:ℝ)*∑ i, (D i)^2 := by |
| apply finite_law_variation_dual |
| intro P hP |
| rw [← T.clockResponse_atomic hw φ L ha P ht x] |
| simpa only [mul_one] using T.clockResponse_abs_le hw φ L ha D (by norm_num : (0:ℝ) ≤ 1) hD hP hB t x |
|
|
| theorem atomic_clockTest_probability {w : S → ℝ} (hw : ∀ σ, 0 < w σ) |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) (L : (Fin (n+1) → ℝ) →L[ℝ] (ι → ℝ)) |
| {steps : List (GaussianStep ι)} (T : ReplicaTree ι S steps) {m : ℝ} (ha : OrderedSteps m steps) |
| [DecidableEq T.Assignment] (t : ℝ) (x : ι → ℝ) : |
| (∀ σ, 0 ≤ linearClockTest L m (gaussianHierarchy w φ steps) |
| (T.expect w φ (fun τ => if τ = σ then 1 else 0)) t x) ∧ |
| (∑ σ, linearClockTest L m (gaussianHierarchy w φ steps) |
| (T.expect w φ (fun τ => if τ = σ then 1 else 0)) t x) = 1 := by |
| have hF := gaussianHierarchy_regular hw φ steps ha 0 |
| have hi := (exponentialIncrement_linearGaussian L (Real.toNNReal t)).integrable_shift hF.1.choose_spec m x |
| refine ⟨fun σ => ?_,?_⟩ |
| · apply shiftedMean_nonneg _ hi |
| intro y |
| rw [T.expect_indicator] |
| exact T.weight_nonneg hw φ ha σ y |
| · have hh := T.clockTest_atomic hw φ L ha (fun _ => 1) t x |
| simp only [one_mul] at hh |
| rw [← hh] |
| have he : T.expect w φ (fun _ => 1) = fun _ => 1 := funext fun y => T.expect_const hw φ ha 1 y |
| unfold linearClockTest |
| rw [he,shiftedMean_const 1 hi] |
|
|
| end ReplicaTree |
| end SKFluctuations.Hierarchy |
|
|
| namespace SKFluctuations.Hierarchy |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped Topology NNReal BigOperators |
| universe uB vB wB |
|
|
| |
|
|
| inductive BoundaryTree (ι : Type uB) (β : Type vB) : List (GaussianStep ι) → Type (max uB vB) where |
| | leaf (b : β) : BoundaryTree ι β [] |
| | step (st : GaussianStep ι) {tail : List (GaussianStep ι)} |
| (T : BoundaryTree ι β tail) : BoundaryTree ι β (st::tail) |
| | fork {front : List (GaussianStep ι)} (T U : BoundaryTree ι β front) : BoundaryTree ι β front |
|
|
| variable {ι : Type uB} {β : Type vB} {κ : β → Type wB} |
|
|
| @[reducible] def BoundaryTree.Assignment (κ : β → Type wB) : |
| {front : List (GaussianStep ι)} → BoundaryTree ι β front → Type wB |
| | _, .leaf b => κ b |
| | _, .step _ T => T.Assignment κ |
| | _, .fork T U => T.Assignment κ × U.Assignment κ |
|
|
| @[instance_reducible] noncomputable def BoundaryTree.assignmentFintype [∀ b, Fintype (κ b)] : |
| {front : List (GaussianStep ι)} → (T : BoundaryTree ι β front) → Fintype (T.Assignment κ) |
| | _, .leaf b => inferInstanceAs (Fintype (κ b)) |
| | _, .step _ T => T.assignmentFintype |
| | _, .fork T U => @instFintypeProd _ _ T.assignmentFintype U.assignmentFintype |
| attribute [instance] BoundaryTree.assignmentFintype |
|
|
| variable [Fintype ι] |
|
|
| noncomputable def BoundaryTree.weight (F : ℝ → (ι → ℝ) → ℝ) |
| (W : ∀ b, κ b → ℝ → (ι → ℝ) → ℝ) : |
| {front : List (GaussianStep ι)} → (T : BoundaryTree ι β front) → T.Assignment κ → ℝ → (ι → ℝ) → ℝ |
| | _, .leaf b, σ => W b σ |
| | _, @BoundaryTree.step _ _ (m,q) tail T, σ => fun t => |
| shiftedMean (Measure.pi fun i => gaussianReal 0 (q i)) m |
| (prefixContinuation tail (F t)) (fun x => T.weight F W σ t x) |
| | _, .fork T U, σ => fun t x => T.weight F W σ.1 t x*U.weight F W σ.2 t x |
|
|
| noncomputable def BoundaryTree.response (F D : ℝ → (ι → ℝ) → ℝ) |
| (W B : ∀ b, κ b → ℝ → (ι → ℝ) → ℝ) : |
| {front : List (GaussianStep ι)} → (T : BoundaryTree ι β front) → T.Assignment κ → ℝ → (ι → ℝ) → ℝ |
| | _, .leaf b, σ => B b σ |
| | _, @BoundaryTree.step _ _ (m,q) tail T, σ => fun t => |
| tiltedResponse q m (prefixContinuation tail (F t)) (prefixTest tail (F t) (D t)) |
| (fun x => T.weight F W σ t x) (fun x => T.response F D W B σ t x) |
| | _, .fork T U, σ => fun t x => T.response F D W B σ.1 t x*U.weight F W σ.2 t x+ |
| T.weight F W σ.1 t x*U.response F D W B σ.2 t x |
|
|
| theorem BoundaryTree.parametric {l r J : ℝ} {F D : ℝ → (ι → ℝ) → ℝ} |
| {W B : ∀ b, κ b → ℝ → (ι → ℝ) → ℝ} |
| (hF : ParametricRegular l r J F D) |
| (hW : ∀ b σ, ∃ K, ParametricTest l r K (W b σ) (B b σ)) |
| {front : List (GaussianStep ι)} (T : BoundaryTree ι β front) |
| (hm : ∀ st ∈ front, 0 < st.1) (σ : T.Assignment κ) : |
| ∃ K, ParametricTest l r K (T.weight F W σ) (T.response F D W B σ) := by |
| induction T with |
| | leaf b => exact hW b σ |
| | @step st tail T ih => |
| rcases st with ⟨m,q⟩ |
| have ht := fun s hs => hm s (List.mem_cons_of_mem _ hs) |
| obtain ⟨K,hK⟩ := ih ht σ |
| exact ⟨_,hK.step (hF.prefix tail ht) q m⟩ |
| | fork T U ihT ihU => |
| obtain ⟨K,hK⟩ := ihT hm σ.1 |
| obtain ⟨J,hJ⟩ := ihU hm σ.2 |
| exact ⟨_,hK.mul hJ⟩ |
|
|
| theorem BoundaryTree.weight_smooth0 {l r J : ℝ} {F D : ℝ → (ι → ℝ) → ℝ} |
| {W B : ∀ b, κ b → ℝ → (ι → ℝ) → ℝ} |
| (hF : ParametricRegular l r J F D) |
| (hW : ∀ b σ, ∃ K, ParametricTest l r K (W b σ) (B b σ)) |
| {front : List (GaussianStep ι)} (T : BoundaryTree ι β front) |
| (hm : ∀ st ∈ front, 0 < st.1) (σ : T.Assignment κ) {t : ℝ} (ht : t ∈ Ioo l r) : |
| BddSmooth 0 (fun x => T.weight F W σ t x) := |
| (T.parametric hF hW hm σ).choose_spec.smooth0 ht |
|
|
| theorem BoundaryTree.response_smooth0 {l r J : ℝ} {F D : ℝ → (ι → ℝ) → ℝ} |
| {W B : ∀ b, κ b → ℝ → (ι → ℝ) → ℝ} |
| (hF : ParametricRegular l r J F D) |
| (hW : ∀ b σ, ∃ K, ParametricTest l r K (W b σ) (B b σ)) |
| {front : List (GaussianStep ι)} (T : BoundaryTree ι β front) |
| (hm : ∀ st ∈ front, 0 < st.1) (σ : T.Assignment κ) {t : ℝ} (ht : t ∈ Ioo l r) : |
| BddSmooth 0 (fun x => T.response F D W B σ t x) := |
| (T.parametric hF hW hm σ).choose_spec.response_smooth0 ht |
|
|
| theorem BoundaryTree.probability [∀ b, Fintype (κ b)] |
| {l r J : ℝ} {F D : ℝ → (ι → ℝ) → ℝ} {W B : ∀ b, κ b → ℝ → (ι → ℝ) → ℝ} |
| (hF : ParametricRegular l r J F D) |
| (hW : ∀ b σ, ∃ K, ParametricTest l r K (W b σ) (B b σ)) |
| (hp : ∀ b, ∀ t ∈ Ioo l r, ∀ x, (∀ σ, 0 ≤ W b σ t x) ∧ ∑ σ, W b σ t x = 1) |
| {front : List (GaussianStep ι)} (T : BoundaryTree ι β front) |
| (hm : ∀ st ∈ front, 0 < st.1) {t : ℝ} (ht : t ∈ Ioo l r) (x : ι → ℝ) : |
| (∀ σ : T.Assignment κ, 0 ≤ T.weight F W σ t x) ∧ ∑ σ, T.weight F W σ t x = 1 := by |
| induction T generalizing x with |
| | leaf b => exact hp b t ht x |
| | @step st tail T ih => |
| rcases st with ⟨m,q⟩ |
| have htail := fun s hs => hm s (List.mem_cons_of_mem _ hs) |
| have hi := (exponentialIncrement_gaussian q).integrable_shift |
| ((hF.prefix tail htail).spatial t ht).choose_spec m x |
| refine ⟨fun σ => shiftedMean_nonneg (fun y => (ih htail y).1 σ) hi,?_⟩ |
| change ∑ σ, shiftedMean _ _ _ (fun y => T.weight F W σ t y) x = _ |
| rw [← shiftedMean_finsetSum Finset.univ (fun σ _ => T.weight_smooth0 hF hW htail σ ht) hi] |
| simp_rw [(ih htail _).2] |
| exact shiftedMean_const 1 hi |
| | @fork front T U ihT ihU => |
| obtain ⟨hT,sT⟩ := ihT hm x |
| obtain ⟨hU,sU⟩ := ihU hm x |
| refine ⟨fun σ => mul_nonneg (hT σ.1) (hU σ.2),?_⟩ |
| change ∑ σ : T.Assignment κ × U.Assignment κ, T.weight F W σ.1 t x*U.weight F W σ.2 t x = _ |
| simp only [Fintype.sum_prod_type,← Finset.mul_sum,sU,mul_one,sT] |
|
|
| end SKFluctuations.Hierarchy |
|
|
| namespace SKFluctuations.Hierarchy |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped Topology NNReal BigOperators |
|
|
| theorem BddSmooth.abs_zero {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| {A : E → ℝ} (h : BddSmooth 0 A) : BddSmooth 0 (fun x => |A x|) := by |
| obtain ⟨K,hK,hb⟩ := h.bound |
| exact ⟨h.continuous.abs,K,hK,fun x => by simpa only [abs_abs] using hb x⟩ |
|
|
| theorem sum_abs_shiftedMean_le {E κ : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [MeasurableSpace E] [BorelSpace E] {ν : Measure E} [IsProbabilityMeasure ν] [Fintype κ] |
| {F : E → ℝ} {m K : ℝ} {A : κ → E → ℝ} |
| (hA : ∀ i, BddSmooth 0 (A i)) (hb : ∀ x, ∑ i, |A i x| ≤ K) {x : E} |
| (hi : Integrable (fun z => Real.exp (m*F (x+z))) ν) : |
| ∑ i, |shiftedMean ν m F (A i) x| ≤ K := by |
| calc |
| _ ≤ ∑ i, shiftedMean ν m F (fun y => |A i y|) x := |
| Finset.sum_le_sum fun i _ => shiftedMean_abs_mono (hA i) (hA i).abs_zero (fun y => le_refl _) hi |
| _ = shiftedMean ν m F (fun y => ∑ i, |A i y|) x := |
| (shiftedMean_finsetSum Finset.univ (fun i _ => (hA i).abs_zero) hi).symm |
| _ ≤ shiftedMean ν m F (fun _ => K) x := shiftedMean_mono |
| (BddSmooth.sum Finset.univ fun i _ => (hA i).abs_zero) (BddSmooth.const 0 K) hb hi |
| _ = K := shiftedMean_const K hi |
|
|
| theorem finite_law_score_fork {κ ρ : Type*} [Fintype κ] [Fintype ρ] |
| {W : κ → ℝ} {V : ρ → ℝ} {B : κ → ℝ} {C : ρ → ℝ} {a D K L M : ℝ} |
| (hW : ∀ i, 0 ≤ W i) (hV : ∀ j, 0 ≤ V j) |
| (sW : ∑ i, W i = 1) (sV : ∑ j, V j = 1) |
| (hB : ∑ i, |B i+a*W i*D| ≤ K) (hC : ∑ j, |C j+a*V j*D| ≤ L) |
| (ha : 0 ≤ a) (hD : |D| ≤ M) : |
| ∑ z : κ × ρ, |B z.1*V z.2+W z.1*C z.2+a*(W z.1*V z.2)*D| ≤ K+L+a*M := by |
| have he (i : κ) (j : ρ) : |
| B i*V j+W i*C j+a*(W i*V j)*D = |
| (B i+a*W i*D)*V j+W i*(C j+a*V j*D)-a*W i*V j*D := by ring |
| calc |
| _ ≤ ∑ z : κ × ρ, (|B z.1+a*W z.1*D| *V z.2+W z.1*|C z.2+a*V z.2*D|+a*W z.1*V z.2*M) := by |
| apply Finset.sum_le_sum |
| intro z _ |
| rw [he] |
| apply (abs_sub _ _).trans |
| have h := abs_add_le ((B z.1+a*W z.1*D)*V z.2) (W z.1*(C z.2+a*V z.2*D)) |
| simp only [abs_mul,abs_of_nonneg (hW z.1),abs_of_nonneg (hV z.2),abs_of_nonneg ha] at h ⊢ |
| have hh := mul_le_mul_of_nonneg_left hD (mul_nonneg (mul_nonneg ha (hW z.1)) (hV z.2)) |
| linarith |
| _ = (∑ i, |B i+a*W i*D|)+(∑ j, |C j+a*V j*D|)+a*M := by |
| simp only [Fintype.sum_prod_type,Finset.sum_add_distrib,← Finset.sum_mul,← Finset.mul_sum,sV,sW,mul_one,one_mul] |
| _ ≤ K+L+a*M := by linarith |
|
|
| theorem finite_law_subtraction_bound {κ : Type*} [Fintype κ] |
| {W R : κ → ℝ} {c D K J : ℝ} (hW : ∀ i, 0 ≤ W i) (sW : ∑ i, W i = 1) |
| (hR : ∑ i, |R i| ≤ K) (hc : 0 ≤ c) (hD : |D| ≤ J) : |
| ∑ i, |R i-c*W i*D| ≤ K+c*J := by |
| calc |
| _ ≤ ∑ i, (|R i|+c*W i*J) := by |
| apply Finset.sum_le_sum |
| intro i _ |
| apply (abs_sub _ _).trans |
| rw [abs_mul,abs_mul,abs_of_nonneg hc,abs_of_nonneg (hW i)] |
| exact add_le_add (le_refl _) (mul_le_mul_of_nonneg_left hD (mul_nonneg hc (hW i))) |
| _ = (∑ i, |R i|)+c*J := by |
| simp only [Finset.sum_add_distrib,← Finset.sum_mul,← Finset.mul_sum,sW,mul_one] |
| _ ≤ K+c*J := add_le_add hR (le_refl _) |
|
|
| end SKFluctuations.Hierarchy |
|
|
| namespace SKFluctuations.Hierarchy |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped Topology NNReal BigOperators |
| universe uB vB wB |
| variable {ι : Type uB} {β : Type vB} {κ : β → Type wB} |
|
|
| def PrefixOrdered (a b : ℝ) : List (GaussianStep ι) → Prop |
| | [] => 0 ≤ a ∧ a ≤ b |
| | (m,_)::tail => 0 ≤ a ∧ a ≤ m ∧ 0 < m ∧ PrefixOrdered m b tail |
|
|
| theorem PrefixOrdered.positive {a b : ℝ} {front : List (GaussianStep ι)} |
| (h : PrefixOrdered a b front) : ∀ st ∈ front, 0 < st.1 := by |
| induction front generalizing a with |
| | nil => simp |
| | cons st tail ih => |
| rcases st with ⟨m,q⟩ |
| intro s hs |
| rcases List.mem_cons.mp hs with hs|hs |
| · simpa only [hs] using h.2.2.1 |
| · exact ih h.2.2.2 s hs |
|
|
| theorem PrefixOrdered.bounds {a b : ℝ} {front : List (GaussianStep ι)} |
| (h : PrefixOrdered a b front) : 0 ≤ a ∧ a ≤ b := by |
| induction front generalizing a with |
| | nil => exact h |
| | cons st tail ih => |
| rcases st with ⟨m,q⟩ |
| exact ⟨h.1,h.2.1.trans (ih h.2.2.2).2⟩ |
|
|
| def BoundaryTree.budget (V : β → ℝ) : {front : List (GaussianStep ι)} → BoundaryTree ι β front → ℝ |
| | _, .leaf b => V b |
| | _, .step _ T => T.budget V |
| | _, .fork T U => T.budget V+U.budget V |
|
|
| variable [Fintype ι] [∀ b, Fintype (κ b)] |
|
|
| noncomputable def BoundaryTree.score (F D : ℝ → (ι → ℝ) → ℝ) |
| (W B : ∀ b, κ b → ℝ → (ι → ℝ) → ℝ) {front : List (GaussianStep ι)} |
| (T : BoundaryTree ι β front) (a : ℝ) (σ : T.Assignment κ) (t : ℝ) (x : ι → ℝ) : ℝ := |
| T.response F D W B σ t x+a*T.weight F W σ t x*prefixTest front (F t) (D t) x |
|
|
| omit [∀ b, Fintype (κ b)] in |
| theorem BoundaryTree.score_smooth0 {l r J : ℝ} {F D : ℝ → (ι → ℝ) → ℝ} |
| {W B : ∀ b, κ b → ℝ → (ι → ℝ) → ℝ} |
| (hF : ParametricRegular l r J F D) |
| (hW : ∀ b σ, ∃ K, ParametricTest l r K (W b σ) (B b σ)) |
| {front : List (GaussianStep ι)} (T : BoundaryTree ι β front) |
| (hm : ∀ st ∈ front, 0 < st.1) (a : ℝ) (σ : T.Assignment κ) {t : ℝ} (ht : t ∈ Ioo l r) : |
| BddSmooth 0 (T.score F D W B a σ t) := |
| (T.response_smooth0 hF hW hm σ ht).add |
| (((T.weight_smooth0 hF hW hm σ ht).const_mul a).mul ((hF.prefix front hm).response_smooth0 ht)) |
|
|
| omit [∀ b, Fintype (κ b)] in |
| theorem BoundaryTree.score_step {l r J : ℝ} {F D : ℝ → (ι → ℝ) → ℝ} |
| {W B : ∀ b, κ b → ℝ → (ι → ℝ) → ℝ} |
| (hF : ParametricRegular l r J F D) |
| (hW : ∀ b σ, ∃ K, ParametricTest l r K (W b σ) (B b σ)) |
| {front : List (GaussianStep ι)} (T : BoundaryTree ι β front) |
| (hm : ∀ st ∈ front, 0 < st.1) (a m : ℝ) (q : ι → ℝ≥0) |
| (σ : T.Assignment κ) {t : ℝ} (ht : t ∈ Ioo l r) (x : ι → ℝ) : |
| (T.step (m,q)).score F D W B a σ t x = |
| shiftedMean (Measure.pi fun i => gaussianReal 0 (q i)) m (prefixContinuation front (F t)) |
| (T.score F D W B m σ t) x- |
| (m-a)*(T.step (m,q)).weight F W σ t x*prefixTest ((m,q)::front) (F t) (D t) x := by |
| let ν := Measure.pi fun i => gaussianReal 0 (q i) |
| have hi := (exponentialIncrement_gaussian q).integrable_shift |
| ((hF.prefix front hm).spatial t ht).choose_spec m x |
| have hB := T.response_smooth0 hF hW hm σ ht |
| have hA := T.weight_smooth0 hF hW hm σ ht |
| have hD := (hF.prefix front hm).response_smooth0 ht |
| have he : (T.score F D W B m σ t) = fun y => |
| T.response F D W B σ t y+m*(T.weight F W σ t y*prefixTest front (F t) (D t) y) := by |
| funext y |
| unfold score |
| ring |
| rw [he,shiftedMean_add hB ((hA.mul hD).const_mul m) hi,shiftedMean_const_mul] |
| simp only [score,response,weight,tiltedResponse,prefixTest] |
| ring |
|
|
| |
|
|
| theorem BoundaryTree.score_variation {l r J m a : ℝ} {F D : ℝ → (ι → ℝ) → ℝ} |
| {W B : ∀ b, κ b → ℝ → (ι → ℝ) → ℝ} {V : β → ℝ} |
| (hF : ParametricRegular l r J F D) |
| (hW : ∀ b σ, ∃ K, ParametricTest l r K (W b σ) (B b σ)) |
| (hp : ∀ b, ∀ t ∈ Ioo l r, ∀ x, (∀ σ, 0 ≤ W b σ t x) ∧ ∑ σ, W b σ t x = 1) |
| (hv : ∀ b, ∀ t ∈ Ioo l r, ∀ x, ∑ σ, |B b σ t x+m*W b σ t x*D t x| ≤ V b) |
| {front : List (GaussianStep ι)} (T : BoundaryTree ι β front) |
| (ha : PrefixOrdered a m front) {t : ℝ} (ht : t ∈ Ioo l r) (x : ι → ℝ) : |
| ∑ σ, |T.score F D W B a σ t x| ≤ T.budget (fun b => V b+m*J)-a*J := by |
| induction T generalizing a x with |
| | leaf b => |
| have hh := finite_law_subtraction_bound (hp b t ht x).1 (hp b t ht x).2 (hv b t ht x) |
| (sub_nonneg.mpr ha.2) (hF.bounded t ht x) |
| have he (σ : κ b) : (B b σ t x+m*W b σ t x*D t x)-(m-a)*W b σ t x*D t x = |
| (BoundaryTree.leaf b : BoundaryTree ι β []).score F D W B a σ t x := by |
| simp only [score,response,weight,prefixTest] |
| ring |
| simp_rw [he] at hh |
| dsimp only [budget] |
| linarith |
| | @step st tail T ih => |
| rcases st with ⟨b,q⟩ |
| let ν := Measure.pi fun i => gaussianReal 0 (q i) |
| have hm := ha.positive |
| have hb := ha.2.2.2.positive |
| have hi := (exponentialIncrement_gaussian q).integrable_shift |
| ((hF.prefix tail hb).spatial t ht).choose_spec b x |
| have hs := sum_abs_shiftedMean_le (fun σ => T.score_smooth0 hF hW hb b σ ht) |
| (fun y => ih ha.2.2.2 y) hi |
| have hp' := (T.step (b,q)).probability hF hW hp hm ht x |
| have hd := (hF.prefix ((b,q)::tail) hm).bounded t ht x |
| have hh := finite_law_subtraction_bound hp'.1 hp'.2 hs (sub_nonneg.mpr ha.2.1) hd |
| simp_rw [← T.score_step hF hW hb a b q _ ht x] at hh |
| dsimp only [budget] |
| linarith |
| | @fork front T U ihT ihU => |
| have hT := T.probability hF hW hp ha.positive ht x |
| have hU := U.probability hF hW hp ha.positive ht x |
| have hd := (hF.prefix front ha.positive).bounded t ht x |
| have hh := finite_law_score_fork hT.1 hU.1 hT.2 hU.2 (ihT ha x) (ihU ha x) ha.bounds.1 hd |
| change (∑ σ : T.Assignment κ × U.Assignment κ, |
| |T.response F D W B σ.1 t x*U.weight F W σ.2 t x+ |
| T.weight F W σ.1 t x*U.response F D W B σ.2 t x+ |
| a*(T.weight F W σ.1 t x*U.weight F W σ.2 t x)*prefixTest front (F t) (D t) x|) ≤ _ |
| dsimp only [budget] |
| exact hh.trans (by linarith) |
| |
| end SKFluctuations.Hierarchy |
| |
| namespace SKFluctuations.Hierarchy |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped Topology NNReal BigOperators |
| universe uB vB wB |
| |
| theorem finite_law_addition_bound {κ : Type*} [Fintype κ] |
| {W R : κ → ℝ} {c D K J : ℝ} (hW : ∀ i, 0 ≤ W i) (sW : ∑ i, W i = 1) |
| (hR : ∑ i, |R i| ≤ K) (hc : 0 ≤ c) (hD : |D| ≤ J) : |
| ∑ i, |R i+c*W i*D| ≤ K+c*J := by |
| have hh := finite_law_subtraction_bound hW sW hR hc (show |-D| ≤ J by simpa only [abs_neg] using hD) |
| simpa only [mul_neg,sub_neg_eq_add] using hh |
| |
| variable {ι : Type uB} {β : Type vB} {κ : β → Type wB} [Fintype ι] [∀ b, Fintype (κ b)] |
| |
| noncomputable def BoundaryTree.expect (F : ℝ → (ι → ℝ) → ℝ) |
| (W : ∀ b, κ b → ℝ → (ι → ℝ) → ℝ) {front : List (GaussianStep ι)} |
| (T : BoundaryTree ι β front) (P : T.Assignment κ → ℝ) (t : ℝ) (x : ι → ℝ) : ℝ := |
| ∑ σ, P σ*T.weight F W σ t x |
| |
| theorem BoundaryTree.expect_hasDerivAt {l r J : ℝ} {F D : ℝ → (ι → ℝ) → ℝ} |
| {W B : ∀ b, κ b → ℝ → (ι → ℝ) → ℝ} |
| (hF : ParametricRegular l r J F D) |
| (hW : ∀ b σ, ∃ K, ParametricTest l r K (W b σ) (B b σ)) |
| {front : List (GaussianStep ι)} (T : BoundaryTree ι β front) |
| (hm : ∀ st ∈ front, 0 < st.1) (P : T.Assignment κ → ℝ) {t : ℝ} (ht : t ∈ Ioo l r) (x : ι → ℝ) : |
| HasDerivAt (fun s => T.expect F W P s x) (∑ σ, P σ*T.response F D W B σ t x) t := by |
| exact HasDerivAt.fun_sum (u := Finset.univ) (fun σ _ => |
| ((T.parametric hF hW hm σ).choose_spec.derivative t ht x).const_mul (P σ)) |
| |
| theorem BoundaryTree.tested_response_bound {F D : ℝ → (ι → ℝ) → ℝ} |
| {W B : ∀ b, κ b → ℝ → (ι → ℝ) → ℝ} {front : List (GaussianStep ι)} |
| (T : BoundaryTree ι β front) {P : T.Assignment κ → ℝ} {C K : ℝ} {t : ℝ} {x : ι → ℝ} |
| (hC : 0 ≤ C) (hP : ∀ σ, |P σ| ≤ C) |
| (hR : ∑ σ, |T.response F D W B σ t x| ≤ K) : |
| |∑ σ, P σ*T.response F D W B σ t x| ≤ C*K := by |
| apply (Finset.abs_sum_le_sum_abs _ _).trans |
| calc |
| _ ≤ ∑ σ, C*|T.response F D W B σ t x| := Finset.sum_le_sum fun σ _ => by |
| rw [abs_mul] |
| exact mul_le_mul_of_nonneg_right (hP σ) (abs_nonneg _) |
| _ = C*∑ σ, |T.response F D W B σ t x| := (Finset.mul_sum _ _ _).symm |
| _ ≤ C*K := mul_le_mul_of_nonneg_left hR hC |
| |
| 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 : ℕ} |
| |
| noncomputable def ReplicaTree.atomicClock (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ) |
| (L : (Fin (n+1) → ℝ) →L[ℝ] (ι → ℝ)) {steps : List (GaussianStep ι)} |
| (T : ReplicaTree ι S steps) (m : ℝ) (σ : T.Assignment) : ℝ → (ι → ℝ) → ℝ := by |
| classical |
| exact linearClockTest L m (gaussianHierarchy w φ steps) (T.expect w φ (fun τ => if τ = σ then 1 else 0)) |
| |
| noncomputable def ReplicaTree.atomicResponse (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ) |
| (L : (Fin (n+1) → ℝ) →L[ℝ] (ι → ℝ)) {steps : List (GaussianStep ι)} |
| (T : ReplicaTree ι S steps) (m : ℝ) (σ : T.Assignment) : ℝ → (ι → ℝ) → ℝ := by |
| classical |
| exact T.clockResponse w φ L m (fun τ => if τ = σ then 1 else 0) |
| |
| |
| |
| theorem BoundaryTree.actual_inserted_response_variation {w : S → ℝ} (hw : ∀ σ, 0 < w σ) |
| (φ : S → (ι → ℝ) →L[ℝ] ℝ) (L : (Fin (n+1) → ℝ) →L[ℝ] (ι → ℝ)) |
| {steps : List (GaussianStep ι)} (R : β → ReplicaTree ι S steps) |
| {m Q : ℝ} (ha : OrderedSteps m steps) (hm : 0 < m) |
| (hQ : ∀ σ, ∑ i, (φ σ (L (Pi.single i 1)))^2 = Q) |
| (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 m front) |
| {t : ℝ} (ht : 0 < t) (x : ι → ℝ) : |
| ∑ σ, |T.response (linearClockContinuation L m (gaussianHierarchy w φ steps)) |
| (featureClockResponse w φ L steps m) |
| (fun b => (R b).atomicClock w φ L m) (fun b => (R b).atomicResponse w φ L m) σ t x| ≤ |
| T.budget (fun b => 4*((R b).leaves:ℝ)*((R b).leaves+1:ℝ)*(∑ i, (D i)^2)+m*Q) := by |
| classical |
| let F := linearClockContinuation L m (gaussianHierarchy w φ steps) |
| let J := featureClockResponse w φ L steps m |
| let W := fun b => (R b).atomicClock w φ L m |
| let B := fun b => (R b).atomicResponse w φ L m |
| have hF : ParametricRegular 0 (t+1) (Q/2) F J := parametric_featureClock hw φ L hQ steps ha hm (t+1) |
| have hW : ∀ b σ, ∃ K, ParametricTest 0 (t+1) K (W b σ) (B b σ) := by |
| intro b σ |
| refine ⟨_,(R b).parametric_clockTest hw φ L ha D (by norm_num : (0:ℝ) ≤ 1) hD ?_ hB (t+1)⟩ |
| intro τ |
| split_ifs <;> norm_num |
| have hp : ∀ b, ∀ s ∈ Ioo 0 (t+1), ∀ y, (∀ σ, 0 ≤ W b σ s y) ∧ ∑ σ, W b σ s y = 1 := by |
| intro b s _ y |
| exact (R b).atomic_clockTest_probability hw φ L ha s y |
| let V : β → ℝ := fun b => 4*((R b).leaves:ℝ)*((R b).leaves+1:ℝ)*(∑ i, (D i)^2)+m*(Q/2) |
| have hv : ∀ b, ∀ s ∈ Ioo 0 (t+1), ∀ y, ∑ σ, |B b σ s y+m*W b σ s y*J s y| ≤ V b := by |
| intro b s hs y |
| exact finite_law_addition_bound (hp b s hs y).1 (hp b s hs y).2 |
| ((R b).atomic_clockResponse_variation hw φ L ha D hD hB hs.1 y) hm.le (hF.bounded s hs y) |
| have hs := T.score_variation hF hW hp hv hO (show t ∈ Ioo 0 (t+1) by exact ⟨ht,by linarith⟩) x |
| have he : (fun b => V b+m*(Q/2)) = (fun b => 4*((R b).leaves:ℝ)*((R b).leaves+1:ℝ)*(∑ i, (D i)^2)+m*Q) := by |
| funext b |
| dsimp [V] |
| ring |
| rw [he] at hs |
| simpa only [BoundaryTree.score,zero_mul,add_zero,sub_zero] using hs |
| |
| end SKFluctuations.Hierarchy |
| |
| namespace SKFluctuations.Hierarchy |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped Topology NNReal BigOperators |
| variable {ι : Type*} [Fintype ι] |
| |
| def interpolate (F G : (ι → ℝ) → ℝ) (t : ℝ) (x : ι → ℝ) : ℝ := |
| (1-t)*F x+t*G x |
| |
| omit [Fintype ι] in |
| theorem interpolate_derivative (F G : (ι → ℝ) → ℝ) (t : ℝ) (x : ι → ℝ) : |
| HasDerivAt (fun s => interpolate F G s x) (G x-F x) t := by |
| apply ((((hasDerivAt_const t (1:ℝ)).sub (hasDerivAt_id t)).mul_const (F x)).add |
| ((hasDerivAt_id t).mul_const (G x))).congr_deriv |
| ring |
| |
| theorem parametric_interpolate {F G : (ι → ℝ) → ℝ} {C₀ C₁ : ℝ≥0} {K l r : ℝ} |
| (hF : LipschitzWith C₀ F) (hG : LipschitzWith C₁ G) (hK : 0 ≤ K) |
| (hb : ∀ x, |G x-F x| ≤ K) : |
| ParametricRegular l r K (interpolate F G) (fun _ x => G x-F x) := by |
| refine ⟨hK,?_,fun _ _ => hG.continuous.sub hF.continuous,fun _ _ x => hb x,fun t _ x => interpolate_derivative F G t x⟩ |
| intro t _ |
| exact ⟨_,((lipschitzWith_smul (1-t)).comp hF).add ((lipschitzWith_smul t).comp hG)⟩ |
| |
| omit [Fintype ι] in |
| theorem parametricTest_interpolate {F G : (ι → ℝ) → ℝ} {K : ℝ} |
| (hF : Continuous F) (hG : Continuous G) (hK : 0 ≤ K) |
| (hbF : ∀ x, |F x| ≤ K) (hbG : ∀ x, |G x| ≤ K) : |
| ParametricTest (-1) 2 (5*K) (interpolate F G) (fun _ x => G x-F x) := by |
| refine ⟨by positivity,fun t _ => (hF.const_mul (1-t)).add (hG.const_mul t), |
| fun _ _ => hG.sub hF,?_,?_,fun t _ x => interpolate_derivative F G t x⟩ |
| · intro t ht x |
| have ht1 : |1-t| ≤ 3 := by rw [abs_le]; constructor <;> linarith [ht.1,ht.2] |
| have ht2 : |t| ≤ 2 := by rw [abs_le]; constructor <;> linarith [ht.1,ht.2] |
| unfold interpolate |
| apply (abs_add_le _ _).trans |
| rw [abs_mul,abs_mul] |
| have h1 := mul_le_mul ht1 (hbF x) (abs_nonneg _) (by norm_num : (0:ℝ) ≤ 3) |
| have h2 := mul_le_mul ht2 (hbG x) (abs_nonneg _) (by norm_num : (0:ℝ) ≤ 2) |
| linarith |
| · intro t _ x |
| exact (abs_sub _ _).trans (by linarith [hbF x,hbG x]) |
| |
| theorem ParametricRegular.restrict {l r l' r' K : ℝ} {F D : ℝ → (ι → ℝ) → ℝ} |
| (h : ParametricRegular l r K F D) (hs : Ioo l' r' ⊆ Ioo l r) : ParametricRegular l' r' K F D := |
| ⟨h.nonneg,fun t ht => h.spatial t (hs ht),fun t ht => h.continuous t (hs ht), |
| fun t ht => h.bounded t (hs ht),fun t ht => h.derivative t (hs ht)⟩ |
| |
| omit [Fintype ι] in |
| theorem ParametricTest.restrict {l r l' r' K : ℝ} {A B : ℝ → (ι → ℝ) → ℝ} |
| (h : ParametricTest l r K A B) (hs : Ioo l' r' ⊆ Ioo l r) : ParametricTest l' r' K A B := |
| ⟨h.nonneg,fun t ht => h.continuous t (hs ht),fun t ht => h.response_continuous t (hs ht), |
| fun t ht => h.bounded t (hs ht),fun t ht => h.response_bounded t (hs ht), |
| fun t ht => h.derivative t (hs ht)⟩ |
| |
| end SKFluctuations.Hierarchy |
| |
| end |
| |
| end OAI |
| |
