lean/OAI/Probability/SKFluctuations/CompContDiff.lean

import Mathlib
import OAI.Probability.SKFluctuations.LineDerivativesSignEquivVolume

namespace OAI

/-! Comp Cont Diff. -/

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 ContDiff
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]

 

theorem BddSmooth.comp_contDiff {n : ℕ} {A : E → ℝ} (hA : BddSmooth n A)
    {f : ℝ → ℝ} (hf : ContDiff ℝ ∞ f) : BddSmooth n (fun x => f (A x)) := by
  induction n generalizing A f with
  | zero =>
    obtain ⟨B,hB,hb⟩ := hA.bound
    obtain ⟨C,hC⟩ := (isCompact_Icc : IsCompact (Icc (-B) B)).exists_bound_of_continuousOn
      hf.continuous.continuousOn
    refine ⟨hf.continuous.comp hA.continuous, max C 0, le_max_right _ _, fun x => ?_⟩
    exact (hC (A x) (abs_le.mp (hb x))).trans (le_max_left _ _)
  | succ n ih =>
    refine ⟨ih hA.down hf, fun v => ?_⟩
    obtain ⟨A₁,hA₁,hd⟩ := hA.2 v
    have hdf : ContDiff ℝ ∞ (deriv f) := (contDiff_infty_iff_deriv.mp hf).2
    refine ⟨fun x => deriv f (A x)*A₁ x, (ih hA.down hdf).mul hA₁, fun x t => ?_⟩
    exact ((contDiff_infty_iff_deriv.mp hf).1 (A (x+t•v))).hasDerivAt.comp t (hd x t)

 
def smoothAbsPower (ε p : ℝ) (x : ℝ) : ℝ := (x^2+ε)^(p/2)

theorem contDiff_smoothAbsPower {ε : ℝ} (hε : 0 < ε) (p : ℝ) :
    ContDiff ℝ ∞ (smoothAbsPower ε p) := by
  exact ((contDiff_id.pow 2).add contDiff_const).rpow_const_of_ne
    (fun x => ne_of_gt (add_pos_of_nonneg_of_pos (sq_nonneg x) hε))

theorem BddSmooth.smoothAbsPower {n : ℕ} {A : E → ℝ} (hA : BddSmooth n A)
    {ε : ℝ} (hε : 0 < ε) (p : ℝ) : BddSmooth n (fun x => smoothAbsPower ε p (A x)) :=
  hA.comp_contDiff (contDiff_smoothAbsPower hε p)

end SKFluctuations.Hierarchy

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set
open scoped NNReal Topology

 

theorem potentialLaw_equiv {n : ℕ} (T : (Fin n → ℝ) ≃L[ℝ] (Fin n → ℝ))
    (hT : MeasurePreserving T volume volume) {U V : (Fin n → ℝ) → ℝ}
    (hUV : ∀ x, V (T x) = U x) :
    MeasurePreserving T (potentialLaw U) (potentialLaw V) := by
  have hI : (∫ z, Real.exp (-V z)) = ∫ z, Real.exp (-U z) := by
    rw [← hT.integral_comp T.toHomeomorph.toMeasurableEquiv.measurableEmbedding]
    simp_rw [hUV]
  have hn (x : Fin n → ℝ) : normalizedPotential V (T x) = normalizedPotential U x := by
    simp only [normalizedPotential, hUV, hI]
  refine ⟨T.continuous.measurable, ?_⟩
  ext s hs
  rw [Measure.map_apply T.continuous.measurable hs]
  unfold potentialLaw
  rw [withDensity_apply _ (T.continuous.measurable hs), withDensity_apply _ hs,
    ← lintegral_indicator (T.continuous.measurable hs), ← lintegral_indicator hs]
  rw [← hT.lintegral_comp_emb T.toHomeomorph.toMeasurableEquiv.measurableEmbedding
    (s.indicator (fun x => ENNReal.ofReal (Real.exp (-normalizedPotential V x))))]
  apply lintegral_congr
  intro x
  by_cases hx : T x ∈ s
  · simp only [mem_preimage, hx, indicator_of_mem, hn]
  · simp only [mem_preimage, hx, not_false_eq_true, indicator_of_notMem]

theorem potentialLaw_joint_test_eq {n : ℕ} (T : (Fin n → ℝ) ≃L[ℝ] (Fin n → ℝ))
    (hT : MeasurePreserving T volume volume) {U V A B J K : (Fin n → ℝ) → ℝ}
    (hUV : ∀ x, V (T x) = U x) (hAB : ∀ x, B (T x) = A x)
    (hJK : ∀ x, K (T x) = J x) (f : ℝ × ℝ → ℝ) :
    (∫ x, f (B x, K x) ∂potentialLaw V) =
      ∫ x, f (A x, J x) ∂potentialLaw U := by
  rw [← (potentialLaw_equiv T hT hUV).integral_comp
    T.toHomeomorph.toMeasurableEquiv.measurableEmbedding]
  simp_rw [hAB, hJK]

