Datasets:

roseking
/

openAI-math-dataset

import Mathlib
import OAI.Probability.ParisiFinite.SpinTrace

namespace OAI

/-! Bounded Of. -/

noncomputable section

open scoped BigOperators ComplexConjugate InnerProductSpace Topology ComplexOrder
open Filter
open scoped BigOperators
open scoped Matrix Matrix.Norms.L2Operator ComplexConjugate
open scoped InnerProductSpace ComplexConjugate
open Filter Topology
open Filter Set Topology
open scoped InnerProductSpace ComplexConjugate Topology
open scoped InnerProductSpace
open scoped BigOperators Topology InnerProductSpace
open scoped BigOperators InnerProductSpace
open scoped BigOperators Matrix Topology ComplexConjugate
open MeasureTheory ProbabilityTheory Filter
open scoped BigOperators Topology
open scoped BigOperators Matrix Topology
open scoped BigOperators Matrix Topology Matrix.Norms.Operator
open scoped Topology
open Filter Asymptotics
open scoped InnerProductSpace Topology
open scoped InnerProductSpace BigOperators
open scoped InnerProductSpace Topology BigOperators
open scoped Topology BigOperators
open scoped Matrix Matrix.Norms.L2Operator InnerProductSpace
open scoped Matrix Matrix.Norms.L2Operator InnerProductSpace BigOperators
open Filter ContinuousLinearMap
open ContinuousLinearMap
open scoped InnerProductSpace BigOperators Topology
open ContinuousLinearMap InnerProductSpace
open ContinuousLinearMap Filter
open Filter MeasureTheory
open scoped Topology ENNReal
open MeasureTheory ProbabilityTheory
open scoped BigOperators Topology RealInnerProductSpace
open scoped BigOperators TensorProduct
open scoped Topology InnerProductSpace
open MeasureTheory Filter
open MeasureTheory ProbabilityTheory Complex
open scoped BigOperators Topology InnerProductSpace ComplexConjugate
open scoped BigOperators Topology NNReal
open scoped BigOperators NNReal Topology
open scoped BigOperators NNReal
open scoped NNReal Topology
open scoped NNReal Topology BigOperators
open MeasureTheory ProbabilityTheory Filter
open scoped NNReal Topology BigOperators
namespace ParisiFinite
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]

 
def boundedOf (g : E → ℝ) (hg : Continuous g) {M : ℝ} (hM : ∀ x, |g x| ≤ M) :
    BoundedContinuousFunction E ℝ where
  toContinuousMap := ⟨g, hg⟩
  map_bounded' := ⟨2*M, fun x y => by
    change |g x-g y| ≤ _
    have h := abs_sub_le (g x) 0 (g y)
    simp only [sub_zero, zero_sub, abs_neg] at h
    linarith [hM x, hM y]⟩
omit [NormedSpace ℝ E] in
lemma bounded_abs (g : BoundedContinuousFunction E ℝ) (x : E) : |g x| ≤ ‖g‖ := by
  simpa only [Real.norm_eq_abs] using g.norm_coe_le_norm x
 
def tiltMap (f : DirectionalField E) (a : ℝ) (c : E) :
    BoundedContinuousFunction E ℝ →ₗ[ℝ] BoundedContinuousFunction E ℝ where
  toFun g := boundedOf (ambientTilt a c f.val g)
    (continuous_ambientTilt f.lipschitz g.continuous (bounded_abs g) a c)
    (abs_ambientTilt_le f.lipschitz g.continuous (bounded_abs g) a c)
  map_add' g h := by
    ext x
    exact ambientTilt_add f.lipschitz g.continuous h.continuous (bounded_abs g) (bounded_abs h) a c x
  map_smul' k g := by
    ext x
    exact ambientTilt_const_mul a c f.val g x k
@[simp] lemma tiltMap_apply (f : DirectionalField E) (a : ℝ) (c : E)
    (g : BoundedContinuousFunction E ℝ) (x : E) :
    tiltMap f a c g x = ambientTilt a c f.val g x := rfl
lemma tiltMap_mono (f : DirectionalField E) (a : ℝ) (c : E)
    {g h : BoundedContinuousFunction E ℝ} (hgh : ∀ x, g x ≤ h x) :
    ∀ x, tiltMap f a c g x ≤ tiltMap f a c h x :=
  ambientTilt_mono f.lipschitz g.continuous h.continuous (bounded_abs g) (bounded_abs h) hgh a c
@[simp] lemma tiltMap_const (f : DirectionalField E) (a : ℝ) (c : E) (k : ℝ) :
    tiltMap f a c (BoundedContinuousFunction.const E k) = BoundedContinuousFunction.const E k := by
  ext x
  exact ambientTilt_const f.lipschitz a c x k
lemma tiltMap_nonneg (f : DirectionalField E) (a : ℝ) (c : E)
    {g : BoundedContinuousFunction E ℝ} (hg : ∀ x, 0 ≤ g x) :
    ∀ x, 0 ≤ tiltMap f a c g x := by
  have h := tiltMap_mono f a c (g:=0) (h:=g) hg
  simpa only [map_zero, BoundedContinuousFunction.coe_zero, Pi.zero_apply] using h
