import Mathlib
import OAI.Probability.Perceptron.Variational.Trial

namespace OAI

noncomputable section
open MeasureTheory ProbabilityTheory Filter Set
open scoped ENNReal NNReal Topology BigOperators BoundedContinuousFunction
namespace SphericalPerceptronFreeEnergy
open Matrix
open scoped InnerProductSpace
variable {H : Type*} [SeminormedAddCommGroup H] [InnerProductSpace ℝ H]

lemma abs_hamiltonian_update_sub_le (α : ℝ) (φ : ℝ →ᵇ ℝ) (N : ℕ)
    (g : Patterns α N) (a : Fin (patternCount α N)) (y : Fin N → ℝ) (x : Spin N) :
    |hamiltonian α φ N (Function.update g a y) x - hamiltonian α φ N g x| ≤ 2 * ‖φ‖ := by
  classical
  have heq : hamiltonian α φ N (Function.update g a y) x - hamiltonian α φ N g x =
      φ (patternField (Function.update g a y) a x) - φ (patternField g a x) := by
    unfold hamiltonian
    rw [← Finset.sum_sub_distrib]
    apply Finset.sum_eq_single a
    · intro b _ hba
      simp [patternField, Function.update_of_ne hba]
    · simp
  rw [heq]
  calc
    _ ≤ |φ (patternField (Function.update g a y) a x)| + |φ (patternField g a x)| :=
      abs_sub _ _
    _ ≤ ‖φ‖ + ‖φ‖ := add_le_add (φ.norm_coe_le_norm _) (φ.norm_coe_le_norm _)
    _ = _ := by ring

lemma abs_pressure_update_sub_le (α β : ℝ) (φ : ℝ →ᵇ ℝ) (N : ℕ)
    (g : Patterns α (N + 1)) (a : Fin (patternCount α (N + 1))) (y : Fin (N + 1) → ℝ) :
    |pressure α β φ (N + 1) (Function.update g a y) - pressure α β φ (N + 1) g| ≤
      (2 * |β| * ‖φ‖) / (N + 1 : ℝ) := by
  have hh := abs_log_integral_exp_sub_le (sphereLaw (N + 1))
    (integrable_partition α β φ N (Function.update g a y)) (integrable_partition α β φ N g)
    (partition_pos α β φ N (Function.update g a y)) (partition_pos α β φ N g)
    (c := 2 * |β| * ‖φ‖) (fun x => by
      rw [← mul_sub, abs_mul]
      calc
        _ ≤ |β| * (2 * ‖φ‖) := mul_le_mul_of_nonneg_left
          (abs_hamiltonian_update_sub_le α φ (N + 1) g a y x) (abs_nonneg β)
        _ = _ := by ring)
  unfold pressure
  rw [← sub_div, abs_div, abs_of_nonneg (show 0 ≤ ((N + 1 : ℕ) : ℝ) by positivity)]
  simpa only [Nat.cast_add, Nat.cast_one] using div_le_div_of_nonneg_right hh
    (show 0 ≤ (N + 1 : ℝ) by positivity)

lemma variance_pressure_le (α β : ℝ) (φ : ℝ →ᵇ ℝ) (N : ℕ) :
    variance (pressure α β φ (N + 1)) (patternLaw α (N + 1)) ≤
      (patternCount α (N + 1) : ℝ) * ((2 * |β| * ‖φ‖) / (N + 1 : ℝ)) ^ 2 := by
  exact variance_pi_le_of_bounded_differences (Measure.pi fun _ : Fin (N + 1) => gaussianReal 0 1)
    (patternCount α (N + 1)) (continuous_pressure α β φ N)
    (abs_pressure_le α β φ N) (abs_pressure_update_sub_le α β φ N)

lemma variance_pressure_le_rate (α β : ℝ) (hα : 0 ≤ α) (φ : ℝ →ᵇ ℝ) (N : ℕ) :
    variance (pressure α β φ (N + 1)) (patternLaw α (N + 1)) ≤
      α * (2 * |β| * ‖φ‖) ^ 2 / (N + 1 : ℝ) := by
  have hM : (patternCount α (N + 1) : ℝ) ≤ α * (N + 1 : ℝ) := by
    simpa [patternCount] using Nat.floor_le
      (mul_nonneg hα (show 0 ≤ ((N + 1 : ℕ) : ℝ) by positivity))
  calc
    _ ≤ (patternCount α (N + 1) : ℝ) * ((2 * |β| * ‖φ‖) / (N + 1 : ℝ)) ^ 2 :=
      variance_pressure_le α β φ N
    _ ≤ (α * (N + 1 : ℝ)) * ((2 * |β| * ‖φ‖) / (N + 1 : ℝ)) ^ 2 :=
      mul_le_mul_of_nonneg_right hM (sq_nonneg _)
    _ = _ := by
      have hn : (N + 1 : ℝ) ≠ 0 := by positivity
      field_simp