end SKFluctuations.Hierarchy

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set
open scoped NNReal Topology ContDiff
open SKFluctuations.PinnedVariance SKFluctuations.PreKopa

theorem BddSmooth.lineDeriv_comp_contDiff {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    {A : E → ℝ} (hA : BddSmooth 1 A) {f : ℝ → ℝ} (hf : ContDiff ℝ ∞ f) (x v : E) :
    lineDeriv ℝ (fun y => f (A y)) x v = deriv f (A x)*lineDeriv ℝ A x v := by
  apply HasLineDerivAt.lineDeriv
  have h := (((contDiff_infty_iff_deriv.mp hf).1 (A (x+0•v))).hasDerivAt).comp 0
    (hA.hasDerivAt_line x v 0)
  simpa only [zero_smul, add_zero, HasLineDerivAt, Function.comp_def] using h

 

theorem variance_comp_le_BddSmooth_block {n : ℕ} {U A J : (Fin n → ℝ) → ℝ}
    {μ : Measure (Fin n → ℝ)} [IsProbabilityMeasure μ]
    (hμ : μ = volume.withDensity (fun x => ENNReal.ofReal (Real.exp (-U x))))
    (hU : GaussianDominated (fun x => Real.exp (-U x))) (hUc : Continuous U)
    (DU : LineDerivatives U) (hA : BddSmooth 2 A) (hJ : BddSmooth 2 J)
    (hstrong : ∀ x v, ‖v‖^2 ≤ DU.second x v)
    (hblock : ∀ x v s, 0 ≤ DU.second x v - 2*s*lineDeriv ℝ A x v + s^2*J x)
    {f : ℝ → ℝ} (hf : ContDiff ℝ ∞ f) :
    variance (fun x => f (A x)) μ ≤ ∫ x, (deriv f (A x))^2 * J x ∂μ := by
  have hdf : ContDiff ℝ ∞ (deriv f) := (contDiff_infty_iff_deriv.mp hf).2
  have hg : BddSmooth 2 (fun x => deriv f (A x)) := hA.comp_contDiff hdf
  simp only [pow_two]
  apply variance_le_BddSmooth_block hμ hU hUc DU (hA.comp_contDiff hf)
    ((hg.mul hg).mul hJ) hstrong
  intro x v s
  rw [hA.down.lineDeriv_comp_contDiff hf x v]
  convert hblock x v (s*deriv f (A x)) using 1
  ring

end SKFluctuations.Hierarchy

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory
open scoped NNReal Topology
variable {ι S : Type*} [Fintype ι] [Fintype S]

theorem gaussianHierarchyMean_const_mul (w : S → ℝ) (φ : S → (ι → ℝ) →L[ℝ] ℝ)
    (A : S → ℝ) (steps : List (GaussianStep ι)) (c : ℝ) (x : ι → ℝ) :
    gaussianHierarchyMean w φ (fun s => c*A s) steps x =
      c*gaussianHierarchyMean w φ A steps x := by
  induction steps generalizing x with
  | nil =>
    simp only [gaussianHierarchyMean, Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro s _
    ring
  | cons p tail ih =>
    obtain ⟨m,q⟩ := p
    simp only [gaussianHierarchyMean, funext ih]
    exact shiftedMean_const_mul c x

end SKFluctuations.Hierarchy

namespace SKFluctuations
open MeasureTheory ProbabilityTheory
open scoped BigOperators Topology NNReal
open Hierarchy

 

abbrev FeatureIndex (n : ℕ) := Sum (Fin n) (CompletedIndex n)

def featureCoefficient (n : ℕ) (σ : Spin n) : FeatureIndex n → ℝ
  | Sum.inl i => spinValue (σ i)
  | Sum.inr j => liftedCoefficients 1 n σ j

def finiteFeature (n : ℕ) (σ : Spin n) : (FeatureIndex n → ℝ) →L[ℝ] ℝ :=
  ∑ i, featureCoefficient n σ i • ContinuousLinearMap.proj i

@[simp] theorem finiteFeature_apply (n : ℕ) (σ : Spin n) (x : FeatureIndex n → ℝ) :
    finiteFeature n σ x = ∑ i, featureCoefficient n σ i*x i := by
  simp [finiteFeature]

def uniformWeight (n : ℕ) (_ : Spin n) : ℝ := (2 : ℝ)^(-(n : ℤ))

theorem uniformWeight_pos (n : ℕ) (σ : Spin n) : 0 < uniformWeight n σ := by
  exact zpow_pos (by norm_num) _

def featureSigns {n : ℕ} (τ : Spin n) : FeatureIndex n → ℝ
  | Sum.inl i => spinValue (τ i)
  | Sum.inr none => 1
  | Sum.inr (some e) => spinValue (τ e.val.1)*spinValue (τ e.val.2)

theorem featureSigns_sq {n : ℕ} (τ : Spin n) (i : FeatureIndex n) :
    featureSigns τ i*featureSigns τ i = 1 := by
  rcases i with i | (_ | e)
  · exact spinValue_sq _
  · norm_num [featureSigns]
  · dsimp [featureSigns]
    calc
      _ = (spinValue (τ e.val.1)*spinValue (τ e.val.1))*
        (spinValue (τ e.val.2)*spinValue (τ e.val.2)) := by ring
      _ = 1 := by rw [spinValue_sq, spinValue_sq]; norm_num

def featureGauge {n : ℕ} (τ : Spin n) : (FeatureIndex n → ℝ) ≃L[ℝ] (FeatureIndex n → ℝ) :=
  signEquiv (featureSigns τ) (featureSigns_sq τ)

theorem featureCoefficient_gauge {n : ℕ} (τ σ : Spin n) (i : FeatureIndex n) :
    featureCoefficient n (spinGauge τ σ) i = featureSigns τ i*featureCoefficient n σ i := by
  rcases i with i | (_ | e)
  · simp [featureCoefficient, featureSigns, spinGauge]
  · simp [featureCoefficient, featureSigns, liftedCoefficients]
  · simp only [featureCoefficient, featureSigns, liftedCoefficients, spinGauge,
      Equiv.coe_fn_mk, spinValue_beq]
    ring

theorem finiteFeature_gauge {n : ℕ} (τ σ : Spin n) (x : FeatureIndex n → ℝ) :
    finiteFeature n (spinGauge τ σ) (featureGauge τ x) = finiteFeature n σ x := by
  simp only [finiteFeature_apply]
  apply Finset.sum_congr rfl
  intro i _
  rw [featureCoefficient_gauge]
  change (featureSigns τ i * featureCoefficient n σ i)*(featureSigns τ i*x i) = _
  calc
    _ = (featureSigns τ i*featureSigns τ i)*(featureCoefficient n σ i*x i) := by ring
    _ = _ := by rw [featureSigns_sq, one_mul]

theorem featureGauge_gaussian {n : ℕ} (τ : Spin n) (q : FeatureIndex n → ℝ≥0) :
    MeasurePreserving (featureGauge τ) (Measure.pi fun i => gaussianReal 0 (q i))
      (Measure.pi fun i => gaussianReal 0 (q i)) :=
  signEquiv_gaussian _ _ q

theorem featureGauge_volume {n : ℕ} (τ : Spin n) :
    MeasurePreserving (featureGauge τ) volume volume := signEquiv_volume _ _

 
def finiteSKHierarchy (n : ℕ) (steps : List (GaussianStep (FeatureIndex n))) :
    (FeatureIndex n → ℝ) → ℝ := gaussianHierarchy (uniformWeight n) (finiteFeature n) steps

theorem finiteSKHierarchy_gauge (n : ℕ) (steps : List (GaussianStep (FeatureIndex n)))
    (τ : Spin n) (x : FeatureIndex n → ℝ) :
    finiteSKHierarchy n steps (featureGauge τ x) = finiteSKHierarchy n steps x :=
  gaussianHierarchy_equiv (featureGauge τ) (spinGauge τ) (fun _ => rfl)
    (finiteFeature_gauge τ) steps (fun p _ => featureGauge_gaussian τ p.2) x

 
def spinSource (n : ℕ) (i : Fin n) : FeatureIndex n → ℝ :=
  Pi.single (Sum.inl i) (1 / Real.sqrt (n : ℝ))

theorem finiteFeature_source (n : ℕ) (σ : Spin n) (i : Fin n) :
    finiteFeature n σ (spinSource n i) = spinValue (σ i) / Real.sqrt (n : ℝ) := by
  classical
  simp [finiteFeature_apply, spinSource, Pi.single_apply, featureCoefficient, mul_ite, div_eq_mul_inv]

theorem spinSource_gauge {n : ℕ} (τ : Spin n) (i : Fin n) :
    featureGauge τ (spinSource n i) = spinValue (τ i) • spinSource n i := by
  classical
  ext j
  change featureSigns τ j * (Pi.single (Sum.inl i) (1 / Real.sqrt (n : ℝ)) : FeatureIndex n → ℝ) j =
    spinValue (τ i) * (Pi.single (Sum.inl i) (1 / Real.sqrt (n : ℝ)) : FeatureIndex n → ℝ) j
  by_cases hj : j = Sum.inl i
  · subst j; rfl
  · simp [hj]

 

def matrixEmbedding (β : ℝ) (n : ℕ) (x : StandardCompletedDisorder n) : FeatureIndex n → ℝ
  | Sum.inl _ => 0
  | Sum.inr i => β*x i

theorem finiteFeature_matrixEmbedding (β : ℝ) (n : ℕ) (σ : Spin n)
    (x : StandardCompletedDisorder n) :
    finiteFeature n σ (matrixEmbedding β n x) = liftedHamiltonian β n x σ := by
  rw [finiteFeature_apply, liftedHamiltonian_eq_sum, Fintype.sum_sum_type]
  simp only [matrixEmbedding, mul_zero, Finset.sum_const_zero, zero_add, featureCoefficient]
  apply Finset.sum_congr rfl
  intro i _
  cases i <;> simp only [liftedCoefficients] <;> ring

end SKFluctuations

namespace SKFluctuations
open MeasureTheory ProbabilityTheory Hierarchy
open scoped NNReal Topology BigOperators

theorem spinMean_gauge (n : ℕ) (steps : List (GaussianStep (FeatureIndex n)))
    (τ : Spin n) (x : FeatureIndex n → ℝ) (i : Fin n) :
    gaussianHierarchyMean (uniformWeight n) (finiteFeature n)
      (fun s => finiteFeature n s (spinSource n i)) steps (featureGauge τ x) =
    spinValue (τ i) * gaussianHierarchyMean (uniformWeight n) (finiteFeature n)
      (fun s => finiteFeature n s (spinSource n i)) steps x := by
  rw [gaussianHierarchyMean_equiv (featureGauge τ) (spinGauge τ) (fun _ => rfl)
    (finiteFeature_gauge τ) steps (fun p _ => featureGauge_gaussian τ p.2)]
  have he : (fun s => finiteFeature n (spinGauge τ s) (spinSource n i)) =
      (fun s => spinValue (τ i)*finiteFeature n s (spinSource n i)) := by
    funext s
    simp only [finiteFeature_source, spinGauge, Equiv.coe_fn_mk, spinValue_beq]
    ring
  rw [he, gaussianHierarchyMean_const_mul]

 

theorem spinObservable_gauge (n : ℕ) (steps : List (GaussianStep (FeatureIndex n)))
    (τ σ : Spin n) (x : FeatureIndex n → ℝ) :
    driverObservable (uniformWeight n) (finiteFeature n) steps
      (ContinuousLinearMap.id ℝ _) (spinSource n) (spinGauge τ σ) (featureGauge τ x) =
    driverObservable (uniformWeight n) (finiteFeature n) steps
      (ContinuousLinearMap.id ℝ _) (spinSource n) σ x := by
  unfold driverObservable driverMean
  simp only [ContinuousLinearMap.id_apply]
  simp_rw [spinMean_gauge]
  simp only [finiteFeature_source, spinGauge, Equiv.coe_fn_mk, spinValue_beq]
  apply Finset.sum_congr rfl
  intro i _
  have hs := spinValue_sq (τ i)
  rcases mul_self_eq_one_iff.mp hs with hi | hi <;> rw [hi] <;> ring

end SKFluctuations

namespace SKFluctuations
open MeasureTheory ProbabilityTheory Hierarchy
open scoped NNReal Topology BigOperators

theorem spinDriverSource_gauge (n : ℕ) (steps : List (GaussianStep (FeatureIndex n)))
    (τ σ : Spin n) (x : FeatureIndex n → ℝ) :
    driverSource (uniformWeight n) (finiteFeature n) steps
      (ContinuousLinearMap.id ℝ _) (spinSource n) (spinGauge τ σ) (featureGauge τ x) =
    featureGauge τ (driverSource (uniformWeight n) (finiteFeature n) steps
      (ContinuousLinearMap.id ℝ _) (spinSource n) σ x) := by
  unfold driverSource driverMean
  simp only [ContinuousLinearMap.id_apply, map_sum, map_smul, spinSource_gauge, smul_smul]
  simp_rw [spinMean_gauge]
  apply Finset.sum_congr rfl
  intro i _
  congr 1
  simp only [finiteFeature_source, spinGauge, Equiv.coe_fn_mk, spinValue_beq]
  ring

theorem spinEnergy_gauge (n : ℕ) (steps : List (GaussianStep (FeatureIndex n)))
    {a : ℝ} (ha : OrderedSteps a steps) (τ σ : Spin n) (x : FeatureIndex n → ℝ) :
    driverEnergy (uniformWeight n) (finiteFeature n) steps
      (ContinuousLinearMap.id ℝ _) (spinSource n) (spinGauge τ σ) (featureGauge τ x) =
    driverEnergy (uniformWeight n) (finiteFeature n) steps
      (ContinuousLinearMap.id ℝ _) (spinSource n) σ x := by
  rw [driverEnergy_eq (uniformWeight_pos n) (finiteFeature n) steps ha,
    driverEnergy_eq (uniformWeight_pos n) (finiteFeature n) steps ha]
  simp only [ContinuousLinearMap.id_apply, spinDriverSource_gauge]
  exact gaussianHierarchyHessian_equiv (featureGauge τ) (spinGauge τ) (uniformWeight_pos n)
    (fun _ => rfl) (finiteFeature_gauge τ) steps ha
    (fun p _ => featureGauge_gaussian τ p.2) _ _ _

end SKFluctuations

namespace SKFluctuations
open MeasureTheory ProbabilityTheory Hierarchy
open scoped NNReal Topology BigOperators

abbrev IncrementIndex (n L : ℕ) := Fin (L+1) × FeatureIndex n
abbrev DriverDimension (n L : ℕ) := Fintype.card (IncrementIndex n L)

 

def prefixDriver (n L : ℕ) (q : Fin (L+1) → FeatureIndex n → ℝ≥0)
    (cut : Fin (L+1)) : (Fin (DriverDimension n L) → ℝ) →L[ℝ] (FeatureIndex n → ℝ) :=
  ContinuousLinearMap.pi fun i => ∑ k ∈ Finset.univ.filter (· ≤ cut),
    Real.sqrt (q k i : ℝ) • ContinuousLinearMap.proj (Fintype.equivFin (IncrementIndex n L) (k,i))

@[simp] theorem prefixDriver_apply (n L : ℕ) (q : Fin (L+1) → FeatureIndex n → ℝ≥0)
    (cut : Fin (L+1)) (x : Fin (DriverDimension n L) → ℝ) (i : FeatureIndex n) :
    prefixDriver n L q cut x i = ∑ k ∈ Finset.univ.filter (· ≤ cut),
      Real.sqrt (q k i : ℝ)*x (Fintype.equivFin (IncrementIndex n L) (k,i)) := by
  simp [prefixDriver]

def driverSigns (n L : ℕ) (τ : Spin n) (j : Fin (DriverDimension n L)) : ℝ :=
  featureSigns τ ((Fintype.equivFin (IncrementIndex n L)).symm j).2

theorem driverSigns_sq (n L : ℕ) (τ : Spin n) (j : Fin (DriverDimension n L)) :
    driverSigns n L τ j*driverSigns n L τ j = 1 := featureSigns_sq τ _

def driverGauge (n L : ℕ) (τ : Spin n) :
    (Fin (DriverDimension n L) → ℝ) ≃L[ℝ] (Fin (DriverDimension n L) → ℝ) :=
  signEquiv (driverSigns n L τ) (driverSigns_sq n L τ)

theorem prefixDriver_gauge (n L : ℕ) (q : Fin (L+1) → FeatureIndex n → ℝ≥0)
    (cut : Fin (L+1)) (τ : Spin n) (x : Fin (DriverDimension n L) → ℝ) :
    prefixDriver n L q cut (driverGauge n L τ x) = featureGauge τ (prefixDriver n L q cut x) := by
  ext i
  simp only [prefixDriver_apply, driverGauge, signEquiv_apply, driverSigns,
    Equiv.symm_apply_apply, featureGauge]
  rw [Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro k _
  ring

 

def skPinFrame (n L : ℕ) (q : Fin (L+1) → FeatureIndex n → ℝ≥0)
    (cut : Fin (L+1)) (steps : List (GaussianStep (FeatureIndex n)))
    (a : ℝ) (ha : OrderedSteps a steps) :
    PinFrame (FeatureIndex n) (Spin n) (Fin n) (DriverDimension n L) where
  weight := uniformWeight n
  weight_pos := uniformWeight_pos n
  feature := finiteFeature n
  steps := steps
  mass := a
  ordered := ha
  driver := prefixDriver n L q cut
  source := spinSource n

end SKFluctuations

namespace SKFluctuations
open MeasureTheory ProbabilityTheory Hierarchy
open scoped NNReal Topology BigOperators
variable {n L : ℕ} (q : Fin (L+1) → FeatureIndex n → ℝ≥0)
  (cuts : Fin (L+1) → Fin (L+1))
  (steps : Fin (L+1) → List (GaussianStep (FeatureIndex n)))
  (a : Fin (L+1) → ℝ) (ha : ∀ j, OrderedSteps (a j) (steps j))

abbrev skPinFamily : Fin (L+1) → PinFrame (FeatureIndex n) (Spin n) (Fin n) (DriverDimension n L) :=
  fun j => skPinFrame n L q (cuts j) (steps j) (a j) (ha j)

 theorem skPinFrame_potential_gauge (j : Fin (L+1)) (τ : Spin n)
    (x : Fin (DriverDimension n L) → ℝ) :
    (skPinFamily q cuts steps a ha j).potential (driverGauge n L τ x) =
      (skPinFamily q cuts steps a ha j).potential x := by
  change finiteSKHierarchy n (steps j) (prefixDriver n L q (cuts j) (driverGauge n L τ x)) = _
  rw [prefixDriver_gauge, finiteSKHierarchy_gauge]
  rfl

 theorem skPinFrame_observable_gauge (j : Fin (L+1)) (τ σ : Spin n)
    (x : Fin (DriverDimension n L) → ℝ) :
    (skPinFamily q cuts steps a ha j).observable (spinGauge τ σ) (driverGauge n L τ x) =
      (skPinFamily q cuts steps a ha j).observable σ x := by
  change driverObservable (uniformWeight n) (finiteFeature n) (steps j)
      (ContinuousLinearMap.id ℝ _) (spinSource n) (spinGauge τ σ)
      (prefixDriver n L q (cuts j) (driverGauge n L τ x)) =
    driverObservable (uniformWeight n) (finiteFeature n) (steps j)
      (ContinuousLinearMap.id ℝ _) (spinSource n) σ (prefixDriver n L q (cuts j) x)
  rw [prefixDriver_gauge]
  exact spinObservable_gauge n (steps j) τ σ (prefixDriver n L q (cuts j) x)

 theorem skPinFrame_energy_gauge (j : Fin (L+1)) (τ σ : Spin n)
    (x : Fin (DriverDimension n L) → ℝ) :
    (skPinFamily q cuts steps a ha j).energy (spinGauge τ σ) (driverGauge n L τ x) =
      (skPinFamily q cuts steps a ha j).energy σ x := by
  change driverEnergy (uniformWeight n) (finiteFeature n) (steps j)
      (ContinuousLinearMap.id ℝ _) (spinSource n) (spinGauge τ σ)
      (prefixDriver n L q (cuts j) (driverGauge n L τ x)) =
    driverEnergy (uniformWeight n) (finiteFeature n) (steps j)
      (ContinuousLinearMap.id ℝ _) (spinSource n) σ (prefixDriver n L q (cuts j) x)
  rw [prefixDriver_gauge]
  exact spinEnergy_gauge n (steps j) (ha j) τ σ (prefixDriver n L q (cuts j) x)

 theorem driverQuadratic_gauge (τ : Spin n) (x : Fin (DriverDimension n L) → ℝ) :
    driverQuadratic (driverGauge n L τ x) = driverQuadratic x := by
  unfold driverQuadratic
  congr 1
  apply Finset.sum_congr rfl
  intro i _
  change (driverSigns n L τ i*x i)^2 = (x i)^2
  rw [mul_pow]
  have hi := driverSigns_sq n L τ i
  nlinarith [sq_nonneg (x i)]

 theorem skPinned_joint_test_gauge (α k : Fin (L+1) → ℝ) (τ σ : Spin n) (f : ℝ × ℝ → ℝ) :
    let P := skPinFamily q cuts steps a ha
    let U := fun σ => pinnedPotential P α ((finiteFeature n σ).comp (prefixDriver n L q (Fin.last L)))
    (∫ x, f (pinnedObservable P α k (spinGauge τ σ) x, pinnedEnergy P α k (spinGauge τ σ) x)
      ∂potentialLaw (U (spinGauge τ σ))) =
    ∫ x, f (pinnedObservable P α k σ x, pinnedEnergy P α k σ x) ∂potentialLaw (U σ) := by
  dsimp only
  apply potentialLaw_joint_test_eq (driverGauge n L τ) (signEquiv_volume _ _)
  · intro x
    unfold pinnedPotential
    rw [driverQuadratic_gauge]
    simp only [ContinuousLinearMap.comp_apply, prefixDriver_gauge, finiteFeature_gauge]
    simp_rw [skPinFrame_potential_gauge]
  · intro x
    unfold pinnedObservable
    simp_rw [skPinFrame_observable_gauge]
  · intro x
    unfold pinnedEnergy
    simp_rw [skPinFrame_energy_gauge]

end SKFluctuations

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set
open scoped Topology ContDiff

 theorem deriv_smoothAbsPower {ε : ℝ} (hε : 0 < ε) (p x : ℝ) :
    deriv (smoothAbsPower ε p) x = p*x*(x^2+ε)^(p/2-1) := by
  have h : HasDerivAt (smoothAbsPower ε p)
      ((2*x)*(p/2)*(x^2+ε)^(p/2-1)) x := by
    change HasDerivAt (fun y : ℝ => (y^2+ε)^(p/2)) _ x
    simpa using (((hasDerivAt_id x).pow 2).add_const ε).rpow_const (p := p/2)
      (Or.inl (ne_of_gt (add_pos_of_nonneg_of_pos (sq_nonneg x) hε)))
  rw [h.deriv]
  ring

 theorem deriv_smoothAbsPower_sq_le {ε p : ℝ} (hε : 0 < ε) (x : ℝ) :
    (deriv (smoothAbsPower ε p) x)^2 ≤ p^2*(x^2+ε)^(p-1) := by
  rw [deriv_smoothAbsPower hε]
  have hz : 0 < x^2+ε := add_pos_of_nonneg_of_pos (sq_nonneg _) hε
  have he : ((x^2+ε)^(p/2-1))^2 = (x^2+ε)^(p-2) := by
    rw [← Real.rpow_natCast, ← Real.rpow_mul hz.le]
    congr 1
    ring
  have he' : (x^2+ε)^(p-1) = (x^2+ε)*(x^2+ε)^(p-2) := by
    rw [show p-1 = 1+(p-2) by ring, Real.rpow_add hz, Real.rpow_one]
  rw [mul_pow, mul_pow, he, he']
  rw [mul_assoc]
  apply mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_right (by linarith)
    (Real.rpow_nonneg hz.le _)) (sq_nonneg p)

 theorem smoothAbsPower_sq {ε : ℝ} (hε : 0 ≤ ε) (p x : ℝ) :
    (smoothAbsPower ε p x)^2 = (x^2+ε)^p := by
  unfold smoothAbsPower
  rw [← Real.rpow_natCast, ← Real.rpow_mul (by positivity)]
  congr 1
  ring

 theorem smoothAbsPower_zero (p : ℝ) (x : ℝ) : smoothAbsPower 0 p x = |x|^p := by
  unfold smoothAbsPower
  rw [add_zero, ← sq_abs, ← Real.rpow_natCast, ← Real.rpow_mul (abs_nonneg x)]
  congr 1
  ring

end SKFluctuations.Hierarchy

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set
open scoped Topology ContDiff

 def powerEps (k : ℕ) : ℝ := 1 / ((k : ℝ)+1)

 theorem powerEps_pos (k : ℕ) : 0 < powerEps k := by unfold powerEps; positivity
 theorem powerEps_le_one (k : ℕ) : powerEps k ≤ 1 := by
  unfold powerEps
  rw [div_le_one (by positivity)]
  linarith [Nat.cast_nonneg (α := ℝ) k]
 theorem powerEps_tendsto : Tendsto powerEps atTop (𝓝 0) :=
  tendsto_one_div_add_atTop_nhds_zero_nat

 theorem integral_regularized_power_tendsto {E : Type*} [NormedAddCommGroup E]
    [NormedSpace ℝ E] [MeasurableSpace E] [BorelSpace E]
    {μ : Measure E} [IsFiniteMeasure μ] {A J : E → ℝ}
    (hA : BddSmooth 0 A) (hJ : BddSmooth 0 J) {p : ℝ} (hp : 0 ≤ p) :
    Tendsto (fun k => ∫ x, (A x^2+powerEps k)^p * J x ∂μ) atTop
      (𝓝 (∫ x, |A x|^(2*p)*J x ∂μ)) := by
  obtain ⟨B,hB,hAb⟩ := hA.bound
  obtain ⟨C,hC,hJb⟩ := hJ.bound
  apply tendsto_integral_of_dominated_convergence (fun _ => (B^2+1)^p*C)
  · intro k
    exact ((Real.continuous_rpow_const hp).comp
      ((hA.continuous.pow 2).add continuous_const) |>.mul hJ.continuous).aestronglyMeasurable
  · exact integrable_const _
  · intro k
    filter_upwards [] with x
    have hz : 0 ≤ A x^2+powerEps k := add_nonneg (sq_nonneg _) (powerEps_pos k).le
    rw [norm_mul, Real.norm_eq_abs, abs_of_nonneg (Real.rpow_nonneg hz _)]
    apply mul_le_mul _ (hJb x) (abs_nonneg _) (Real.rpow_nonneg (by positivity) _)
    apply Real.rpow_le_rpow hz _ hp
    have hab : A x^2 ≤ B^2 := by
      simpa only [sq_abs] using (sq_le_sq₀ (abs_nonneg _) hB).mpr (hAb x)
    
    linarith [powerEps_le_one k]
  · filter_upwards [] with x
    have ht : Tendsto (fun k => A x^2+powerEps k) atTop (𝓝 (A x^2)) := by
      simpa using tendsto_const_nhds.add powerEps_tendsto (a := A x^2)
    have he : (A x^2)^p = |A x|^(2*p) := by
      rw [← sq_abs, ← Real.rpow_natCast, ← Real.rpow_mul (abs_nonneg _)]
      norm_num
    simpa only [he, Function.comp_def] using ((Real.continuous_rpow_const hp).tendsto _ |>.comp ht).mul_const (J x)

end SKFluctuations.Hierarchy

namespace SKFluctuations.Hierarchy
open MeasureTheory ProbabilityTheory Filter Set
open scoped NNReal Topology ContDiff
open SKFluctuations.PinnedVariance SKFluctuations.PreKopa

 theorem BddSmooth.memLp {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [MeasurableSpace E] [BorelSpace E] {μ : Measure E} [IsFiniteMeasure μ]
    {r : ℕ} {A : E → ℝ} (hA : BddSmooth r A) (p : ENNReal) : MemLp A p μ := by
  obtain ⟨B,_,hB⟩ := hA.bound
  exact MemLp.of_bound hA.continuous.aestronglyMeasurable B (ae_of_all _ hB)

 theorem BddSmooth.integrable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [MeasurableSpace E] [BorelSpace E] {μ : Measure E} [IsFiniteMeasure μ]
    {r : ℕ} {A : E → ℝ} (hA : BddSmooth r A) : Integrable A μ :=
  memLp_one_iff_integrable.mp (hA.memLp 1)

 theorem regularized_power_moment_le {n : ℕ} {U A J : (Fin n → ℝ) → ℝ}
    {μ : Measure (Fin n → ℝ)} [IsProbabilityMeasure μ]
    (hμ : μ = volume.withDensity (fun x => ENNReal.ofReal (Real.exp (-U x))))
    (hU : GaussianDominated (fun x => Real.exp (-U x))) (hUc : Continuous U)
    (DU : LineDerivatives U) (hA : BddSmooth 2 A) (hJ : BddSmooth 2 J)
    (hJ0 : ∀ x, 0 ≤ J x)
    (hstrong : ∀ x v, ‖v‖^2 ≤ DU.second x v)
    (hblock : ∀ x v s, 0 ≤ DU.second x v - 2*s*lineDeriv ℝ A x v + s^2*J x)
    {ε : ℝ} (hε : 0 < ε) (p : ℝ) :
    (∫ x, (A x^2+ε)^(p/2) ∂μ) ≤
      (∫ x, (A x^2+ε)^(p/4) ∂μ)^2 +
        (p^2/4)*(∫ x, (A x^2+ε)^((p-2)/2)*J x ∂μ) := by
  let f := smoothAbsPower ε (p/2)
  have hf : ContDiff ℝ ∞ f := contDiff_smoothAbsPower hε _
  have hAf := hA.comp_contDiff hf
  have hdf := hA.comp_contDiff (contDiff_infty_iff_deriv.mp hf).2
  have hG : BddSmooth 2 (fun x => (A x^2+ε)^((p-2)/2)*J x) :=
    (hA.smoothAbsPower hε (p-2)).mul hJ
  have hv := variance_comp_le_BddSmooth_block hμ hU hUc DU hA hJ hstrong hblock hf
  rw [variance_eq_sub (hAf.memLp 2)] at hv
  have he : (∫ x, (deriv f (A x))^2*J x ∂μ) ≤
      (p^2/4)*(∫ x, (A x^2+ε)^((p-2)/2)*J x ∂μ) := by
    rw [← integral_const_mul]
    apply integral_mono
    · simpa only [pow_two] using ((hdf.mul hdf).mul hJ).integrable (μ := μ)
    · exact (hG.const_mul (p^2/4)).integrable
    · intro x
      have he := mul_le_mul_of_nonneg_right (deriv_smoothAbsPower_sq_le hε (p := p/2) (A x)) (hJ0 x)
      have hexp : p/2-1 = (p-2)/2 := by ring
      have hcoef : (p/2)^2 = p^2/4 := by ring
      simpa only [f, hexp, hcoef, mul_assoc] using he
  have hsq : (∫ x, ((fun x => f (A x))^2) x ∂μ) = ∫ x, (A x^2+ε)^(p/2) ∂μ := by
    apply integral_congr_ae
    filter_upwards [] with x
    exact smoothAbsPower_sq hε.le _ _
  have hmean : (∫ x, f (A x) ∂μ) = ∫ x, (A x^2+ε)^(p/4) ∂μ := by
    congr 1
    funext x
    dsimp [f, smoothAbsPower]
    congr 1
    ring
  rw [hsq, hmean] at hv
  linarith

 theorem power_moment_le {n : ℕ} {U A J : (Fin n → ℝ) → ℝ}
    {μ : Measure (Fin n → ℝ)} [IsProbabilityMeasure μ]
    (hμ : μ = volume.withDensity (fun x => ENNReal.ofReal (Real.exp (-U x))))
    (hU : GaussianDominated (fun x => Real.exp (-U x))) (hUc : Continuous U)
    (DU : LineDerivatives U) (hA : BddSmooth 2 A) (hJ : BddSmooth 2 J)
    (hJ0 : ∀ x, 0 ≤ J x)
    (hstrong : ∀ x v, ‖v‖^2 ≤ DU.second x v)
    (hblock : ∀ x v s, 0 ≤ DU.second x v - 2*s*lineDeriv ℝ A x v + s^2*J x)
    {p : ℝ} (hp : 2 < p) :
    (∫ x, |A x|^p ∂μ) ≤ (∫ x, |A x|^(p/2) ∂μ)^2 +
        (p^2/4)*(∫ x, |A x|^(p-2)*J x ∂μ) := by
  have h₁ := integral_regularized_power_tendsto (μ := μ) hA.down.down
    (BddSmooth.const 0 (1 : ℝ)) (p := p/2) (by linarith)
  have h₂ := integral_regularized_power_tendsto (μ := μ) hA.down.down
    (BddSmooth.const 0 (1 : ℝ)) (p := p/4) (by linarith)
  have h₃ := integral_regularized_power_tendsto (μ := μ) hA.down.down hJ.down.down
    (p := (p-2)/2) (by linarith)
  have he₁ : 2*(p/2) = p := by ring
  have he₂ : 2*(p/4) = p/2 := by ring
  have he₃ : 2*((p-2)/2) = p-2 := by ring
  simp only [mul_one, he₁, he₂, he₃] at h₁ h₂ h₃
  exact le_of_tendsto_of_tendsto h₁ ((h₂.pow 2).add (h₃.const_mul (p^2/4)))
    (Filter.Eventually.of_forall fun k => regularized_power_moment_le hμ hU hUc DU hA hJ hJ0 hstrong hblock
      (powerEps_pos k) p)

end SKFluctuations.Hierarchy

end

end OAI