lemma norm_tiltMap_le (f : DirectionalField E) (a : ℝ) (c : E)
    (g : BoundedContinuousFunction E ℝ) : ‖tiltMap f a c g‖ ≤ ‖g‖ := by
  apply (BoundedContinuousFunction.norm_le (norm_nonneg g)).2
  intro x
  exact abs_ambientTilt_le f.lipschitz g.continuous (bounded_abs g) a c x
namespace DirectionalField
def firstBCF (f : DirectionalField E) (v : E) : BoundedContinuousFunction E ℝ :=
  boundedOf (f.first v) (f.continuousFirst v) (f.normFirst v)
def secondBCF (f : DirectionalField E) (v w : E) : BoundedContinuousFunction E ℝ :=
  boundedOf (f.second v w) (f.continuousSecond v w) (f.normSecond v w)
@[simp] lemma firstBCF_apply (f : DirectionalField E) (v x : E) : f.firstBCF v x = f.first v x := rfl
@[simp] lemma secondBCF_apply (f : DirectionalField E) (v w x : E) : f.secondBCF v w x = f.second v w x := rfl
lemma firstBCF_transform (f : DirectionalField E) (a : ℝ≥0) (c v : E) :
    (f.transform a c).firstBCF v = tiltMap f a c (f.firstBCF v) := rfl
lemma secondBCF_transform (f : DirectionalField E) (a : ℝ≥0) (c v w : E) :
    (f.transform a c).secondBCF v w = tiltMap f a c (f.secondBCF v w) +
      (a:ℝ) • (tiltMap f a c (f.firstBCF v*f.firstBCF w) -
        tiltMap f a c (f.firstBCF v)*tiltMap f a c (f.firstBCF w)) := rfl
end DirectionalField
namespace FieldFamily
def dotBCF (F : FieldFamily E) (t : ℝ) : BoundedContinuousFunction E ℝ :=
  boundedOf (F.dot t) (F.continuousDot.comp (continuous_const.prodMk continuous_id)) (F.normDot t)
@[simp] lemma dotBCF_apply (F : FieldFamily E) (t : ℝ) (x : E) : F.dotBCF t x = F.dot t x := rfl
lemma dotBCF_constant (f : DirectionalField E) (t : ℝ) : (constant f).dotBCF t = 0 := rfl
lemma dotBCF_transform (F : FieldFamily E) (a : ℝ≥0) (c : E) (s ds : ℝ → ℝ)
    (hs : Continuous s) (hds : Continuous ds) (hd : ∀ t, HasDerivAt s (ds t) t) (t : ℝ) :
    (F.transform a c s ds hs hds hd).dotBCF t =
      tiltMap (F.field t) a (s t • c) (F.dotBCF t) + (s t*ds t) •
      (tiltMap (F.field t) a (s t • c) ((F.field t).secondBCF c c) + (a:ℝ) •
        tiltMap (F.field t) a (s t • c) ((F.field t).firstBCF c ^ 2)) := by
  ext x
  rfl
end FieldFamily
end ParisiFinite
 
open MeasureTheory ProbabilityTheory Filter
open scoped NNReal Topology BigOperators
namespace ParisiFinite
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
 
def transport (f : DirectionalField E) : List (MovingCoordinate E) → ℝ →
    (BoundedContinuousFunction E ℝ →ₗ[ℝ] BoundedContinuousFunction E ℝ)
  | [], _ => LinearMap.id
  | c::cs, t => (tiltMap ((hierarchy f cs).field t) c.gamma (c.scale t • c.direction)).comp
      (transport f cs t)
lemma transport_nonneg (f : DirectionalField E) (cs : List (MovingCoordinate E)) (t : ℝ)
    {g : BoundedContinuousFunction E ℝ} (hg : ∀ x, 0 ≤ g x) :
    ∀ x, 0 ≤ transport f cs t g x := by
  induction cs with
  | nil => exact hg
  | cons c cs ih => exact tiltMap_nonneg _ _ _ ih
lemma transport_const (f : DirectionalField E) (cs : List (MovingCoordinate E)) (t k : ℝ) :
    transport f cs t (BoundedContinuousFunction.const E k) = BoundedContinuousFunction.const E k := by
  induction cs with
  | nil => rfl
  | cons c cs ih => simp only [transport, LinearMap.comp_apply, ih, tiltMap_const]
lemma hierarchy_firstBCF (f : DirectionalField E) (cs : List (MovingCoordinate E)) (t : ℝ) (v : E) :
    ((hierarchy f cs).field t).firstBCF v = transport f cs t (f.firstBCF v) := by
  induction cs with
  | nil => rfl
  | cons c cs ih =>
    change (((hierarchy f cs).field t).transform c.gamma (c.scale t • c.direction)).firstBCF v = _
    rw [DirectionalField.firstBCF_transform, ih]
    rfl
section FiniteSpin
variable {ι : Type*} [Fintype ι] [Nonempty ι]
open SKGaussian
 
