import Mathlib
import OAI.Probability.ParisiFinite.TreeNodeDepth

namespace OAI

/-! Log Series Term Bound. -/

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 TopologicalSpace
open scoped BigOperators Topology NNReal ENNReal
open MeasureTheory ProbabilityTheory Filter Set MeasurableSpace
open MeasureTheory ProbabilityTheory Filter TopologicalSpace Set MeasurableSpace
open scoped BigOperators Topology NNReal ENNReal MatrixOrder
open scoped BigOperators Topology NNReal ENNReal ContDiff
open MeasureTheory ProbabilityTheory Filter TopologicalSpace
open scoped BigOperators Topology NNReal ENNReal
namespace SKCavity
open SKQAOA SKGaussian ParisiInterpolation ParisiFinite

lemma log_series_term_bound {x z : ℝ} (hx : 0≤x ∧ x≤1) (hz : |z|<1) (n : ℕ) :
    ‖-(z*x)^(n+1)/(n+1:ℕ)‖≤|z|^n := by
  have hn : (1:ℝ)≤(n+1:ℕ) := by exact_mod_cast Nat.succ_pos n
  rw [Real.norm_eq_abs,abs_div,abs_neg,abs_pow,abs_mul,abs_of_nonneg hx.1,
    abs_of_nonneg (by positivity : (0:ℝ)≤(n+1:ℕ))]
  calc
    (|z| * x)^(n+1)/(n+1:ℕ) ≤ |z|^(n+1)/(n+1:ℕ) :=
      div_le_div_of_nonneg_right (pow_le_pow_left₀ (mul_nonneg (abs_nonneg _) hx.1)
        (mul_le_of_le_one_right (abs_nonneg _) hx.2) _) (by positivity)
    _ ≤ |z|^(n+1) := div_le_self (pow_nonneg (abs_nonneg _) _) hn
    _ ≤ |z|^n := by rw [pow_succ]; exact mul_le_of_le_one_right (pow_nonneg (abs_nonneg _) _) hz.le

lemma integral_log_unit_series {Ω : Type*} [MeasurableSpace Ω] (ν : Measure Ω) [IsProbabilityMeasure ν]
    {Y : Ω → ℝ} (hY : Measurable Y) (hb : ∀ sample,0≤Y sample ∧ Y sample≤1) {z : ℝ} (hz : |z|<1) :
    (∫ sample,Real.log (1-z*Y sample) ∂ν)=
      ∑' n,-(∫ sample,Y sample^(n+1) ∂ν)*z^(n+1)/(n+1:ℕ) := by
  let F (n : ℕ) (sample : Ω) : ℝ := -(z*Y sample)^(n+1)/(n+1:ℕ)
  have hFi (n : ℕ) : Integrable (F n) ν :=
    integrable_of_uniform_abs (by fun_prop) (fun sample => by
      simpa only [Real.norm_eq_abs] using log_series_term_bound (hb sample) hz n)
  have hs : Summable (fun n => ∫ sample,‖F n sample‖ ∂ν) := by
    apply Summable.of_nonneg_of_le (fun n => integral_nonneg (fun sample => norm_nonneg _))
      (fun n => ?_) (summable_geometric_of_lt_one (abs_nonneg z) hz)
    simpa using integral_mono (hFi n).norm (integrable_const (|z|^n))
      (fun sample => log_series_term_bound (hb sample) hz n)
  have hseries : ∀ sample,HasSum (fun n => F n sample) (Real.log (1-z*Y sample)) := by
    intro sample
    have hzx : |z*Y sample|<1 := ((by
      rw [abs_mul,abs_of_nonneg (hb sample).1]
      exact mul_le_of_le_one_right (abs_nonneg z) (hb sample).2) : |z*Y sample|≤|z|).trans_lt hz
    simpa only [F,Nat.cast_add,Nat.cast_one,neg_div,neg_neg] using (Real.hasSum_pow_div_log_of_abs_lt_one hzx).neg
  have hi := hasSum_integral_of_summable_integral_norm hFi hs
  simp_rw [(hseries _).tsum_eq] at hi
  rw [← hi.tsum_eq]
  apply tsum_congr
  intro n
  simp only [F,mul_pow,neg_div,integral_neg,integral_div,integral_const_mul]
  ring

 