lemma pressure_deviation_le (α β : ℝ) (hα : 0 ≤ α) (φ : ℝ →ᵇ ℝ)
    (N : ℕ) (ε : ℝ) (hε : 0 < ε) :
    patternLaw α (N + 1)
      {g | ε < |pressure α β φ (N + 1) g - expectedPressure α β φ (N + 1)|} ≤
    ENNReal.ofReal ((α * (2 * |β| * ‖φ‖) ^ 2 / (N + 1 : ℝ)) / ε ^ 2) := by
  have : IsProbabilityMeasure (patternLaw α (N + 1)) := by
    unfold patternLaw
    infer_instance
  have hp : MemLp (pressure α β φ (N + 1)) 2 (patternLaw α (N + 1)) :=
    MemLp.of_bound (continuous_pressure α β φ N).aestronglyMeasurable _
      (Filter.Eventually.of_forall (abs_pressure_le α β φ N))
  calc
    _ ≤ patternLaw α (N + 1)
        {g | ε ≤ |pressure α β φ (N + 1) g - expectedPressure α β φ (N + 1)|} :=
      by
        apply measure_mono
        intro g hg
        change ε < |pressure α β φ (N + 1) g - expectedPressure α β φ (N + 1)| at hg
        change ε ≤ |pressure α β φ (N + 1) g - expectedPressure α β φ (N + 1)|
        exact le_of_lt hg
    _ ≤ ENNReal.ofReal (variance (pressure α β φ (N + 1)) (patternLaw α (N + 1)) / ε ^ 2) :=
      meas_ge_le_variance_div_sq hp hε
    _ ≤ _ := ENNReal.ofReal_le_ofReal (div_le_div_of_nonneg_right
      (variance_pressure_le_rate α β hα φ N) (sq_nonneg _))

theorem pressure_concentrates (α β : ℝ) (hα : 0 ≤ α) (φ : ℝ →ᵇ ℝ)
    (ε : ℝ) (hε : 0 < ε) :
    Tendsto (fun N : ℕ => patternLaw α (N + 1)
      {g | ε < |pressure α β φ (N + 1) g - expectedPressure α β φ (N + 1)|})
      atTop (𝓝 0) := by
  have hr : Tendsto (fun N : ℕ =>
      (α * (2 * |β| * ‖φ‖) ^ 2 / (N + 1 : ℝ)) / ε ^ 2) atTop (𝓝 0) := by
    simpa only [div_eq_mul_inv, one_mul, mul_zero, zero_mul] using
      (tendsto_const_nhds.mul (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ))).div_const
        (ε ^ 2)
  have he := ENNReal.tendsto_ofReal hr
  simp only [ENNReal.ofReal_zero] at he
  exact tendsto_of_tendsto_of_tendsto_of_le_of_le tendsto_const_nhds he
    (fun _ => bot_le) (fun N => pressure_deviation_le α β hα φ N ε hε)

theorem pressure_probability_of_expected_limit (α β : ℝ) (hα : 0 ≤ α)
    (φ : ℝ →ᵇ ℝ) (p : ℝ)
    (hp : Tendsto (fun N : ℕ => expectedPressure α β φ (N+1)) atTop (𝓝 p))
    (ε : ℝ) (hε : 0 < ε) :
    Tendsto (fun N : ℕ => patternLaw α (N+1)
      {g | ε < |pressure α β φ (N+1) g - p|}) atTop (𝓝 0) := by
  have he : ∀ᶠ N in atTop, |expectedPressure α β φ (N+1) - p| < ε/2 := by
    simpa only [Real.dist_eq] using (Metric.tendsto_nhds.mp hp (ε/2) (by positivity))
  apply tendsto_of_tendsto_of_tendsto_of_le_of_le' tendsto_const_nhds
    (pressure_concentrates α β hα φ (ε/2) (by positivity))
  · exact Filter.Eventually.of_forall fun _ => bot_le
  · filter_upwards [he] with N hN
    apply measure_mono
    intro g hg
    change ε/2 < |pressure α β φ (N+1) g - expectedPressure α β φ (N+1)|
    change ε < |pressure α β φ (N+1) g - p| at hg
    have hh := abs_sub_le (pressure α β φ (N+1) g) (expectedPressure α β φ (N+1)) p
    linarith