def gibbsMap (β : ℝ) : (ι → ℝ) →ₗ[ℝ] BoundedContinuousFunction (ι → ℝ) ℝ where
  toFun v := boundedOf (fun x => gibbsMean β x v) (continuous_gibbsMean β v)
    (fun x => abs_gibbsMean_le β x v)
  map_add' v w := by
    ext x
    simp [boundedOf, gibbsMean, mul_add, Finset.sum_add_distrib]
  map_smul' k v := by
    ext x
    simp [boundedOf, gibbsMean, mul_left_comm _ k, Finset.mul_sum]
@[simp] lemma gibbsMap_apply (β : ℝ) (v x : ι → ℝ) : gibbsMap β v x = gibbsMean β x v := rfl
lemma gibbsMap_nonneg (β : ℝ) {v : ι → ℝ} (hv : ∀ i, 0 ≤ v i) :
    ∀ x, 0 ≤ gibbsMap β v x := by
  intro x
  exact Finset.sum_nonneg (fun i _ => mul_nonneg (weight_pos _ _).le (hv i))
lemma gibbsMap_const (β k : ℝ) : gibbsMap (ι:=ι) β (fun _ => k) =
    BoundedContinuousFunction.const (ι → ℝ) k := by
  ext x
  change (∑ i, weight (fun j => β*x j) i*k) = k
  rw [← Finset.sum_mul, sum_weight, one_mul]
 
def spinObserve (β : ℝ≥0) (hβ : 0 < β) (cs : List (MovingCoordinate (ι → ℝ))) (t : ℝ) :
    (ι → ℝ) →ₗ[ℝ] BoundedContinuousFunction (ι → ℝ) ℝ :=
  (transport (traceField β hβ) cs t).comp (gibbsMap β)
lemma spinObserve_nonneg (β : ℝ≥0) (hβ : 0 < β) (cs : List (MovingCoordinate (ι → ℝ))) (t : ℝ)
    {v : ι → ℝ} (hv : ∀ i, 0 ≤ v i) : ∀ x, 0 ≤ spinObserve β hβ cs t v x :=
  transport_nonneg _ _ _ (gibbsMap_nonneg β hv)
lemma spinObserve_const (β : ℝ≥0) (hβ : 0 < β) (cs : List (MovingCoordinate (ι → ℝ))) (t k : ℝ) :
    spinObserve β hβ cs t (fun _ => k) = BoundedContinuousFunction.const (ι → ℝ) k := by
  simp only [spinObserve, LinearMap.comp_apply, gibbsMap_const, transport_const]
lemma spin_first_observe (β : ℝ≥0) (hβ : 0 < β) (cs : List (MovingCoordinate (ι → ℝ))) (t : ℝ)
    (v : ι → ℝ) : ((hierarchy (traceField β hβ) cs).field t).firstBCF v = spinObserve β hβ cs t v :=
  hierarchy_firstBCF _ _ _ _
 
def spinWeight [DecidableEq ι] (β : ℝ≥0) (hβ : 0 < β)
    (cs : List (MovingCoordinate (ι → ℝ))) (t : ℝ) (i : ι) :
    BoundedContinuousFunction (ι → ℝ) ℝ := spinObserve β hβ cs t (Pi.single i 1)
lemma spinWeight_nonneg [DecidableEq ι] (β : ℝ≥0) (hβ : 0 < β)
    (cs : List (MovingCoordinate (ι → ℝ))) (t : ℝ) (i : ι) (x : ι → ℝ) :
    0 ≤ spinWeight β hβ cs t i x := by
  apply spinObserve_nonneg
  intro j
  by_cases hij : j=i <;> simp [hij]
lemma spinObserve_eq_sum [DecidableEq ι] (β : ℝ≥0) (hβ : 0 < β)
    (cs : List (MovingCoordinate (ι → ℝ))) (t : ℝ) (v : ι → ℝ) :
    spinObserve β hβ cs t v = ∑ i, v i • spinWeight β hβ cs t i := by
  have he : v = ∑ i, v i • Pi.single i (1:ℝ) := by
    ext j
    simp [Pi.single_apply, apply_ite]
  conv_lhs => rw [he]
  simp only [map_sum, map_smul, spinWeight]
lemma sum_spinWeight [DecidableEq ι] (β : ℝ≥0) (hβ : 0 < β)
    (cs : List (MovingCoordinate (ι → ℝ))) (t : ℝ) :
    ∑ i, spinWeight β hβ cs t i = BoundedContinuousFunction.const (ι → ℝ) 1 := by
  have he := spinObserve_eq_sum β hβ cs t (fun _ => 1)
  rw [spinObserve_const] at he
  simpa only [one_smul] using he.symm
end FiniteSpin
end ParisiFinite
 
open MeasureTheory ProbabilityTheory Filter
open scoped NNReal Topology BigOperators
namespace ParisiFinite
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
 
abbrev Noise (E : Type*) := List (ℝ × E)
def noiseGradient (f : DirectionalField E) : Noise E → BoundedContinuousFunction E ℝ
  | [] => 0
  | (k,v)::vs => k • (f.firstBCF v)^2 + noiseGradient f vs
def noiseHessian (f : DirectionalField E) : Noise E → BoundedContinuousFunction E ℝ
  | [] => 0
  | (k,v)::vs => k • f.secondBCF v v + noiseHessian f vs