theorem empirical_log_limit_of_distinct_moments
    {Ω : ℕ → Type*} [∀ r,MeasurableSpace (Ω r)] (ν : (r : ℕ) → Measure (Ω r))
    [∀ r,IsProbabilityMeasure (ν r)] (X : (r : ℕ) → Ω r → Fin (r+1) → ℝ)
    (hX : ∀ r i,Measurable (fun sample => X r sample i))
    (hb : ∀ r sample i,0≤X r sample i ∧ X r sample i≤1)
    (M : ℕ → ℝ) (hM : ∀ k,0≤M k ∧ M k≤1)
    (he : ∀ r k (e : Fin k → Fin (r+1)),Function.Injective e →
      (∫ sample,∏ i,X r sample (e i) ∂ν r)=M k)
    {z : ℝ} (hz : |z|<1) :
    Tendsto (fun r => ∫ sample,Real.log (1-z*((∑ i,X r sample i)/(r+1:ℕ))) ∂ν r) atTop
      (𝓝 (∑' n,-M (n+1)*z^(n+1)/(n+1:ℕ))) := by
  let Y (r : ℕ) (sample : Ω r) : ℝ := (∑ i,X r sample i)/(r+1:ℕ)
  have hYm (r : ℕ) : Measurable (Y r) := (Finset.measurable_sum _ (fun i _ => hX r i)).div_const _
  have hYb (r : ℕ) (sample : Ω r) : 0≤Y r sample ∧ Y r sample≤1 := by
    dsimp only [Y]
    constructor
    · exact div_nonneg (Finset.sum_nonneg (fun i _ => (hb r sample i).1)) (by positivity)
    · apply (div_le_one (by positivity)).mpr
      simpa using Finset.sum_le_sum (s:=Finset.univ) (fun i _ => (hb r sample i).2)
  have hprod (r k : ℕ) (e : Fin k → Fin (r+1)) (sample : Ω r) :
      0≤∏ i,X r sample (e i) ∧ (∏ i,X r sample (e i))≤1 :=
    ⟨Finset.prod_nonneg (fun i _ => (hb r sample (e i)).1),
       Finset.prod_le_one₀ (fun i _ => (hb r sample (e i)).1) (fun i _ => (hb r sample (e i)).2)⟩
  have hprodi (r k : ℕ) (e : Fin k → Fin (r+1)) :
      Integrable (fun sample => ∏ i,X r sample (e i)) (ν r) := by
    apply integrable_of_uniform_abs (Finset.measurable_prod _ (fun i _ => hX r (e i)))
    intro sample
    rw [abs_of_nonneg (hprod r k e sample).1]
    exact (hprod r k e sample).2
  have hmom (k : ℕ) : Tendsto (fun r => ∫ sample,Y r sample^k ∂ν r) atTop (𝓝 (M k)) := by
    have hh (r : ℕ) : (∫ sample,Y r sample^k ∂ν r)=
        (∑ e : Fin k → Fin (r+1),∫ sample,∏ i,X r sample (e i) ∂ν r)/(r+1:ℕ)^k := by
      simp only [Y,div_pow,Fintype.sum_pow,integral_div]
      rw [integral_finsetSum Finset.univ (fun e _ => hprodi r k e)]
    simp_rw [hh]
    apply replica_average_moment_tendsto k _ (hM k)
    · intro r e
      refine ⟨integral_nonneg (fun sample => (hprod r k e sample).1),?_⟩
      simpa using integral_mono (hprodi r k e) (integrable_const (1:ℝ)) (fun sample => (hprod r k e sample).2)
    · exact fun r e h => he r k e h
  have hlog (r : ℕ) := integral_log_unit_series (ν r) (hYm r) (hYb r) hz
  change Tendsto (fun r => ∫ sample,Real.log (1-z*Y r sample) ∂ν r) _ _
  simp_rw [hlog]
  apply tendsto_tsum_of_dominated_convergence (summable_geometric_of_lt_one (abs_nonneg z) hz)
  · intro n
    exact (((hmom (n+1)).neg).mul_const (z^(n+1))).div_const _
  · apply Eventually.of_forall
    intro r n
    have hbb : 0≤(∫ sample,Y r sample^(n+1) ∂ν r) ∧ (∫ sample,Y r sample^(n+1) ∂ν r)≤1 := by
      refine ⟨integral_nonneg (fun sample => pow_nonneg (hYb r sample).1 _),?_⟩
      have hi : Integrable (fun sample => Y r sample^(n+1)) (ν r) := by
        apply integrable_of_uniform_abs ((hYm r).pow_const _)
        intro sample
        rw [abs_of_nonneg (pow_nonneg (hYb r sample).1 _)]
        exact pow_le_one₀ (hYb r sample).1 (hYb r sample).2
      simpa using integral_mono hi (integrable_const (1:ℝ))
        (fun sample => pow_le_one₀ (hYb r sample).1 (hYb r sample).2)
    have hh := normalized_moment_bound hbb z (n+1)
    have hzpow : |z|^(n+1)≤|z|^n := by
      rw [pow_succ]; exact mul_le_of_le_one_right (pow_nonneg (abs_nonneg _) _) hz.le
    convert hh.trans hzpow using 1
    congr 1
    push_cast
    ring

end SKCavity

open MeasureTheory ProbabilityTheory Filter TopologicalSpace
open scoped BigOperators Topology NNReal ENNReal
namespace SKCavity
open SKQAOA SKGaussian ParisiInterpolation ParisiFinite

def treePathVector {d r : ℕ} (T : PartitionTree d r) (z : TreeNode T → ℝ)
    (i : Fin r) (k : Fin d) : ℝ := z (treeNodePath T i k)

lemma treePathVector_continuous {d r : ℕ} (T : PartitionTree d r) :
    Continuous (treePathVector T) := by unfold treePathVector; fun_prop

def treePathLaw {d r : ℕ} (T : PartitionTree d r) : Measure (Fin r → Fin d → ℝ) :=
  (gaussianLaw (TreeNode T)).map (treePathVector T)

instance treePathLaw_probability {d r : ℕ} (T : PartitionTree d r) :
    IsProbabilityMeasure (treePathLaw T) := by
  unfold treePathLaw
  infer_instance

lemma integral_treePathLaw {d r : ℕ} (T : PartitionTree d r)
    (f : (Fin r → Fin d → ℝ) → ℝ) (hf : Measurable f) :
    (∫ s,f s ∂treePathLaw T)=∫ z,f (treePathVector T z) ∂gaussianLaw (TreeNode T) :=
  integral_map (treePathVector_continuous T).measurable.aemeasurable hf.aestronglyMeasurable

def pathCoeff {d r : ℕ} (T : PartitionTree d r) (i : Fin r×Fin d) (n : TreeNode T) : ℝ :=
  if treeNodePath T i.1 i.2=n then 1 else 0

lemma field_pathCoeff {d r : ℕ} (T : PartitionTree d r) (z : TreeNode T → ℝ) (i : Fin r×Fin d) :
    field (pathCoeff T) z i=treePathVector T z i.1 i.2 := by
  classical
  simp [field,pathCoeff,treePathVector]

lemma kernel_pathCoeff {d r : ℕ} (T : PartitionTree d r) (i j : Fin r×Fin d) :
    kernel (pathCoeff T) i j=if treeNodePath T i.1 i.2=treeNodePath T j.1 j.2 then 1 else 0 := by
  classical
  unfold kernel pathCoeff
  rw [Finset.sum_eq_single (treeNodePath T i.1 i.2)]
  · simp [eq_comm]
  · intro n _ hn
    simp [Ne.symm hn]
  · simp

lemma treePath_marginal_integral {d r k : ℕ} (T : PartitionTree d r) (U : PartitionTree d k)
    (e : Fin k → Fin r)
    (he : ∀ (l : Fin d) (i j : Fin k),treeCodes T l.succ (e i)=treeCodes T l.succ (e j) ↔
      treeCodes U l.succ i=treeCodes U l.succ j)
    (f : (Fin k → Fin d → ℝ) → ℝ) (hf : Measurable f) :
    (∫ s,f (fun i => s (e i)) ∂treePathLaw T)=(∫ s,f s ∂treePathLaw U) := by
  have hp (i j : Fin k×Fin d) :
      treeNodePath T (e i.1) i.2=treeNodePath T (e j.1) j.2 ↔
      treeNodePath U i.1 i.2=treeNodePath U j.1 j.2 := by
    constructor
    · intro h
      have hkl := treeNodePath_eq_levels T _ _ _ _ h
      obtain ⟨i,l⟩ := i
      obtain ⟨j,k⟩ := j
      dsimp only at hkl h ⊢
      subst k
      rw [treeNodePath_eq_iff] at h ⊢
      exact (he l i j).mp h
    · intro h
      have hkl := treeNodePath_eq_levels U _ _ _ _ h
      obtain ⟨i,l⟩ := i
      obtain ⟨j,k⟩ := j
      dsimp only at hkl h ⊢
      subst k
      rw [treeNodePath_eq_iff] at h ⊢
      exact (he l i j).mpr h
  have hk : kernel (fun i : Fin k×Fin d => pathCoeff T (e i.1,i.2))=kernel (pathCoeff U) := by
    funext i j
    change kernel (pathCoeff T) (e i.1,i.2) (e j.1,j.2)=_
    simp only [kernel_pathCoeff,hp]
  rw [integral_treePathLaw T (fun s => f (fun i => s (e i))) (hf.comp (by fun_prop)),integral_treePathLaw U f hf]
  have hh := integral_field_eq_of_kernel (fun i : Fin k×Fin d => pathCoeff T (e i.1,i.2))
    (pathCoeff U) hk (fun x => f (fun i l => x (i,l))) (hf.comp (by fun_prop))
  convert hh using 1
  · congr 1; funext z; congr 1; funext i l
    exact (field_pathCoeff T z (e i,l)).symm
  · congr 1; funext z; congr 1; funext i l
    exact (field_pathCoeff U z (i,l)).symm

end SKCavity

open MeasureTheory ProbabilityTheory Filter TopologicalSpace
open scoped BigOperators Topology NNReal ENNReal
namespace SKCavity
open SKQAOA SKGaussian ParisiInterpolation ParisiFinite

def hierarchySampleLaw {d : ℕ} (μ : ProbabilityMeasure OverlapArray) (q : Fin (d+1) → ℝ)
    (r : ℕ) : Measure (Fin r → Fin d → ℝ) :=
  ∑ T : PartitionTree d r,(μ:Measure OverlapArray) (hierarchyEvent (treeCodes T) q) • treePathLaw T

def hierarchyBlockSample {d r : ℕ} (q : Fin (d+1) → ℝ)
    (f : (Fin r → Fin d → ℝ) → ℝ) (A : OverlapBlock r) : ℝ :=
  ∑ T : PartitionTree d r,(hierarchyBlock (treeCodes T) q).indicator
    (fun _ => ∫ s,f s ∂treePathLaw T) A

lemma hierarchyBlockSample_measurable {d r : ℕ} (q : Fin (d+1) → ℝ)
    (f : (Fin r → Fin d → ℝ) → ℝ) : Measurable (hierarchyBlockSample q f) := by
  apply Finset.measurable_sum
  intro T _
  exact measurable_const.indicator (hierarchyBlock_measurable _ _)

lemma hierarchyBlockSample_on_event {d r : ℕ} (q : Fin (d+1) → ℝ)
    (f : (Fin r → Fin d → ℝ) → ℝ) (T : PartitionTree d r)
    {A : OverlapBlock r} (hA : A∈hierarchyBlock (treeCodes T) q) :
    hierarchyBlockSample q f A=∫ s,f s ∂treePathLaw T := by
  unfold hierarchyBlockSample
  rw [Finset.sum_eq_single T]
  · exact Set.indicator_of_mem hA _
  · intro U _ hUT
    apply Set.indicator_of_notMem
    intro hU
    apply hUT
    exact tree_eq_of_same_relations U T (fun k i j => (hU k i j).symm.trans (hA k i j))
  · simp

lemma hierarchySampleLaw_integral {d r : ℕ} (μ : ProbabilityMeasure OverlapArray)
    (q : Fin (d+1) → ℝ) {f : (Fin r → Fin d → ℝ) → ℝ} {C : ℝ}
    (hf : Measurable f) (hb : ∀ s,|f s|≤C) :
    (∫ s,f s ∂hierarchySampleLaw μ q r)=
      ∑ T : PartitionTree d r,(μ:Measure OverlapArray).real (hierarchyEvent (treeCodes T) q)*
        ∫ s,f s ∂treePathLaw T := by
  unfold hierarchySampleLaw
  rw [integral_finsetSum_measure]
  · simp only [integral_smul_measure,smul_eq_mul,Measure.real]
  · intro T _
    exact (integrable_of_uniform_abs hf hb).smul_measure (measure_ne_top _ _)

lemma hierarchySampleLaw_integral_block {d r : ℕ} (μ : ProbabilityMeasure OverlapArray)
    (q : Fin (d+1) → ℝ) {f : (Fin r → Fin d → ℝ) → ℝ} {C : ℝ}
    (hf : Measurable f) (hb : ∀ s,|f s|≤C) :
    (∫ s,f s ∂hierarchySampleLaw μ q r)=
      ∫ R,hierarchyBlockSample q f (blockOfArray r R) ∂(μ:Measure OverlapArray) := by
  rw [hierarchySampleLaw_integral μ q hf hb]
  have he (R : OverlapArray) : hierarchyBlockSample q f (blockOfArray r R)=
      ∑ T : PartitionTree d r,(hierarchyEvent (treeCodes T) q).indicator
        (fun _ => ∫ s,f s ∂treePathLaw T) R := rfl
  simp_rw [he]
  rw [integral_finsetSum]
  · apply Finset.sum_congr rfl
    intro T _
    rw [integral_indicator_const _ (hierarchyEvent_measurable _ _)]
    rfl
  · intro T _
    exact (integrable_const _).indicator (hierarchyEvent_measurable _ _)

lemma hierarchySampleLaw_probability {μ : ProbabilityMeasure OverlapArray}
    (hG : (μ:Measure OverlapArray) GramArrays=1) (hgg : GGIdentities μ)
    (hu : (μ:Measure OverlapArray) UltrametricArrays=1)
    {d : ℕ} (q : Fin (d+2) → ℝ) (hq : Monotone q) (h0 : q 0 < -1)
    (h1 : q (Fin.last (d+1))<1) {r : ℕ} (hr : 0<r) :
    IsProbabilityMeasure (hierarchySampleLaw μ q r) := by
  constructor
  unfold hierarchySampleLaw
  simp only [Measure.finsetSum_apply,Measure.smul_apply,measure_univ,smul_eq_mul,mul_one]
  have hc := hierarchy_partition_cover_all hG hgg hu q hq h0 h1 hr
  rw [measure_iUnion] at hc
  · simpa only [tsum_fintype] using hc
  · exact fun T U htu => tree_hierarchy_disjoint htu q
  · exact fun T => hierarchyEvent_measurable _ _

 

theorem hierarchySampleLaw_marginal_integral {μ : ProbabilityMeasure OverlapArray}
    (hG : (μ:Measure OverlapArray) GramArrays=1) (hgg : GGIdentities μ)
    (hu : (μ:Measure OverlapArray) UltrametricArrays=1) (hex : FiniteExchangeable μ)
    {d : ℕ} (q : Fin (d+2) → ℝ) (hq : Monotone q) (h0 : q 0 < -1)
    (h1 : q (Fin.last (d+1))<1) {r k : ℕ} (hr : 0<r) (hk : 0<k)
    (e : Fin k → Fin r) (he : Function.Injective e)
    {f : (Fin k → Fin (d+1) → ℝ) → ℝ} {C : ℝ} (hf : Measurable f) (hb : ∀ s,|f s|≤C) :
    (∫ s,f (fun i => s (e i)) ∂hierarchySampleLaw μ q r)=
      ∫ s,f s ∂hierarchySampleLaw μ q k := by
  let B : Set (OverlapBlock k) := ⋃ U : PartitionTree (d+1) k,hierarchyBlock (treeCodes U) q
  have hBm : MeasurableSet B := MeasurableSet.iUnion fun U => hierarchyBlock_measurable _ _
  have he' : Function.Injective (fun i => (e i:ℕ)) := Fin.val_injective.comp he
  have hcov : (μ:Measure OverlapArray) ((selectedBlock (fun i => (e i:ℕ))) ⁻¹' B)=1 := by
    rw [exchangeable_event hex _ he' hBm]
    dsimp only [B]
    rw [Set.preimage_iUnion]
    exact hierarchy_partition_cover_all hG hgg hu q hq h0 h1 hk
  have hcovr := hierarchy_partition_cover_all hG hgg hu q hq h0 h1 hr
  rw [hierarchySampleLaw_integral_block μ q (f:=fun s => f (fun i => s (e i)))
      (hf.comp (by fun_prop)) (fun s => hb _),hierarchySampleLaw_integral_block μ q hf hb]
  have hpoint : ∀ᵐ R ∂(μ:Measure OverlapArray),
      hierarchyBlockSample q (fun s => f (fun i => s (e i))) (blockOfArray r R)=
        hierarchyBlockSample q f (selectedBlock (fun i => (e i:ℕ)) R) := by
    filter_upwards [ae_full_probability μ (MeasurableSet.iUnion fun T => hierarchyEvent_measurable (treeCodes T) q) hcovr,
      ae_full_probability μ (hBm.preimage (continuous_selectedBlock _).measurable) hcov] with R hR hS
    obtain ⟨T,hT⟩ := Set.mem_iUnion.mp hR
    obtain ⟨U,hU⟩ := Set.mem_iUnion.mp hS
    rw [hierarchyBlockSample_on_event q _ T hT,hierarchyBlockSample_on_event q _ U hU]
    apply treePath_marginal_integral T U e
    · intro l i j
      exact (hT l.succ (e i) (e j)).symm.trans (hU l.succ i j)
    · exact hf
  rw [integral_congr_ae hpoint]
  have hF := hierarchyBlockSample_measurable q f
  rw [← integral_map (continuous_selectedBlock _).measurable.aemeasurable hF.aestronglyMeasurable,
    hex k _ he',blockLaw,integral_map (continuous_blockOfArray k).measurable.aemeasurable hF.aestronglyMeasurable]

end SKCavity

open MeasureTheory ProbabilityTheory Filter TopologicalSpace
open scoped BigOperators Topology NNReal ENNReal
namespace SKCavity
open SKQAOA SKGaussian ParisiInterpolation ParisiFinite

lemma hierarchySampleLaw_product {d r : ℕ} (μ : ProbabilityMeasure OverlapArray)
    (q : Fin (d+1) → ℝ) {x : (Fin d → ℝ) → ℝ} (hx : Continuous x)
    (hb : ∀ s,0≤x s ∧ x s≤1) :
    (∫ s,∏ i : Fin r,x (s i) ∂hierarchySampleLaw μ q r)=gaussianHierarchyMoment μ q x r := by
  rw [hierarchySampleLaw_integral μ q (by fun_prop) (C:=1)]
  · apply Finset.sum_congr rfl
    intro T _
    congr 1
    rw [integral_treePathLaw T _ (by fun_prop)]
    rfl
  · intro s
    rw [abs_of_nonneg (Finset.prod_nonneg (fun i _ => (hb (s i)).1))]
    exact Finset.prod_le_one₀ (fun i _ => (hb (s i)).1) (fun i _ => (hb (s i)).2)

 

theorem hierarchy_empirical_log_tendsto {μ : ProbabilityMeasure OverlapArray}
    (hG : (μ:Measure OverlapArray) GramArrays=1) (hgg : GGIdentities μ)
    (hu : (μ:Measure OverlapArray) UltrametricArrays=1) (hex : FiniteExchangeable μ)
    {d : ℕ} (q : Fin (d+2) → ℝ) (hq : Monotone q) (h0 : q 0 < -1)
    (h1 : q (Fin.last (d+1))<1) (ha : ∀ k : Fin (d+1),overlapDiscount μ (q k.succ)≠0)
    {x : (Fin (d+1) → ℝ) → ℝ} (hx : Continuous x) (hb : ∀ s,0≤x s ∧ x s≤1)
    {z : ℝ} (hz : |z|<1) :
    Tendsto (fun r => ∫ s,Real.log (1-z*((∑ i : Fin (r+1),x (s i))/(r+1:ℕ)))
      ∂hierarchySampleLaw μ q (r+1)) atTop
      (𝓝 (gaussianHierarchyRisk (fun k => overlapDiscount μ (q k.succ))
        (fun s => Real.log (1-z*x s)))) := by
  let ν (r : ℕ) := hierarchySampleLaw μ q (r+1)
  let (r : ℕ) : IsProbabilityMeasure (ν r) :=
    hierarchySampleLaw_probability hG hgg hu q hq h0 h1 (Nat.succ_pos r)
  let M (k : ℕ) := if k=0 then 1 else gaussianHierarchyMoment μ q x k
  have hM (k : ℕ) : 0≤M k ∧ M k≤1 := by
    by_cases hk : k=0
    · simp [M,hk]
    · simpa [M,hk] using gaussianHierarchyMoment_mem_unit μ q hx hb k
  have he (r k : ℕ) (e : Fin k → Fin (r+1)) (he : Function.Injective e) :
      (∫ s,∏ i,x (s (e i)) ∂ν r)=M k := by
    by_cases hk : k=0
    · subst k
      simp [M]
    have hk' := Nat.pos_of_ne_zero hk
    rw [hierarchySampleLaw_marginal_integral hG hgg hu hex q hq h0 h1 (Nat.succ_pos r) hk'
      e he (f:=fun s => ∏ i,x (s i)) (by fun_prop) (C:=1)]
    · simpa [M,hk] using hierarchySampleLaw_product μ q hx hb
    · intro s
      rw [abs_of_nonneg (Finset.prod_nonneg (fun i _ => (hb (s i)).1))]
      exact Finset.prod_le_one₀ (fun i _ => (hb (s i)).1) (fun i _ => (hb (s i)).2)
  have ht := empirical_log_limit_of_distinct_moments ν (fun _ s i => x (s i))
    (fun _ i => hx.measurable.comp (measurable_pi_apply i)) (fun _ s i => hb (s i)) M hM he hz
  rw [GG_gaussian_hierarchy_log_identity hG hgg hu q hq h0 h1 ha hx hb hz]
  have hs : Summable (fun n => -gaussianHierarchyMoment μ q x n/(n:ℝ)*z^n) := by
    apply Summable.of_norm_bounded_eventually (summable_geometric_of_lt_one (abs_nonneg z) hz)
    exact Eventually.of_forall (fun n => normalized_moment_bound (gaussianHierarchyMoment_mem_unit μ q hx hb n) z n)
  rw [hs.tsum_eq_zero_add]
  simp only [Nat.cast_zero,div_zero,zero_mul,zero_add]
  convert ht using 2
  apply tsum_congr
  intro n
  simp only [M,Nat.add_one_ne_zero,↓reduceIte]
  ring

end SKCavity

open MeasureTheory ProbabilityTheory Filter TopologicalSpace
open scoped BigOperators Topology NNReal ENNReal
namespace SKCavity
open SKQAOA SKGaussian ParisiInterpolation ParisiFinite

lemma unit_average {r : ℕ} (hr : 0<r) {x : Fin r → ℝ} (hx : ∀ i,0≤x i ∧ x i≤1) :
    0≤(∑ i,x i)/(r:ℝ) ∧ (∑ i,x i)/(r:ℝ)≤1 := by
  refine ⟨div_nonneg (Finset.sum_nonneg (fun i _ => (hx i).1)) (by positivity),?_⟩
  apply (div_le_one (by positivity)).mpr
  simpa using Finset.sum_le_sum (s:=Finset.univ) (fun i _ => (hx i).2)

lemma affine_average {r : ℕ} (hr : 0<r) (b z : ℝ) (x : Fin r → ℝ) :
    (∑ i,b*(1-z*x i))/(r:ℝ)=b*(1-z*((∑ i,x i)/(r:ℝ))) := by
  simp only [mul_sub,mul_one,Finset.sum_sub_distrib,← Finset.mul_sum,Finset.sum_const,
    Finset.card_univ,Fintype.card_fin,nsmul_eq_mul]
  have hr0 : (r:ℝ)≠0 := Nat.cast_ne_zero.mpr hr.ne'
  field_simp

lemma integral_affine_average_log {Ω : Type*} [MeasurableSpace Ω] (ν : Measure Ω)
    [IsProbabilityMeasure ν] {r : ℕ} (hr : 0<r) {x : Ω → Fin r → ℝ}
    (hx : ∀ i,Measurable (fun sample => x sample i)) (hb : ∀ sample i,0≤x sample i ∧ x sample i≤1)
    {b z : ℝ} (hbp : 0<b) (hz : |z|<1) :
    (∫ sample,Real.log ((∑ i,b*(1-z*x sample i))/(r:ℝ)) ∂ν)=
      (∫ sample,Real.log (1-z*((∑ i,x sample i)/(r:ℝ))) ∂ν)+Real.log b := by
  have hav (sample : Ω) := unit_average hr (hb sample)
  have hf : Measurable (fun sample => Real.log (1-z*((∑ i,x sample i)/(r:ℝ)))) := by
    apply Real.measurable_log.comp
    exact measurable_const.sub (((Finset.measurable_sum _ (fun i _ => hx i)).div_const _).const_mul _)
  have hi : Integrable (fun sample => Real.log (1-z*((∑ i,x sample i)/(r:ℝ)))) ν := by
    apply integrable_of_uniform_abs hf (C:=|Real.log (1-|z|)|+|Real.log (1+|z|)|)
    intro sample
    exact affine_log_bounded (x:=fun _ : Fin 0 → ℝ => (∑ i,x sample i)/(r:ℝ)) (fun _ => hav sample) hz (fun k => k.elim0)
  simp_rw [affine_average hr,Real.log_mul hbp.ne' (affine_mark_pos (hav _) hz).ne']
  rw [integral_add (integrable_const _) hi]
  simp [add_comm]

end SKCavity

open MeasureTheory ProbabilityTheory Filter TopologicalSpace
open scoped BigOperators Topology NNReal ENNReal
namespace SKCavity
open SKQAOA SKGaussian ParisiInterpolation ParisiFinite

lemma gaussianHierarchyRisk_add_const {d : ℕ} {a : Fin d → ℝ} (ha : ∀ k,0≤a k)
    {f : (Fin d → ℝ) → ℝ} {C : ℝ} (hf : Continuous f) (hb : ∀ s,|f s|≤C) (c : ℝ) :
    gaussianHierarchyRisk a (fun s => f s+c)=gaussianHierarchyRisk a f+c := by
  induction d with
  | zero => rfl
  | succ d ih =>
    simp only [gaussianHierarchyRisk]
    have he (z : ℝ) := ih (fun k => ha k.succ)
      (hf.comp (continuous_finCons continuous_const continuous_id)) (fun s => hb (Fin.cons z s))
    simp only [Function.comp_def,id_eq] at he
    simp_rw [he]
    have hh := gaussianHierarchyRisk_continuous_bound (fun k => ha k.succ)
      (f:=fun z s => f (Fin.cons z s))
      (hf.comp (continuous_finCons continuous_fst continuous_snd)) (fun z s => hb (Fin.cons z s))
    exact logMean_add_const (integrable_of_uniform_abs hh.1.measurable hh.2)
      (integrable_exp_of_uniform_abs (a 0) hh.1.measurable hh.2) c

 

theorem hierarchy_empirical_positive_tendsto {μ : ProbabilityMeasure OverlapArray}
    (hG : (μ:Measure OverlapArray) GramArrays=1) (hgg : GGIdentities μ)
    (hu : (μ:Measure OverlapArray) UltrametricArrays=1) (hex : FiniteExchangeable μ)
    {d : ℕ} (q : Fin (d+2) → ℝ) (hq : Monotone q) (h0 : q 0 < -1)
    (h1 : q (Fin.last (d+1))<1) (ha : ∀ k : Fin (d+1),overlapDiscount μ (q k.succ)≠0)
    {y : (Fin (d+1) → ℝ) → ℝ} (hy : Continuous y) {l b : ℝ} (hl : 0<l) (hlb : l<b)
    (hb : ∀ s,l≤y s ∧ y s≤b) :
    Tendsto (fun r => ∫ s,Real.log ((∑ i : Fin (r+1),y (s i))/(r+1:ℕ))
      ∂hierarchySampleLaw μ q (r+1)) atTop
      (𝓝 (gaussianHierarchyRisk (fun k => overlapDiscount μ (q k.succ)) (fun s => Real.log (y s)))) := by
  let x (s : Fin (d+1) → ℝ) := (b-y s)/(b-l)
  let z := (b-l)/b
  have hbp : 0<b := hl.trans hlb
  have hbl : 0<b-l := sub_pos.mpr hlb
  have hx : Continuous x := by unfold x; fun_prop
  have hxb (s : Fin (d+1) → ℝ) : 0≤x s ∧ x s≤1 := by
    exact ⟨div_nonneg (sub_nonneg.mpr (hb s).2) hbl.le,
      (div_le_one hbl).mpr (by linarith [(hb s).1])⟩
  have hz : |z|<1 := by
    rw [abs_of_pos (div_pos hbl hbp)]
    exact (div_lt_one hbp).mpr (by linarith)
  have he (s : Fin (d+1) → ℝ) : y s=b*(1-z*x s) := by
    dsimp only [x,z]
    field_simp
    ring
  have hlog (s : Fin (d+1) → ℝ) : Real.log (y s)=Real.log (1-z*x s)+Real.log b := by
    rw [he,Real.log_mul hbp.ne' (affine_mark_pos (hxb s) hz).ne']
    ring
  have ht := hierarchy_empirical_log_tendsto hG hgg hu hex q hq h0 h1 ha hx hxb hz
  have hlogc : Continuous (fun s => Real.log (1-z*x s)) :=
    (continuous_const.sub (hx.const_mul z)).log (fun s => (affine_mark_pos (hxb s) hz).ne')
  have hrisk := gaussianHierarchyRisk_add_const (a:=fun k : Fin (d+1) => overlapDiscount μ (q k.succ)) (fun k => (measureReal_nonneg : 0≤overlapDiscount μ (q k.succ)))
    hlogc (affine_log_bounded hxb hz) (Real.log b)
  have hleft (r : ℕ) : (∫ s,Real.log ((∑ i : Fin (r+1),y (s i))/(r+1:ℕ)) ∂hierarchySampleLaw μ q (r+1))=
      (∫ s,Real.log (1-z*((∑ i : Fin (r+1),x (s i))/(r+1:ℕ))) ∂hierarchySampleLaw μ q (r+1))+Real.log b := by
    let := hierarchySampleLaw_probability hG hgg hu q hq h0 h1 (Nat.succ_pos r)
    have hrep : (fun s : Fin (r+1) → Fin (d+1) → ℝ => Real.log ((∑ i,y (s i))/(r+1:ℕ)))=
        (fun s => Real.log ((∑ i,b*(1-z*x (s i)))/(r+1:ℕ))) := by
      funext s
      congr 2
      exact Finset.sum_congr rfl (fun i _ => he (s i))
    rw [hrep]
    exact integral_affine_average_log _ (Nat.succ_pos r)
      (fun i => hx.measurable.comp (measurable_pi_apply i)) (fun s i => hxb (s i)) hbp hz
  simp_rw [hleft,hlog]
  rw [hrisk]
  exact ht.add_const _

end SKCavity

open MeasureTheory ProbabilityTheory Filter TopologicalSpace
open scoped BigOperators Topology NNReal ENNReal
namespace ParisiFinite

lemma bounded_exp_mass_derivative {Ω : Type*} [MeasurableSpace Ω] {ν : Measure Ω}
    [IsProbabilityMeasure ν] {f : Ω → ℝ} {C : ℝ} (hf : Measurable f) (hb : ∀ x,|f x|≤C) :
    HasDerivAt (fun a => ∫ x,Real.exp (a*f x) ∂ν) (∫ x,f x ∂ν) 0 := by
  have hC : 0≤C := by
    have : Nonempty Ω := nonempty_of_isProbabilityMeasure ν
    obtain ⟨x⟩ := this
    exact (abs_nonneg _).trans (hb x)
  have h := (hasDerivAt_integral_of_dominated_loc_of_deriv_le
    (s:=Set.Ioo (-1:ℝ) 1) (x₀:=0) (μ:=ν) (F:=fun a x => Real.exp (a*f x))
    (F':=fun a x => Real.exp (a*f x)*f x) (bound:=fun _ => Real.exp C*C)
    (Ioo_mem_nhds (by norm_num) (by norm_num)) ?_
    (by simp)
    ?_ ?_ (integrable_const _) ?_).2
  · simpa only [zero_mul,Real.exp_zero,one_mul] using h
  · exact Eventually.of_forall (fun a => (integrable_exp_of_uniform_abs a hf hb).aestronglyMeasurable)
  · exact ((hf.const_mul 0).exp.mul hf).aestronglyMeasurable
  · filter_upwards with x a ha
    rw [Real.norm_eq_abs,abs_mul,abs_of_pos (Real.exp_pos _)]
    have hab : |a|≤1 := (abs_lt.mpr ha).le
    have haf : a*f x≤C := (le_abs_self _).trans (by
      rw [abs_mul]
      exact (mul_le_mul_of_nonneg_right hab (abs_nonneg _)).trans (by simpa using hb x))
    exact mul_le_mul (Real.exp_le_exp.mpr haf) (hb x) (abs_nonneg _) (Real.exp_pos _).le
  · filter_upwards with x a _
    simpa only [one_mul,id_eq] using ((hasDerivAt_id a).mul_const (f x)).exp

lemma logMean_coefficient_continuousAt_zero {Ω : Type*} [MeasurableSpace Ω] {ν : Measure Ω}
    [IsProbabilityMeasure ν] {f : Ω → ℝ} {C : ℝ} (hf : Measurable f) (hb : ∀ x,|f x|≤C) :
    ContinuousAt (fun a => logMean ν a f) 0 := by
  have hmass := bounded_exp_mass_derivative (ν:=ν) hf hb
  have hp : (∫ x,Real.exp (0*f x) ∂ν)=(1:ℝ) := by simp
  have hd := hmass.log (by rw [hp]; norm_num)
  rw [hp,div_one] at hd
  have hc := hd.continuousAt_div
  have he : Function.update (fun a => (Real.log (∫ x,Real.exp (a*f x) ∂ν)-
      Real.log (∫ x,Real.exp (0*f x) ∂ν))/(a-0)) 0 (∫ x,f x ∂ν)=
      (fun a => logMean ν a f) := by
    funext a
    by_cases ha : a=0
    · subst a; simp [logMean]
    · simp [logMean,ha]
  rwa [he] at hc

lemma logMean_coefficient_continuous {Ω : Type*} [MeasurableSpace Ω] {ν : Measure Ω}
    [IsProbabilityMeasure ν] {f : Ω → ℝ} {C : ℝ} (hf : Measurable f) (hb : ∀ x,|f x|≤C) :
    Continuous (fun a => logMean ν a f) := by
  apply continuous_iff_continuousAt.mpr
  intro a
  by_cases ha : a=0
  · subst a; exact logMean_coefficient_continuousAt_zero hf hb
  have hmass : ContinuousAt (fun a => ∫ x,Real.exp (a*f x) ∂ν) a := by
    apply continuousAt_of_dominated (bound:=fun _ => Real.exp ((|a|+1)*C))
    · exact Eventually.of_forall fun t => ((hf.const_mul t).exp).aestronglyMeasurable
    · filter_upwards [continuous_abs.continuousAt.eventually (gt_mem_nhds (lt_add_one |a|))] with t ht
      filter_upwards with x
      rw [Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)]
      apply Real.exp_le_exp.mpr
      exact (le_abs_self _).trans (by
        rw [abs_mul]
        exact mul_le_mul ht.le (hb x) (abs_nonneg _) (by positivity))
    · exact integrable_const _
    · filter_upwards with x
      exact (Real.continuous_exp.comp (continuous_id.mul_const (f x))).continuousAt
  have hc := (hmass.log (integral_exp_pos (integrable_exp_of_uniform_abs a hf hb)).ne').div continuousAt_id ha
  apply hc.congr
  filter_upwards [eventually_ne_nhds ha] with t ht
  simp [logMean,ht]

end ParisiFinite

open MeasureTheory ProbabilityTheory Filter TopologicalSpace
open scoped BigOperators Topology NNReal ENNReal
namespace SKCavity
open SKQAOA SKGaussian ParisiInterpolation ParisiFinite
variable {ι : Type*} [Fintype ι] [MeasurableSpace ι] [MeasurableSingletonClass ι]

lemma finiteRisk_measure (ν : Measure ι) [IsFiniteMeasure ν] (a : ℝ) (f : ι → ℝ) :
    finiteRisk (fun i => ν.real {i}) a f=logMean ν a f := by
  unfold finiteRisk logMean
  rw [integral_fintype Integrable.of_finite,integral_fintype Integrable.of_finite]
  rfl

lemma finiteRisk_coefficient_tendsto (ν : Measure ι) [IsProbabilityMeasure ν]
    {a : ℕ → ℝ} {b : ℝ} (ha : ∀ m,0≤a m) (hab : Tendsto a atTop (𝓝 b))
    {f : ℕ → ι → ℝ} {g : ι → ℝ} (hfg : ∀ i,Tendsto (fun m => f m i) atTop (𝓝 (g i))) :
    Tendsto (fun m => finiteRisk (fun i => ν.real {i}) (a m) (f m)) atTop
      (𝓝 (finiteRisk (fun i => ν.real {i}) b g)) := by
  classical
  simp_rw [finiteRisk_measure]
  have hgb : ∀ i,|g i|≤∑ j,|g j| := fun i => Finset.single_le_sum (fun j _ => abs_nonneg (g j)) (Finset.mem_univ i)
  have hc := (logMean_coefficient_continuous (ν:=ν) (measurable_of_finite g) hgb).continuousAt.tendsto.comp hab
  have hnorm : Tendsto (fun m => ‖f m-g‖) atTop (𝓝 (0:ℝ)) := by
    simpa using ((tendsto_pi_nhds.mpr hfg).sub (tendsto_const_nhds (x:=g))).norm
  have hd : Tendsto (fun m => logMean ν (a m) (f m)-logMean ν (a m) g) atTop (𝓝 0) := by
    apply squeeze_zero_norm ?_ hnorm
    intro m
    rw [Real.norm_eq_abs]
    apply logMean_stable (ha m) Integrable.of_finite Integrable.of_finite
      Integrable.of_finite Integrable.of_finite
    intro i
    exact le_trans (norm_le_pi_norm (f m-g) i) (le_refl _) 
  have h := hd.add hc
  simpa only [Function.comp_def,sub_add_cancel,zero_add] using h

lemma finiteHierarchyRisk_coefficient_tendsto (ν : Measure ι) [IsProbabilityMeasure ν]
    {d : ℕ} {a : ℕ → Fin d → ℝ} {b : Fin d → ℝ}
    (ha : ∀ m k,0≤a m k) (hab : ∀ k,Tendsto (fun m => a m k) atTop (𝓝 (b k)))
    (f : (Fin d → ι) → ℝ) :
    Tendsto (fun m => finiteHierarchyRisk (fun i => ν.real {i}) (a m) f) atTop
      (𝓝 (finiteHierarchyRisk (fun i => ν.real {i}) b f)) := by
  induction d with
  | zero => exact tendsto_const_nhds
  | succ d ih =>
    apply finiteRisk_coefficient_tendsto ν (fun m => ha m 0) (hab 0)
    intro i
    exact ih (fun m k => ha m k.succ) (fun k => hab k.succ) (fun s => f (Fin.cons i s))

end SKCavity

end

end OAI