lemma brownianEval_measurable (t : ℝ≥0) : Measurable (brownianEval t) :=
  (continuous_eval_const t).measurable

lemma usualBrownianSigma_le_completion (P : Measure BrownianPath) (t : Time) :
    usualBrownianSigma P t ≤
      (inferInstance : MeasurableSpace (NullMeasurableSpace BrownianPath P)) := by
  unfold usualBrownianSigma
  refine (iInf_le _ (⟨2, lt_of_le_of_lt t.property.2 (by norm_num)⟩ :
    {s : ℝ≥0 // (t : ℝ) < s})).trans ?_
  apply sup_le
  · apply iSup_le
    intro r
    exact (brownianEval_measurable r.val).comap_le.trans
      (fun _ hs => hs.nullMeasurableSet)
  · apply MeasurableSpace.generateFrom_le
    intro s hs
    exact NullMeasurableSet.of_null hs

lemma progressive_joint_complete (P : Measure BrownianPath)
    {v : Time → BrownianPath → ℝ} (hv : Progressive P v) :
    Measurable (fun p : Time × NullMeasurableSpace BrownianPath P => v p.1 p.2) := by
  have h := (hv 1).mono (show MeasurableSpace.prod inferInstance (usualBrownianSigma P 1) ≤
      MeasurableSpace.prod inferInstance
        (inferInstance : MeasurableSpace (NullMeasurableSpace BrownianPath P)) from
      sup_le_sup le_rfl (MeasurableSpace.comap_mono (usualBrownianSigma_le_completion P 1))) le_rfl
  have hf : Measurable (fun p : Time × NullMeasurableSpace BrownianPath P =>
      (⟨p.1, p.1.property.2⟩ : Set.Iic (1 : Time))) := measurable_fst.subtype_mk
  exact h.comp (hf.prodMk measurable_snd)

lemma progressive_time_measurable (P : Measure BrownianPath)
    {v : Time → BrownianPath → ℝ} (hv : Progressive P v) (ω : BrownianPath) :
    Measurable (fun t : Time => v t ω) :=
  (progressive_joint_complete P hv).comp (measurable_id.prodMk measurable_const)

lemma drift_sq_le_cost (m : Trial) (v : Time → ℝ) (hv : Measurable v)
    (hc : (∫⁻ t, ENNReal.ofReal (m t * v t ^ 2) ∂timeLaw) < ∞) :
    (∫ t, m t * v t ∂timeLaw) ^ 2 ≤
      (∫⁻ t, ENNReal.ofReal (m t * v t ^ 2) ∂timeLaw).toReal := by
  have hm : Integrable m timeLaw :=
    (integrable_const (1 : ℝ)).mono' m.measurable.aestronglyMeasurable
      (Filter.Eventually.of_forall fun t => by simpa [abs_of_nonneg (m.nonneg t)] using m.le_one t)
  have hq : Integrable (fun t => m t * v t ^ 2) timeLaw :=
    ⟨(m.measurable.mul (hv.pow_const 2)).aestronglyMeasurable,
      (hasFiniteIntegral_iff_ofReal (Filter.Eventually.of_forall fun t =>
        mul_nonneg (m.nonneg t) (sq_nonneg _))).mpr hc⟩
  have hi : Integrable (fun t => m t * v t) timeLaw := by
    apply (hq.add hm).mono' (m.measurable.mul hv).aestronglyMeasurable
    apply Filter.Eventually.of_forall
    intro t
    change |m t * v t| ≤ m t * v t ^ 2 + m t
    rw [abs_mul, abs_of_nonneg (m.nonneg t)]
    have h := sq_nonneg (|v t| - 1)
    have habs : |v t| ≤ v t ^ 2 + 1 := by nlinarith [sq_abs (v t)]
    calc
      _ ≤ m t * (v t ^ 2 + 1) := mul_le_mul_of_nonneg_left habs (m.nonneg t)
      _ = _ := by ring
  let D := ∫ t, m t * v t ∂timeLaw
  have hnon : 0 ≤ ∫ t, (m t * v t ^ 2 - 2 * D * (m t * v t) + D^2 * m t) ∂timeLaw := by
    apply integral_nonneg
    intro t
    change 0 ≤ m t * v t ^ 2 - 2 * D * (m t * v t) + D^2 * m t
    nlinarith [mul_nonneg (m.nonneg t) (sq_nonneg (v t - D))]
  have hs : Integrable (fun t => m t * v t ^ 2 - 2 * D * (m t * v t)) timeLaw :=
    hq.sub (hi.const_mul (2*D))
  rw [integral_add hs (hm.const_mul (D^2)),
    integral_sub hq (hi.const_mul (2*D)), integral_const_mul, integral_const_mul] at hnon
  have hmone : (∫ t, m t ∂timeLaw) ≤ 1 := by
    calc
      _ ≤ ∫ _ : Time, (1 : ℝ) ∂timeLaw := integral_mono hm (integrable_const _) m.le_one
      _ = _ := by simp
  rw [← integral_eq_lintegral_of_nonneg_ae
    (Filter.Eventually.of_forall fun t => mul_nonneg (m.nonneg t) (sq_nonneg _))
    hq.aestronglyMeasurable]
  change D ^ 2 ≤ _
  nlinarith [mul_le_mul_of_nonneg_left hmone (sq_nonneg D)]

def controlDrift (m : Trial) (v : Time → BrownianPath → ℝ) (ω : BrownianPath) : ℝ :=
  ∫ t, m t * v t ω ∂timeLaw

def pathControlCost (m : Trial) (v : Time → BrownianPath → ℝ) (ω : BrownianPath) : ℝ≥0∞ :=
  ∫⁻ t, ENNReal.ofReal (m t * v t ω ^ 2) ∂timeLaw

lemma controlDrift_aemeasurable (P : Measure BrownianPath) (m : Trial)
    {v : Time → BrownianPath → ℝ} (hv : Progressive P v) :
    AEMeasurable (controlDrift m v) P := by
  have h : Measurable (fun ω : NullMeasurableSpace BrownianPath P => controlDrift m v ω) :=
    ((m.measurable.comp measurable_fst).mul
      (progressive_joint_complete P hv)).stronglyMeasurable.integral_prod_left'.measurable
  exact (show NullMeasurable (controlDrift m v) P from h).aemeasurable

lemma pathControlCost_aemeasurable (P : Measure BrownianPath) (m : Trial)
    {v : Time → BrownianPath → ℝ} (hv : Progressive P v) :
    AEMeasurable (pathControlCost m v) P := by
  have h : Measurable (fun ω : NullMeasurableSpace BrownianPath P => pathControlCost m v ω) :=
    ((m.measurable.comp measurable_fst).mul
      ((progressive_joint_complete P hv).pow_const 2)).ennreal_ofReal.lintegral_prod_left'
  exact (show NullMeasurable (pathControlCost m v) P from h).aemeasurable

lemma controlDrift_sq_integrable (P : Measure BrownianPath) (m : Trial)
    {v : Time → BrownianPath → ℝ} (hv : Progressive P v)
    (hc : controlCost P m v < ∞) :
    Integrable (fun ω => controlDrift m v ω ^ 2) P := by
  have hm := pathControlCost_aemeasurable P m hv
  have hfin : ∀ᵐ ω ∂P, pathControlCost m v ω < ∞ := ae_lt_top' hm hc.ne
  apply (integrable_toReal_of_lintegral_ne_top hm hc.ne).mono'
    ((controlDrift_aemeasurable P m hv).pow_const 2).aestronglyMeasurable
  filter_upwards [hfin] with ω hω
  rw [Real.norm_eq_abs, abs_of_nonneg (sq_nonneg _)]
  exact drift_sq_le_cost m (fun t => v t ω) (progressive_time_measurable P hv ω) hω

lemma integral_controlDrift_sq_le (P : Measure BrownianPath) (m : Trial)
    {v : Time → BrownianPath → ℝ} (hv : Progressive P v)
    (hc : controlCost P m v < ∞) :
    (∫ ω, controlDrift m v ω ^ 2 ∂P) ≤ (controlCost P m v).toReal := by
  have hm := pathControlCost_aemeasurable P m hv
  have hfin : ∀ᵐ ω ∂P, pathControlCost m v ω < ∞ := ae_lt_top' hm hc.ne
  calc
    _ ≤ ∫ ω, (pathControlCost m v ω).toReal ∂P := by
      apply integral_mono_ae (controlDrift_sq_integrable P m hv hc)
        (integrable_toReal_of_lintegral_ne_top hm hc.ne)
      filter_upwards [hfin] with ω hω
      exact drift_sq_le_cost m (fun t => v t ω) (progressive_time_measurable P hv ω) hω
    _ = _ := integral_toReal hm hfin

lemma brownianEval_one_sq_integral (P : Measure BrownianPath) [IsProbabilityMeasure P]
    (hB : IsBrownianReal brownianEval P) : (∫ ω, brownianEval 1 ω ^ 2 ∂P) = 1 := by
  have hm := (hB.isGaussianProcess.hasGaussianLaw_eval 1).memLp_two
  have h := hB.covariance_eval 1 1
  rw [covariance_eq_sub hm hm, hB.integral_eval, zero_mul, sub_zero] at h
  simpa only [sq, min_self, NNReal.coe_one, Pi.mul_apply] using h

lemma controlledTerminal_sq_integral_le (P : Measure BrownianPath) [IsProbabilityMeasure P]
    (hB : IsBrownianReal brownianEval P) (m : Trial)
    {v : Time → BrownianPath → ℝ} (hv : Progressive P v)
    (hc : controlCost P m v < ∞) :
    (∫ ω, (brownianEval 1 ω + controlDrift m v ω)^2 ∂P) ≤
      2 + 2 * (controlCost P m v).toReal := by
  have hb := (hB.isGaussianProcess.hasGaussianLaw_eval 1).memLp_two
  have hd := (memLp_two_iff_integrable_sq
    (controlDrift_aemeasurable P m hv).aestronglyMeasurable).mpr
    (controlDrift_sq_integrable P m hv hc)
  calc
    _ ≤ ∫ ω, (2 * brownianEval 1 ω ^ 2 + 2 * controlDrift m v ω ^ 2) ∂P := by
      apply integral_mono (hb.add hd).integrable_sq
        ((hb.integrable_sq.const_mul 2).add (hd.integrable_sq.const_mul 2))
      intro ω
      change (brownianEval 1 ω + controlDrift m v ω)^2 ≤
        2 * brownianEval 1 ω ^ 2 + 2 * controlDrift m v ω ^ 2
      nlinarith [sq_nonneg (brownianEval 1 ω - controlDrift m v ω)]
    _ = 2 + 2 * ∫ ω, controlDrift m v ω ^ 2 ∂P := by
      rw [integral_add (hb.integrable_sq.const_mul 2) (hd.integrable_sq.const_mul 2),
        integral_const_mul, integral_const_mul, brownianEval_one_sq_integral P hB]
      ring
    _ ≤ _ := by linarith [integral_controlDrift_sq_le P m hv hc]

lemma controlledTerminal_aemeasurable (P : Measure BrownianPath) (m : Trial)
    {v : Time → BrownianPath → ℝ} (hv : Progressive P v) :
    AEMeasurable (fun ω => brownianEval 1 ω + controlDrift m v ω) P :=
  (brownianEval_measurable 1).aemeasurable.add (controlDrift_aemeasurable P m hv)

lemma controlReward_integrable (P : Measure BrownianPath) [IsProbabilityMeasure P]
    (f : ℝ →ᵇ ℝ) (m : Trial) {v : Time → BrownianPath → ℝ}
    (hv : Progressive P v) :
    Integrable (fun ω => f (brownianEval 1 ω + controlDrift m v ω)) P := by
  apply (integrable_const ‖f‖).mono'
    (f.continuous.measurable.comp_aemeasurable
      (controlledTerminal_aemeasurable P m hv)).aestronglyMeasurable
  exact Filter.Eventually.of_forall fun ω => f.norm_coe_le_norm _

lemma controlPayoff_compact_bound (P : Measure BrownianPath) [IsProbabilityMeasure P]
    (hB : IsBrownianReal brownianEval P) (f g : ℝ →ᵇ ℝ)
    (K R ε : ℝ) (hK : 0 ≤ K) (hR : 0 < R) (hε : 0 ≤ ε)
    (hf : ‖f‖ ≤ K) (hg : ‖g‖ ≤ K)
    (hnear : ∀ x : ℝ, |x| ≤ R → |f x - g x| ≤ ε)
    (m : Trial) {v : Time → BrownianPath → ℝ} (hv : Progressive P v)
    (hc : controlCost P m v < ∞) :
    |controlPayoff P f m v - controlPayoff P g m v| ≤
      ε + (2 * K / R^2) * (2 + 2 * (controlCost P m v).toReal) := by
  let X := fun ω => brownianEval 1 ω + controlDrift m v ω
  have hfI := controlReward_integrable P f m hv
  have hgI := controlReward_integrable P g m hv
  have hX : Integrable (fun ω => X ω ^ 2) P := by
    have hb := (hB.isGaussianProcess.hasGaussianLaw_eval 1).memLp_two
    have hd := (memLp_two_iff_integrable_sq
      (controlDrift_aemeasurable P m hv).aestronglyMeasurable).mpr
      (controlDrift_sq_integrable P m hv hc)
    exact (hb.add hd).integrable_sq
  have hconst : 0 ≤ 2 * K / R ^ 2 := div_nonneg (by positivity) (sq_nonneg _)
  have hbound (x : ℝ) : |f x - g x| ≤ ε + (2*K/R^2)*x^2 := by
    by_cases hx : |x| ≤ R
    · exact (hnear x hx).trans (le_add_of_nonneg_right (mul_nonneg hconst (sq_nonneg _)))
    · have habs : |f x - g x| ≤ 2*K := by
        calc
          _ ≤ |f x| + |g x| := abs_sub _ _
          _ ≤ K + K := add_le_add ((f.norm_coe_le_norm x).trans hf)
            ((g.norm_coe_le_norm x).trans hg)
          _ = _ := by ring
      have hsq : R^2 ≤ x^2 := by nlinarith [sq_abs x, lt_of_not_ge hx]
      have hr : R^2 ≠ 0 := ne_of_gt (sq_pos_of_pos hR)
      have heq : (2*K/R^2)*R^2 = 2*K := div_mul_cancel₀ _ hr
      have hb := mul_le_mul_of_nonneg_left hsq hconst
      rw [heq] at hb
      exact habs.trans (hb.trans (le_add_of_nonneg_left hε))
  have heq : controlPayoff P f m v - controlPayoff P g m v =
      ∫ ω, (f (X ω) - g (X ω)) ∂P := by
    rw [integral_sub hfI hgI]
    unfold controlPayoff controlDrift
    ring
  rw [heq]
  calc
    _ ≤ ∫ ω, |f (X ω) - g (X ω)| ∂P := abs_integral_le_integral_abs
    _ ≤ ∫ ω, (ε + (2*K/R^2)*X ω^2) ∂P :=
      integral_mono (hfI.sub hgI).abs ((integrable_const ε).add (hX.const_mul _))
        (fun ω => hbound (X ω))
    _ = ε + (2*K/R^2) * ∫ ω, X ω^2 ∂P := by
      rw [integral_add (integrable_const ε) (hX.const_mul _), integral_const_mul]
      simp
    _ ≤ _ := add_le_add le_rfl (mul_le_mul_of_nonneg_left
      (controlledTerminal_sq_integral_le P hB m hv hc) hconst)

lemma controlValue_le_of_cost_cutoff (P : Measure BrownianPath) [IsProbabilityMeasure P]
    (f : ℝ →ᵇ ℝ) (m : Trial) (K b : ℝ) (hf : ‖f‖ ≤ K)
    (hb : -K ≤ b)
    (hsmall : ∀ v : Time → BrownianPath → ℝ, Progressive P v →
      controlCost P m v < ∞ → (controlCost P m v).toReal ≤ 4*K+2 →
      controlPayoff P f m v ≤ b) : controlValue P f m ≤ b := by
  apply csSup_le (controlPayoffs_nonempty P f m)
  rintro a ⟨v, hv, hc, rfl⟩
  by_cases hcost : (controlCost P m v).toReal ≤ 4*K+2
  · exact hsmall v hv hc hcost
  · have hr := (abs_le.mp (abs_integral_reward_le P f
      (fun ω => brownianEval 1 ω + ∫ t, m t * v t ω ∂timeLaw))).2
    unfold controlPayoff
    linarith [lt_of_not_ge hcost]

lemma controlValue_compact_bound (P : Measure BrownianPath) [IsProbabilityMeasure P]
    (hB : IsBrownianReal brownianEval P) (f g : ℝ →ᵇ ℝ)
    (K R ε : ℝ) (hK : 0 ≤ K) (hR : 0 < R) (hε : 0 ≤ ε)
    (hf : ‖f‖ ≤ K) (hg : ‖g‖ ≤ K)
    (hnear : ∀ x : ℝ, |x| ≤ R → |f x - g x| ≤ ε)
    (m : Trial) :
    |controlValue P f m - controlValue P g m| ≤
      ε + (2 * K / R^2) * (2 + 2 * (4*K+2)) := by
  let δ := ε + (2*K/R^2)*(2+2*(4*K+2))
  have hδ : 0 ≤ δ := by dsimp [δ]; positivity
  have hfg : controlValue P f m ≤ controlValue P g m + δ := by
    apply controlValue_le_of_cost_cutoff P f m K _ hf
    · linarith [neg_norm_le_controlValue P g m]
    · intro v hv hc hcost
      have hd := (abs_le.mp (controlPayoff_compact_bound P hB f g K R ε hK hR hε
        hf hg hnear m hv hc)).2
      have hp : controlPayoff P g m v ≤ controlValue P g m :=
        le_csSup (controlPayoffs_bddAbove P g m) ⟨v, hv, hc, rfl⟩
      have hh : ε + (2*K/R^2)*(2+2*(controlCost P m v).toReal) ≤ δ := by
        dsimp [δ]
        apply add_le_add le_rfl
        apply mul_le_mul_of_nonneg_left _ (by positivity)
        linarith
      linarith
  have hgf : controlValue P g m ≤ controlValue P f m + δ := by
    apply controlValue_le_of_cost_cutoff P g m K _ hg
    · linarith [neg_norm_le_controlValue P f m]
    · intro v hv hc hcost
      have hd := (abs_le.mp (controlPayoff_compact_bound P hB f g K R ε hK hR hε
        hf hg hnear m hv hc)).1
      have hp : controlPayoff P f m v ≤ controlValue P f m :=
        le_csSup (controlPayoffs_bddAbove P f m) ⟨v, hv, hc, rfl⟩
      have hh : ε + (2*K/R^2)*(2+2*(controlCost P m v).toReal) ≤ δ := by
        dsimp [δ]
        apply add_le_add le_rfl
        apply mul_le_mul_of_nonneg_left _ (by positivity)
        linarith
      linarith
  exact abs_le.mpr ⟨by linarith, by linarith⟩

lemma controlValue_uniform_of_compact (P : Measure BrownianPath) [IsProbabilityMeasure P]
    (hB : IsBrownianReal brownianEval P) (f : ℝ →ᵇ ℝ) (fseq : ℕ → ℝ →ᵇ ℝ)
    (K : ℝ) (hK : 0 ≤ K) (hf : ‖f‖ ≤ K) (hseq : ∀ n, ‖fseq n‖ ≤ K)
    (hcomp : ∀ R : ℝ, 0 < R → ∀ ε : ℝ, 0 < ε →
      ∃ N : ℕ, ∀ n ≥ N, ∀ x : ℝ, |x| ≤ R → |fseq n x - f x| ≤ ε) :
    ∀ ε : ℝ, 0 < ε → ∃ N : ℕ, ∀ n ≥ N, ∀ m : Trial,
      |controlValue P (fseq n) m - controlValue P f m| < ε := by
  intro ε hε
  let C := 2*K*(2+2*(4*K+2))
  have hC : 0 ≤ C := by dsimp [C]; positivity
  let Q := C / (ε/2)
  have hQ : 0 ≤ Q := div_nonneg hC (by positivity)
  let R := Q+1
  have hR : 0 < R := by dsimp [R]; positivity
  have hQR : Q < R^2 := by dsimp [R]; nlinarith [sq_nonneg Q]
  have hCQ : C = (ε/2)*Q := by dsimp [Q]; field_simp
  have htail : C/R^2 < ε/2 := by
    apply (div_lt_iff₀ (sq_pos_of_pos hR)).mpr
    rw [hCQ]
    exact mul_lt_mul_of_pos_left hQR (by positivity)
  obtain ⟨N,hN⟩ := hcomp R hR (ε/2) (by positivity)
  refine ⟨N, fun n hn m => ?_⟩
  have hb := controlValue_compact_bound P hB (fseq n) f K R (ε/2) hK hR
    (by positivity) (hseq n) hf (hN n hn) m
  have heq : (2*K/R^2)*(2+2*(4*K+2)) = C/R^2 := by dsimp [C]; ring
  rw [heq] at hb
  linarith

end SphericalPerceptronFreeEnergy
end

end OAI