def noiseResponse (f : DirectionalField E) (a : ℝ) (vs : Noise E) : BoundedContinuousFunction E ℝ :=
  noiseHessian f vs + a • noiseGradient f vs
lemma noiseResponse_nil (f : DirectionalField E) (a : ℝ) : noiseResponse f a [] = 0 := by
  simp [noiseResponse, noiseHessian, noiseGradient]
lemma noiseResponse_cons (f : DirectionalField E) (a k : ℝ) (v : E) (vs : Noise E) :
    noiseResponse f a ((k,v)::vs) = k • (f.secondBCF v v+a •(f.firstBCF v)^2)+noiseResponse f a vs := by
  simp only [noiseResponse, noiseHessian, noiseGradient]
  module
lemma noiseHessian_transform (f : DirectionalField E) (a : ℝ≥0) (c : E) (vs : Noise E) :
    noiseHessian (f.transform a c) vs = tiltMap f a c (noiseHessian f vs) + (a:ℝ) •
      (tiltMap f a c (noiseGradient f vs)-noiseGradient (f.transform a c) vs) := by
  induction vs with
  | nil => simp [noiseHessian, noiseGradient]
  | cons kv vs ih =>
    rcases kv with ⟨k,v⟩
    simp only [noiseHessian, noiseGradient, DirectionalField.secondBCF_transform, ih,
      map_add, map_smul, DirectionalField.firstBCF_transform, pow_two]
    module
 
lemma noiseResponse_transform (f : DirectionalField E) (b : ℝ≥0) (a : ℝ) (c : E) (vs : Noise E) :
    noiseResponse (f.transform b c) a vs =
      tiltMap f b c (noiseResponse f b vs) - ((b:ℝ)-a) • noiseGradient (f.transform b c) vs := by
  simp only [noiseResponse, noiseHessian_transform, map_add, map_smul]
  module
def coordinateNoise (c : MovingCoordinate E) (t : ℝ) : ℝ × E := (c.scale t*c.velocity t,c.direction)
def allNoise : List (MovingCoordinate E) → ℝ → Noise E → Noise E
  | [], _, vs => vs
  | c::cs, t, vs => allNoise cs t (coordinateNoise c t::vs)
lemma hierarchy_local_sum (f : DirectionalField E) (c : MovingCoordinate E)
    (cs : List (MovingCoordinate E)) (t a : ℝ) (vs : Noise E) :
    (hierarchy f (c::cs)).dotBCF t + noiseResponse ((hierarchy f (c::cs)).field t) a vs =
      tiltMap ((hierarchy f cs).field t) c.gamma (c.scale t • c.direction)
        ((hierarchy f cs).dotBCF t +
          noiseResponse ((hierarchy f cs).field t) c.gamma (coordinateNoise c t::vs)) -
        ((c.gamma:ℝ)-a) • noiseGradient ((hierarchy f (c::cs)).field t) vs := by
  change ((hierarchy f cs).transform c.gamma c.direction c.scale c.velocity
    c.continuousScale c.continuousVelocity c.hasScale).dotBCF t +
      noiseResponse (((hierarchy f cs).field t).transform c.gamma (c.scale t • c.direction)) a vs =
      tiltMap ((hierarchy f cs).field t) c.gamma (c.scale t • c.direction)
        ((hierarchy f cs).dotBCF t +
          noiseResponse ((hierarchy f cs).field t) c.gamma (coordinateNoise c t::vs)) -
        ((c.gamma:ℝ)-a) • noiseGradient
          (((hierarchy f cs).field t).transform c.gamma (c.scale t • c.direction)) vs
  rw [FieldFamily.dotBCF_transform, noiseResponse_transform]
  simp only [coordinateNoise, noiseResponse_cons, map_add, map_smul]
  module
 
def hierarchyRemainder (f : DirectionalField E) (β : ℝ) : List (MovingCoordinate E) → ℝ → ℝ →
    Noise E → BoundedContinuousFunction E ℝ
  | [], _, a, vs => (β-a) • noiseGradient f vs
  | c::cs, t, a, vs => ((c.gamma:ℝ)-a) • noiseGradient ((hierarchy f (c::cs)).field t) vs +
      tiltMap ((hierarchy f cs).field t) c.gamma (c.scale t • c.direction)
        (hierarchyRemainder f β cs t c.gamma (coordinateNoise c t::vs))
section FiniteSpin
variable {ι : Type*} [Fintype ι] [Nonempty ι]
def diagonalNoise : Noise (ι → ℝ) → (ι → ℝ)
  | [] => 0
  | (k,v)::vs => k • v^2+diagonalNoise vs
lemma trace_firstBCF (β : ℝ≥0) (hβ : 0 < β) (v : ι → ℝ) :
    (traceField β hβ).firstBCF v = gibbsMap β v := rfl
lemma trace_secondBCF (β : ℝ≥0) (hβ : 0 < β) (v : ι → ℝ) :
    (traceField β hβ).secondBCF v v = (β:ℝ) • (gibbsMap β (v^2)-(gibbsMap β v)^2) := by
  ext x
  change (β:ℝ)*(gibbsMean β x (fun i => v i*v i)-gibbsMean β x v*gibbsMean β x v) =
    (β:ℝ)*(gibbsMean β x (v^2)-(gibbsMean β x v)^2)
  have he : (fun i => v i*v i) = v^2 := by ext i; simp [pow_two]
  rw [he]
  simp only [pow_two]
lemma trace_noiseResponse (β : ℝ≥0) (hβ : 0 < β) (a : ℝ) (vs : Noise (ι → ℝ)) :
    noiseResponse (traceField β hβ) a vs = (β:ℝ) • gibbsMap β (diagonalNoise vs) -
      ((β:ℝ)-a) • noiseGradient (traceField β hβ) vs := by
  induction vs with
  | nil => simp [noiseResponse_nil, diagonalNoise, noiseGradient]
  | cons kv vs ih =>
    rcases kv with ⟨k,v⟩
    rw [noiseResponse_cons, ih]
    simp only [diagonalNoise, noiseGradient, map_add, map_smul]
    rw [trace_secondBCF, trace_firstBCF]
    module
 
lemma hierarchy_sum_rule (β : ℝ≥0) (hβ : 0 < β) (cs : List (MovingCoordinate (ι → ℝ)))
    (t a : ℝ) (vs : Noise (ι → ℝ)) :
    (hierarchy (traceField β hβ) cs).dotBCF t +
      noiseResponse ((hierarchy (traceField β hβ) cs).field t) a vs =
      (β:ℝ) • spinObserve β hβ cs t (diagonalNoise (allNoise cs t vs)) -
        hierarchyRemainder (traceField β hβ) β cs t a vs := by
  induction cs generalizing a vs with
  | nil =>
    change 0 + noiseResponse (traceField β hβ) a vs = _
    simpa only [zero_add, spinObserve, transport, LinearMap.comp_apply, LinearMap.id_apply,
      hierarchyRemainder, allNoise] using trace_noiseResponse β hβ a vs
  | cons c cs ih =>
    rw [hierarchy_local_sum, ih]
    simp only [map_sub, map_smul, hierarchyRemainder, allNoise, spinObserve,
      transport, LinearMap.comp_apply]
    module
lemma hierarchy_derivative_sum_rule (β : ℝ≥0) (hβ : 0 < β)
    (cs : List (MovingCoordinate (ι → ℝ))) (t : ℝ) (x : ι → ℝ) :
    HasDerivAt (fun s => hierarchyValue (spinTrace β) cs s x)
      ((β:ℝ)*spinObserve β hβ cs t (diagonalNoise (allNoise cs t [])) x -
        hierarchyRemainder (traceField β hβ) β cs t 0 [] x) t := by
  have h := hierarchy_sum_rule β hβ cs t 0 []
  simp only [noiseResponse_nil, add_zero] at h
  have hd := hasDerivAt_hierarchyValue (traceField β hβ) cs t x
  change HasDerivAt _ ((hierarchy (traceField β hβ) cs).dotBCF t x) t at hd
  rw [h] at hd
  exact hd
end FiniteSpin
end ParisiFinite
 
open MeasureTheory ProbabilityTheory Filter
open scoped NNReal Topology BigOperators
namespace ParisiFinite
variable {ι : Type*} [Fintype ι] [Nonempty ι] [DecidableEq ι]
 
def replicaObserve (β : ℝ≥0) (hβ : 0 < β) (cs : List (MovingCoordinate (ι → ℝ))) (t : ℝ) :
    (ι → ι → ℝ) →ₗ[ℝ] BoundedContinuousFunction (ι → ℝ) ℝ where
  toFun K := ∑ i, ∑ j, K i j • (spinWeight β hβ cs t i * spinWeight β hβ cs t j)
  map_add' K L := by simp [add_smul, Finset.sum_add_distrib]
  map_smul' a K := by simp [mul_smul, Finset.smul_sum]
lemma replicaObserve_apply (β : ℝ≥0) (hβ : 0 < β) (cs : List (MovingCoordinate (ι → ℝ))) (t : ℝ)
    (K : ι → ι → ℝ) (x : ι → ℝ) :
    replicaObserve β hβ cs t K x = ∑ i, ∑ j, K i j * (spinWeight β hβ cs t i x * spinWeight β hβ cs t j x) := by
  simp [replicaObserve, BoundedContinuousFunction.sum_apply]
lemma sum_spinWeight_apply (β : ℝ≥0) (hβ : 0 < β) (cs : List (MovingCoordinate (ι → ℝ))) (t : ℝ)
    (x : ι → ℝ) : ∑ i, spinWeight β hβ cs t i x = 1 := by
  simpa using congrArg (fun w : BoundedContinuousFunction (ι → ℝ) ℝ => w x) (sum_spinWeight β hβ cs t)
lemma replicaObserve_nonneg (β : ℝ≥0) (hβ : 0 < β) (cs : List (MovingCoordinate (ι → ℝ))) (t : ℝ)
    {K : ι → ι → ℝ} (hK : ∀ i j, 0 ≤ K i j) (x : ι → ℝ) :
    0 ≤ replicaObserve β hβ cs t K x := by
  rw [replicaObserve_apply]
  exact Finset.sum_nonneg (fun i _ => Finset.sum_nonneg (fun j _ =>
    mul_nonneg (hK i j) (mul_nonneg (spinWeight_nonneg β hβ cs t i x) (spinWeight_nonneg β hβ cs t j x))))
@[simp] lemma replicaObserve_const (β : ℝ≥0) (hβ : 0 < β) (cs : List (MovingCoordinate (ι → ℝ)))
    (t k : ℝ) : replicaObserve β hβ cs t (fun _ _ => k) = BoundedContinuousFunction.const (ι → ℝ) k := by
  ext x
  simp only [replicaObserve_apply, ← Finset.mul_sum, sum_spinWeight_apply, mul_one]
  rfl
lemma replicaObserve_rankOne (β : ℝ≥0) (hβ : 0 < β) (cs : List (MovingCoordinate (ι → ℝ)))
    (t : ℝ) (v w : ι → ℝ) :
    replicaObserve β hβ cs t (fun i j => v i*w j) = spinObserve β hβ cs t v * spinObserve β hβ cs t w := by
  rw [spinObserve_eq_sum, spinObserve_eq_sum]
  ext x
  simp only [replicaObserve_apply, BoundedContinuousFunction.mul_apply,
    BoundedContinuousFunction.sum_apply, BoundedContinuousFunction.smul_apply, smul_eq_mul,
    Finset.sum_mul, Finset.mul_sum]
  conv_rhs => rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro i _
  apply Finset.sum_congr rfl
  intro j _
  ring
 
def kernelNoise : Noise (ι → ℝ) → (ι → ι → ℝ)
  | [] => 0
  | (k,v)::vs => (fun i j => k*(v i*v j)) + kernelNoise vs
omit [Fintype ι] [Nonempty ι] [DecidableEq ι] in
lemma kernelNoise_diagonal (vs : Noise (ι → ℝ)) (i : ι) : kernelNoise vs i i = diagonalNoise vs i := by
  induction vs with
  | nil => rfl
  | cons kv vs ih =>
    rcases kv with ⟨k,v⟩
    simp only [kernelNoise, diagonalNoise, Pi.add_apply, Pi.smul_apply, smul_eq_mul, ih, pow_two, Pi.mul_apply]
lemma noiseGradient_replica (β : ℝ≥0) (hβ : 0 < β) (cs : List (MovingCoordinate (ι → ℝ)))
    (t : ℝ) (vs : Noise (ι → ℝ)) :
    noiseGradient ((hierarchy (traceField β hβ) cs).field t) vs =
      replicaObserve β hβ cs t (kernelNoise vs) := by
  induction vs with
  | nil => simp [noiseGradient, kernelNoise]
  | cons kv vs ih =>
    rcases kv with ⟨k,v⟩
    change k • (((hierarchy (traceField β hβ) cs).field t).firstBCF v)^2 +
      noiseGradient ((hierarchy (traceField β hβ) cs).field t) vs =
      replicaObserve β hβ cs t (k •(fun i j => v i*v j)+kernelNoise vs)
    rw [map_add, map_smul, replicaObserve_rankOne, spin_first_observe, ih, pow_two]
lemma replicaObserve_ge_const (β : ℝ≥0) (hβ : 0 < β) (cs : List (MovingCoordinate (ι → ℝ)))
    (t : ℝ) {K : ι → ι → ℝ} {k : ℝ} (hK : ∀ i j, k ≤ K i j) (x : ι → ℝ) :
    k ≤ replicaObserve β hβ cs t K x := by
  have h := replicaObserve_nonneg β hβ cs t (K:=K-(fun _ _ => k)) (fun i j => sub_nonneg.mpr (hK i j)) x
  simpa only [map_sub, replicaObserve_const, BoundedContinuousFunction.sub_apply,
    BoundedContinuousFunction.const_apply, sub_nonneg] using h
end ParisiFinite
 
open MeasureTheory ProbabilityTheory Filter
open scoped NNReal Topology BigOperators
namespace ParisiFinite
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
 
def prefixTransport (f : DirectionalField E) (tail : List (MovingCoordinate E)) :
    List (MovingCoordinate E) → ℝ →
      (BoundedContinuousFunction E ℝ →ₗ[ℝ] BoundedContinuousFunction E ℝ)
  | [], _ => LinearMap.id
  | c::cs, t => (tiltMap ((hierarchy f (cs++tail)).field t) c.gamma (c.scale t • c.direction)).comp
      (prefixTransport f tail cs t)
lemma prefixTransport_const (f : DirectionalField E) (tail pre : List (MovingCoordinate E)) (t k : ℝ) :
    prefixTransport f tail pre t (BoundedContinuousFunction.const E k) = BoundedContinuousFunction.const E k := by
  induction pre with
  | nil => rfl
  | cons c cs ih => simp only [prefixTransport, LinearMap.comp_apply, ih, tiltMap_const]
lemma prefixTransport_nonneg (f : DirectionalField E) (tail pre : List (MovingCoordinate E)) (t : ℝ)
    {g : BoundedContinuousFunction E ℝ} (hg : ∀ x, 0 ≤ g x) :
    ∀ x, 0 ≤ prefixTransport f tail pre t g x := by
  induction pre with
  | nil => exact hg
  | cons c cs ih => exact tiltMap_nonneg _ _ _ ih
lemma transport_append (f : DirectionalField E) (pre tail : List (MovingCoordinate E)) (t : ℝ) :
    transport f (pre++tail) t = (prefixTransport f tail pre t).comp (transport f tail t) := by
  induction pre with
  | nil => rfl
  | cons c cs ih =>
    simp only [List.cons_append, transport, prefixTransport, ih, LinearMap.comp_assoc]
omit [NormedAddCommGroup E] [NormedSpace ℝ E] in
lemma allNoise_append (pre tail : List (MovingCoordinate E)) (t : ℝ) (vs : Noise E) :
    allNoise (pre++tail) t vs = allNoise tail t (allNoise pre t vs) := by
  induction pre generalizing vs with
  | nil => rfl
  | cons c cs ih => simpa only [List.cons_append, allNoise] using ih (coordinateNoise c t::vs)
 
lemma remainder_constant_prefix (f : DirectionalField E) (β : ℝ) (b : ℝ≥0)
    (pre tail : List (MovingCoordinate E)) (t : ℝ) (vs : Noise E)
    (hb : ∀ c ∈ pre, c.gamma = b) :
    hierarchyRemainder f β (pre++tail) t b vs = prefixTransport f tail pre t
      (hierarchyRemainder f β tail t b (allNoise pre t vs)) := by
  induction pre generalizing vs with
  | nil => rfl
  | cons c cs ih =>
    have hc := hb c (by simp)
    have hcs : ∀ d ∈ cs, d.gamma = b := fun d hd => hb d (by simp [hd])
    simp only [List.cons_append, hierarchyRemainder, hc, sub_self, zero_smul, zero_add,
      allNoise, prefixTransport, LinearMap.comp_apply, ih (coordinateNoise c t::vs) hcs]
lemma remainder_nonempty_constant_prefix (f : DirectionalField E) (β a : ℝ) (b : ℝ≥0)
    (c : MovingCoordinate E) (pre tail : List (MovingCoordinate E)) (t : ℝ) (vs : Noise E)
    (hb : ∀ d ∈ c::pre, d.gamma = b) :
    hierarchyRemainder f β ((c::pre)++tail) t a vs =
      ((b:ℝ)-a) • noiseGradient ((hierarchy f ((c::pre)++tail)).field t) vs +
        prefixTransport f tail (c::pre) t
          (hierarchyRemainder f β tail t b (allNoise (c::pre) t vs)) := by
  have hc := hb c (by simp)
  have hpre : ∀ d ∈ pre, d.gamma = b := fun d hd => hb d (by simp [hd])
  simp only [List.cons_append, hierarchyRemainder, hc, prefixTransport, LinearMap.comp_apply, allNoise]
  rw [remainder_constant_prefix f β b pre tail t (coordinateNoise c t::vs) hpre]
end ParisiFinite
 
open MeasureTheory ProbabilityTheory Filter
open scoped NNReal Topology BigOperators
namespace ParisiFinite
variable {ι : Type*}
def coordinatesKernel (cs : List (MovingCoordinate (ι → ℝ))) (t : ℝ) : ι → ι → ℝ :=
  (cs.map (fun c => fun i j => (c.scale t*c.velocity t)*(c.direction i*c.direction j))).sum
lemma coordinatesKernel_nil (t : ℝ) : coordinatesKernel ([] : List (MovingCoordinate (ι → ℝ))) t = 0 := rfl
lemma coordinatesKernel_cons (c : MovingCoordinate (ι → ℝ)) (cs : List (MovingCoordinate (ι → ℝ))) (t : ℝ) :
    coordinatesKernel (c::cs) t = (fun i j => (c.scale t*c.velocity t)*(c.direction i*c.direction j)) + coordinatesKernel cs t := rfl
lemma coordinatesKernel_append (pre tail : List (MovingCoordinate (ι → ℝ))) (t : ℝ) :
    coordinatesKernel (pre++tail) t = coordinatesKernel pre t + coordinatesKernel tail t := by
  simp [coordinatesKernel, List.sum_append]
lemma coordinatesKernel_ofFn {k : ℕ} (c : Fin k → MovingCoordinate (ι → ℝ)) (t : ℝ) (i j : ι) :
    coordinatesKernel (List.ofFn c) t i j = ∑ l, (c l).scale t*(c l).velocity t*((c l).direction i*(c l).direction j) := by
  simp [coordinatesKernel, List.map_ofFn, List.sum_ofFn]
lemma kernelNoise_allNoise [Fintype ι] [Nonempty ι] (cs : List (MovingCoordinate (ι → ℝ)))
    (t : ℝ) (vs : Noise (ι → ℝ)) :
    kernelNoise (allNoise cs t vs) = kernelNoise vs + coordinatesKernel cs t := by
  induction cs generalizing vs with
  | nil => simp [allNoise, coordinatesKernel_nil]
  | cons c cs ih =>
    rw [allNoise, ih, coordinatesKernel_cons]
    ext i j
    simp only [kernelNoise, coordinateNoise, Pi.add_apply]
    ring
 
def dummyCoordinate (a : ℝ≥0) : MovingCoordinate (ι → ℝ) := MovingCoordinate.constant a 0 0
lemma coordinatesKernel_dummy (a : ℝ≥0) (cs : List (MovingCoordinate (ι → ℝ))) (t : ℝ) :
    coordinatesKernel (dummyCoordinate a::cs) t = coordinatesKernel cs t := by
  ext i j
  simp [coordinatesKernel_cons, dummyCoordinate, MovingCoordinate.constant]
end ParisiFinite
namespace ParisiGuerra
open ParisiFinite SKQAOA SKGaussian ParisiInterpolation
def costBlock (n : ℕ) : List (MovingCoordinate (Configuration n → ℝ)) :=
  dummyCoordinate 0 :: List.ofFn (fun k : Fin (Fintype.card (Edge n)) =>
    MovingCoordinate.sine 0 (fun σ => skCoeff n σ ((Fintype.equivFin (Edge n)).symm k)))
def siteBlock (n : ℕ) (l : ℝ≥0 × ℝ≥0) : List (MovingCoordinate (Configuration n → ℝ)) :=
  dummyCoordinate l.1 :: List.ofFn (fun i : Fin n =>
    MovingCoordinate.cosine l.1 (fun σ => Real.sqrt l.2*spin σ i))
def siteCoordinates (n : ℕ) (ls : Schedule) : List (MovingCoordinate (Configuration n → ℝ)) :=
  ls.flatMap (siteBlock n)
def coordinates (n : ℕ) (ls : Schedule) := costBlock n ++ siteCoordinates n ls
def pressureCurve (n : ℕ) (β : ℝ) (ls : Schedule) (t : ℝ) : ℝ :=
  hierarchyValue (spinTrace β) (coordinates n ls) t 0
lemma costBlock_gamma (n : ℕ) : ∀ c ∈ costBlock n, c.gamma = 0 := by
  intro c hc
  simp only [costBlock, List.mem_cons, List.mem_ofFn] at hc
  rcases hc with rfl | ⟨i,rfl⟩ <;> rfl
lemma siteBlock_gamma (n : ℕ) (l : ℝ≥0 × ℝ≥0) : ∀ c ∈ siteBlock n l, c.gamma = l.1 := by
  intro c hc
  simp only [siteBlock, List.mem_cons, List.mem_ofFn] at hc
  rcases hc with rfl | ⟨i,rfl⟩ <;> rfl
lemma costBlock_kernel (n : ℕ) (t : ℝ) (σ τ : Configuration n) :
    coordinatesKernel (costBlock n) t σ τ =
      Real.sin t*Real.cos t*(∑ e, skCoeff n σ e*skCoeff n τ e) := by
  rw [costBlock, coordinatesKernel_dummy, coordinatesKernel_ofFn]
  simp only [MovingCoordinate.sine]
  rw [← Finset.mul_sum]
  congr 1
  exact ((Fintype.equivFin (Edge n)).symm.sum_comp (fun e => skCoeff n σ e*skCoeff n τ e))
lemma siteBlock_kernel (n : ℕ) (l : ℝ≥0 × ℝ≥0) (t : ℝ) (σ τ : Configuration n) :
    coordinatesKernel (siteBlock n l) t σ τ =
      -(Real.sin t*Real.cos t)*(l.2:ℝ)*overlapSum σ τ := by
  rw [siteBlock, coordinatesKernel_dummy, coordinatesKernel_ofFn]
  have hs := Real.sq_sqrt l.2.coe_nonneg
  have he (i : Fin n) : Real.cos t*(-Real.sin t)*
      ((Real.sqrt l.2*spin σ i)*(Real.sqrt l.2*spin τ i)) =
      (-(Real.sin t*Real.cos t)*(l.2:ℝ))*(spin σ i*spin τ i) := by
    calc
      _ = (-(Real.sin t*Real.cos t))*(Real.sqrt l.2)^2*(spin σ i*spin τ i) := by ring
      _ = _ := by rw [hs]
  simp only [MovingCoordinate.cosine, he, ← Finset.mul_sum, overlapSum]
 
def frontierKernel (n : ℕ) (q t : ℝ) (σ τ : Configuration n) : ℝ :=
  Real.sin t*Real.cos t*((n:ℝ)/2*(overlap σ τ-q)^2-(n:ℝ)/2*q^2-1/2)
lemma costBlock_frontier {n : ℕ} (hn : 0 < n) (t : ℝ) :
    coordinatesKernel (costBlock n) t = frontierKernel n 0 t := by
  ext σ τ
  rw [costBlock_kernel, coeff_covariance hn]
  unfold frontierKernel overlap
  have hn' : (n:ℝ) ≠ 0 := Nat.cast_ne_zero.mpr hn.ne'
  field_simp [hn']
  ring

lemma frontier_add_site {n : ℕ} (hn : 0 < n) (q t : ℝ) (l : ℝ≥0 × ℝ≥0) :
    frontierKernel n q t + coordinatesKernel (siteBlock n l) t = frontierKernel n (q+l.2) t := by
  ext σ τ
  simp only [Pi.add_apply, siteBlock_kernel]
  unfold frontierKernel overlap
  have hn' : (n:ℝ) ≠ 0 := Nat.cast_ne_zero.mpr hn.ne'
  field_simp [hn']
  ring
end ParisiGuerra
end
end OAI