import Mathlib
import OAI.Probability.Perceptron.Sphere.SphereKernel

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]

def weightedCDF (μ : Measure Time) (a : Time → ℝ) (x : ℝ) : ℝ :=
  ∫ s in {s : Time | (s : ℝ) ≤ x}, a s ∂μ

lemma weightedCDF_fubini (μ : Measure Time) [IsFiniteMeasure μ]
    {a : Time → ℝ} (ha : Integrable a μ) {r : ℝ} (hr : 0 ≤ r) :
    IntervalIntegrable (weightedCDF μ a) volume 0 r ∧
    (∫ t in 0..r, weightedCDF μ a t) = ∫ s : Time, max (r - s) 0 * a s ∂μ := by
  let ν : Measure ℝ := volume.restrict (Icc 0 r)
  have hmeas : MeasurableSet {p : ℝ × Time | (p.2 : ℝ) ≤ p.1} :=
    measurableSet_le (by fun_prop) measurable_fst
  have hbase : Integrable (fun p : ℝ × Time => a p.2) (ν.prod μ) := by
    simpa using (integrable_const (1 : ℝ) (μ := ν)).mul_prod ha
  have hi := hbase.indicator hmeas
  have hleft (t : ℝ) :
      (∫ s : Time, {p : ℝ × Time | (p.2 : ℝ) ≤ p.1}.indicator
        (fun p => a p.2) (t, s) ∂μ) = weightedCDF μ a t := by
    change (∫ s : Time, {s : Time | (s : ℝ) ≤ t}.indicator a s ∂μ) = _
    rw [integral_indicator (measurableSet_le (by fun_prop) measurable_const)]
    rfl
  have hright (s : Time) :
      (∫ t, {p : ℝ × Time | (p.2 : ℝ) ≤ p.1}.indicator
        (fun p => a p.2) (t, s) ∂ν) = max (r - s) 0 * a s := by
    change (∫ t, (Ici (s : ℝ)).indicator (fun _ => a s) t ∂ν) = _
    rw [integral_indicator measurableSet_Ici]
    have hset : Icc 0 r ∩ Ici (s : ℝ) = Icc (s : ℝ) r := by
      ext t
      simp only [mem_inter_iff, mem_Icc, mem_Ici]
      constructor
      · intro h; exact ⟨h.2, h.1.2⟩
      · intro h; exact ⟨⟨s.property.1.trans h.1, h.2⟩, h.1⟩
    dsimp only [ν]
    rw [Measure.restrict_restrict measurableSet_Ici, inter_comm, hset,
      setIntegral_const]
    simp only [Measure.real, Real.volume_Icc, ENNReal.toReal_ofReal', smul_eq_mul]
  have hl : (∫ t, weightedCDF μ a t ∂ν) = ∫ t in 0..r, weightedCDF μ a t := by
    dsimp only [ν]
    rw [integral_Icc_eq_integral_Ioc, intervalIntegral.integral_of_le hr]
  constructor
  · apply (intervalIntegrable_iff_integrableOn_Icc_of_le hr).mpr
    have hi' : Integrable (weightedCDF μ a) ν := by
      simpa only [Function.uncurry_apply_pair, hleft] using hi.integral_prod_left
    change Integrable (weightedCDF μ a) ν
    exact hi'
  · have hs := integral_integral_swap (μ := ν) (ν := μ)
      (f := fun t s => {p : ℝ × Time | (p.2 : ℝ) ≤ p.1}.indicator (fun p => a p.2) (t,s)) hi
    simpa only [Function.uncurry_apply_pair, hleft, hright, hl] using hs

lemma realTail_inv_formula (μ : Measure Time) [IsProbabilityMeasure μ] {B r : ℝ}
    (hB : B < 1) (hμ : ∀ᵐ s : Time ∂μ, (s : ℝ) ≤ B) (hr : 0 ≤ r) (hrB : r ≤ B) :
    (realTail μ r)⁻¹ - (realTail μ 0)⁻¹ =
      realCDF μ r * cappedA μ B r - weightedCDF μ (fun s => cappedA μ B s) r := by
  rw [realTail_inv_integral μ hB hμ hr hrB,
    integral_cdf_mul μ hr ((cappedDensity_continuous μ hB).intervalIntegrable 0 r)]
  have hm : MeasurableSet {s : Time | (s : ℝ) ≤ r} :=
    measurableSet_le (by fun_prop) measurable_const
  have hA : Integrable (fun s : Time => cappedA μ B s) μ :=
    continuous_time_integrable μ ((cappedA_continuous μ hB).comp continuous_subtype_val)
  have he (s : Time) :
      (if (s : ℝ) ≤ r then ∫ t in (s : ℝ)..r, cappedDensity μ B t else 0) =
      {s : Time | (s : ℝ) ≤ r}.indicator (fun _ => cappedA μ B r) s -
      {s : Time | (s : ℝ) ≤ r}.indicator (fun s => cappedA μ B s) s := by
    by_cases hs : (s : ℝ) ≤ r
    · simp only [hs, ite_true, mem_ofPred_eq, indicator_of_mem]
      have h := intervalIntegral.integral_add_adjacent_intervals
        ((cappedDensity_continuous μ hB).intervalIntegrable (μ := volume) 0 (s : ℝ))
        ((cappedDensity_continuous μ hB).intervalIntegrable (μ := volume) (s : ℝ) r)
      change _ = _ - _
      exact eq_sub_of_add_eq' h
    · simp [hs]
  simp_rw [he]
  rw [integral_sub ((integrable_const _).indicator hm) (hA.indicator hm),
    integral_indicator_const _ hm, integral_indicator hm]
  rfl

@[simp] lemma cappedA_zero (μ : Measure Time) (B : ℝ) : cappedA μ B 0 = 0 := by
  simp [cappedA]

lemma realTail_mul_A (μ : Measure Time) [IsProbabilityMeasure μ] {B r : ℝ}
    (hB : B < 1) (hμ : ∀ᵐ s : Time ∂μ, (s : ℝ) ≤ B) (hr : 0 ≤ r) (hrB : r ≤ B) :
    realTail μ r * cappedA μ B r = r * (realTail μ 0)⁻¹ -
      ∫ s : Time, max (r - s) 0 * cappedA μ B s ∂μ := by
  have hA := cappedA_continuous μ hB
  have hAi : Integrable (fun s : Time => cappedA μ B s) μ :=
    continuous_time_integrable μ (hA.comp continuous_subtype_val)
  have hG := weightedCDF_fubini μ hAi hr
  have hd (x : ℝ) (hx : x ∈ Ioo 0 r) :
      HasDerivWithinAt (fun t => realTail μ t * cappedA μ B t)
        ((realTail μ 0)⁻¹ - weightedCDF μ (fun s => cappedA μ B s) x) (Ioi x) x := by
    have hn : realTail μ x ≠ 0 :=
      ne_of_gt ((sub_pos.mpr hB).trans_le (realTail_lower μ hμ (hx.2.le.trans hrB)))
    have he := realTail_inv_formula μ hB hμ hx.1.le (hx.2.le.trans hrB)
    have hp := (realTail_right_derivative μ x).mul (cappedA_hasDerivAt μ hB x).hasDerivWithinAt
    convert! hp using 1
    rw [cappedDensity_eq μ hμ (hx.2.le.trans hrB)]
    have hm : realTail μ x * ((realTail μ x)⁻¹ ^ 2) = (realTail μ x)⁻¹ := by
      field_simp
    rw [hm]
    linarith
  have h := intervalIntegral.integral_eq_sub_of_hasDeriv_right_of_le
    (f := fun t => realTail μ t * cappedA μ B t)
    (f' := fun t => (realTail μ 0)⁻¹ - weightedCDF μ (fun s => cappedA μ B s) t)
    hr ((realTail_continuous μ).mul hA).continuousOn hd
    (intervalIntegrable_const.sub hG.1)
  rw [intervalIntegral.integral_sub (f := fun _ => (realTail μ 0)⁻¹)
    intervalIntegrable_const hG.1, hG.2] at h
  simpa using h.symm

lemma realTail_at_top (μ : Measure Time) [IsProbabilityMeasure μ] {B : ℝ}
    (hμ : ∀ᵐ s : Time ∂μ, (s : ℝ) ≤ B) : realTail μ B = 1 - B := by
  calc
    _ = ∫ _ : Time, 1 - B ∂μ := integral_congr_ae (by
      filter_upwards [hμ] with s hs
      rw [max_eq_left hs])
    _ = _ := by simp

lemma realCDF_at_top (μ : Measure Time) [IsProbabilityMeasure μ] {B : ℝ}
    (hμ : ∀ᵐ s : Time ∂μ, (s : ℝ) ≤ B) : realCDF μ B = 1 := by
  unfold realCDF Measure.real
  have h : {s : Time | (s : ℝ) ≤ B} =ᵐ[μ] univ := by
    filter_upwards [hμ] with s hs
    change ((s : ℝ) ≤ B) = True
    simp [hs]
  rw [measure_congr h]
  simp

lemma weightedCDF_at_top (μ : Measure Time) {B : ℝ}
    (hμ : ∀ᵐ s : Time ∂μ, (s : ℝ) ≤ B) (a : Time → ℝ) :
    weightedCDF μ a B = ∫ s, a s ∂μ := by
  unfold weightedCDF
  have h : {s : Time | (s : ℝ) ≤ B} =ᵐ[μ] univ := by
    filter_upwards [hμ] with s hs
    change ((s : ℝ) ≤ B) = True
    simp [hs]
  rw [setIntegral_congr_set h, setIntegral_univ]

lemma realTail_inv_zero_formula (μ : Measure Time) [IsProbabilityMeasure μ] {B : ℝ}
    (hB : B < 1) (hB0 : 0 ≤ B) (hμ : ∀ᵐ s : Time ∂μ, (s : ℝ) ≤ B) :
    (realTail μ 0)⁻¹ = 1 + ∫ s : Time, (1 - (s : ℝ)) * cappedA μ B s ∂μ := by
  have hA : Continuous (fun s : Time => cappedA μ B s) :=
    (cappedA_continuous μ hB).comp continuous_subtype_val
  have hAi := continuous_time_integrable μ hA
  have hSAi : Integrable (fun s : Time => (s : ℝ) * cappedA μ B s) μ :=
    continuous_time_integrable μ (continuous_subtype_val.mul hA)
  have htop := realTail_inv_formula μ hB hμ hB0 le_rfl
  rw [realTail_at_top μ hμ, realCDF_at_top μ hμ, one_mul,
    weightedCDF_at_top μ hμ] at htop
  have hproduct := realTail_mul_A μ hB hμ hB0 le_rfl
  rw [realTail_at_top μ hμ] at hproduct
  have hi : (∫ s : Time, max (B - s) 0 * cappedA μ B s ∂μ) =
      B * (∫ s : Time, cappedA μ B s ∂μ) - ∫ s : Time, (s : ℝ) * cappedA μ B s ∂μ := by
    calc
      _ = ∫ s : Time, B * cappedA μ B s - (s : ℝ) * cappedA μ B s ∂μ :=
        integral_congr_ae (by
          filter_upwards [hμ] with s hs
          rw [max_eq_left (sub_nonneg.mpr hs)]
          ring)
      _ = _ := by rw [integral_sub (hAi.const_mul B) hSAi, integral_const_mul]
  rw [hi] at hproduct
  have hc : (realTail μ 0)⁻¹ = 1 + (∫ s : Time, cappedA μ B s ∂μ) -
      ∫ s : Time, (s : ℝ) * cappedA μ B s ∂μ := by
    have htop' := congrArg (fun z : ℝ => (1 - B) * z) htop
    have hinv : (1 - B) * (1 - B)⁻¹ = 1 := mul_inv_cancel₀ (ne_of_gt (sub_pos.mpr hB))
    nlinarith
  rw [hc]
  have hi' : (∫ s : Time, (1 - (s : ℝ)) * cappedA μ B s ∂μ) =
      (∫ s : Time, cappedA μ B s ∂μ) - ∫ s : Time, (s : ℝ) * cappedA μ B s ∂μ := by
    simp_rw [sub_mul, one_mul]
    exact integral_sub hAi hSAi
  rw [hi']
  ring

theorem cappedA_sphere_equation (μ : Measure Time) [IsProbabilityMeasure μ] {B r : ℝ}
    (hB : B < 1) (hμ : ∀ᵐ s : Time ∂μ, (s : ℝ) ≤ B) (hr : 0 ≤ r) (hrB : r ≤ B) :
    cappedA μ B r * realTail μ r = r +
      ∫ s : Time, (min r (s : ℝ) - r * (s : ℝ)) * cappedA μ B s ∂μ := by
  have hA : Continuous (fun s : Time => cappedA μ B s) :=
    (cappedA_continuous μ hB).comp continuous_subtype_val
  have ht := realTail_mul_A μ hB hμ hr hrB
  rw [realTail_inv_zero_formula μ hB (hr.trans hrB) hμ] at ht
  have hk (s : Time) :
      (min r (s : ℝ) - r * (s : ℝ)) * cappedA μ B s =
      r * ((1 - (s : ℝ)) * cappedA μ B s) - max (r - s) 0 * cappedA μ B s := by
    rcases le_total r (s : ℝ) with hs | hs
    · rw [min_eq_left hs, max_eq_right (sub_nonpos.mpr hs)]
      ring
    · rw [min_eq_right hs, max_eq_left (sub_nonneg.mpr hs)]
      ring
  simp_rw [hk]
  rw [integral_sub (continuous_time_integrable μ (by fun_prop))
    (continuous_time_integrable μ (by fun_prop)), integral_const_mul]
  nlinarith [ht]

lemma cappedA_eq_integral (μ : Measure Time) [IsProbabilityMeasure μ] {B r : ℝ}
    (hμ : ∀ᵐ s : Time ∂μ, (s : ℝ) ≤ B) (hr : 0 ≤ r) (hrB : r ≤ B) :
    cappedA μ B r = ∫ t in 0..r, (realTail μ t)⁻¹ ^ 2 := by
  apply intervalIntegral.integral_congr
  intro x hx
  rw [uIcc_of_le hr] at hx
  exact cappedDensity_eq μ hμ (hx.2.trans hrB)

theorem sphere_self_consistency (μ : Measure Time) [IsProbabilityMeasure μ]
    {a : Time → ℝ} {A : ℝ} (hA : 0 ≤ A) (ha : AEStronglyMeasurable a μ)
    (haNonneg : ∀ᵐ r ∂μ, 0 ≤ a r) (haBound : ∀ᵐ r ∂μ, a r ≤ A)
    (haEq : ∀ᵐ r ∂μ, a r * sphereTail μ r = (r : ℝ) + ∫ s, sphereKernel r s * a s ∂μ) :
    (∀ᵐ r : Time ∂μ, a r = ∫ t in 0..(r : ℝ), (realTail μ t)⁻¹ ^ 2) ∧
      ∀ᵐ r : Time ∂μ, (r : ℝ) ≤ A / (1 + A) := by
  have hμ := sphere_equation_support_bound μ hA haNonneg haBound haEq
  have hB : A / (1 + A) < 1 := (div_lt_one (by linarith)).mpr (by linarith)
  let B := A / (1 + A)
  have hb : Continuous (fun s : Time => cappedA μ B s) :=
    (cappedA_continuous μ hB).comp continuous_subtype_val
  obtain ⟨C, hC⟩ := (isCompact_range hb.abs).bddAbove
  have hident := sphere_equation_unique μ hB hμ ha hb.aestronglyMeasurable
    ⟨A, by
      filter_upwards [haNonneg, haBound] with s hs hsA
      simpa only [abs_of_nonneg hs] using hsA⟩
    ⟨C, Eventually.of_forall fun s => hC (mem_range_self s)⟩ haEq
    (by
      filter_upwards [hμ] with r hr
      exact cappedA_sphere_equation μ hB hμ r.property.1 hr)
  refine ⟨?_, hμ⟩
  filter_upwards [hident, hμ] with r hr hrB
  rw [hr, cappedA_eq_integral μ hμ r.property.1 hrB]

def boundedCDF (μ : Measure Time) (r : Time) : ℝ := μ.real (Iic r)

lemma boundedCDF_eq (μ : Measure Time) [IsProbabilityMeasure μ] (r : Time) :
    boundedCDF μ r = cdf (μ.map fun s : Time => (s : ℝ)) r := by
  rw [cdf_eq_real, map_measureReal_apply measurable_subtype_coe measurableSet_Iic]
  rfl

lemma boundedCDF_monotone (μ : Measure Time) [IsProbabilityMeasure μ] :
    Monotone (boundedCDF μ) := by
  intro r s hrs
  exact measureReal_mono (Iic_subset_Iic.mpr hrs)

lemma boundedCDF_top (μ : Measure Time) [IsProbabilityMeasure μ] :
    boundedCDF μ 1 = 1 := by
  have h : Iic (1 : Time) = univ := by
    ext r
    simp only [mem_Iic, mem_univ, iff_true]
    exact r.property.2
  simp [boundedCDF, h]

lemma boundedCDF_nonneg (μ : Measure Time) (r : Time) : 0 ≤ boundedCDF μ r :=
  measureReal_nonneg

lemma boundedCDF_le_one (μ : Measure Time) [IsProbabilityMeasure μ] (r : Time) :
    boundedCDF μ r ≤ 1 := by
  rw [boundedCDF_eq]
  exact cdf_le_one _ _

lemma boundedCDF_right_continuous (μ : Measure Time) [IsProbabilityMeasure μ] (r : Time) :
    ContinuousWithinAt (boundedCDF μ) (Ici r) r := by
  have hc := (cdf (μ.map fun s : Time => (s : ℝ))).right_continuous (r : ℝ)
  have hmap : MapsTo (Subtype.val : Time → ℝ) (Ici r) (Ici (r : ℝ)) := fun _ hs => hs
  have hcomp := hc.comp continuous_subtype_val.continuousWithinAt hmap
  simpa only [Function.comp_def, ← boundedCDF_eq] using hcomp

def boundedQuantile (μ : Measure Time) (u : Time) : Time :=
  sInf {r : Time | (u : ℝ) ≤ boundedCDF μ r}

lemma boundedQuantile_le_iff (μ : Measure Time) [IsProbabilityMeasure μ] (u r : Time) :
    boundedQuantile μ u ≤ r ↔ (u : ℝ) ≤ boundedCDF μ r := by
  let A : Set Time := {r | (u : ℝ) ≤ boundedCDF μ r}
  have hA : A.Nonempty := ⟨1, by simpa [A, boundedCDF_top] using u.property.2⟩
  have hcont : ContinuousWithinAt (boundedCDF μ) A (sInf A) :=
    (boundedCDF_right_continuous μ _).mono (fun x hx => sInf_le hx)
  have hmin : (u : ℝ) ≤ boundedCDF μ (sInf A) := by
    rw [MonotoneOn.map_csInf_of_continuousWithinAt hcont ((boundedCDF_monotone μ).monotoneOn A) hA]
    apply le_csInf (hA.image _)
    rintro _ ⟨s, hs, rfl⟩
    exact hs
  constructor
  · intro h
    exact hmin.trans (boundedCDF_monotone μ h)
  · exact fun h => sInf_le h

lemma boundedQuantile_monotone (μ : Measure Time) [IsProbabilityMeasure μ] :
    Monotone (boundedQuantile μ) := by
  intro u v huv
  rw [boundedQuantile_le_iff]
  exact (show (u : ℝ) ≤ v from huv).trans ((boundedQuantile_le_iff μ v _).mp le_rfl)

lemma boundedQuantile_measurable (μ : Measure Time) [IsProbabilityMeasure μ] :
    Measurable (boundedQuantile μ) := (boundedQuantile_monotone μ).measurable

theorem boundedQuantile_law (μ : Measure Time) [IsProbabilityMeasure μ] :
    (volume : Measure Time).map (boundedQuantile μ) = μ := by
  apply Measure.ext_of_Iic
  intro r
  rw [Measure.map_apply (boundedQuantile_measurable μ) measurableSet_Iic]
  have hpre : boundedQuantile μ ⁻¹' Iic r =
      Iic (⟨boundedCDF μ r, boundedCDF_nonneg μ r, boundedCDF_le_one μ r⟩ : Time) := by
    ext u
    exact boundedQuantile_le_iff μ u r
  rw [hpre, unitInterval.volume_Iic]
  exact ENNReal.ofReal_toReal (measure_ne_top μ _)

lemma map_snd_restrict_prod (μ : Measure (Time × Time)) (s t : Set Time)
    (ht : MeasurableSet t) :
    ((μ.restrict (s ×ˢ univ)).map Prod.snd) t = μ (s ×ˢ t) := by
  rw [Measure.map_apply measurable_snd ht,
    Measure.restrict_apply (ht.preimage measurable_snd)]
  congr 1
  ext x
  simp only [mem_inter_iff, mem_preimage, mem_prod, mem_univ, and_true]
  exact and_comm

lemma map_fst_restrict_prod (μ : Measure (Time × Time)) (s t : Set Time)
    (hs : MeasurableSet s) :
    ((μ.restrict (univ ×ˢ t)).map Prod.fst) s = μ (s ×ˢ t) := by
  rw [Measure.map_apply measurable_fst hs,
    Measure.restrict_apply (hs.preimage measurable_fst)]
  congr 1
  ext x
  simp

lemma measure_prod_ext_Iic (μ ν : Measure (Time × Time)) [IsFiniteMeasure μ]
    [IsFiniteMeasure ν]
    (h : ∀ r t, μ (Iic r ×ˢ Iic t) = ν (Iic r ×ˢ Iic t)) : μ = ν := by
  have hrow (r : Time) : (μ.restrict (Iic r ×ˢ univ)).map Prod.snd =
      (ν.restrict (Iic r ×ˢ univ)).map Prod.snd := by
    apply Measure.ext_of_Iic
    intro t
    rw [map_snd_restrict_prod μ _ _ measurableSet_Iic,
      map_snd_restrict_prod ν _ _ measurableSet_Iic]
    exact h r t
  apply Measure.ext_prod
  intro s t hs ht
  have hcol : (μ.restrict (univ ×ˢ t)).map Prod.fst =
      (ν.restrict (univ ×ˢ t)).map Prod.fst := by
    apply Measure.ext_of_Iic
    intro r
    rw [map_fst_restrict_prod μ _ _ measurableSet_Iic,
      map_fst_restrict_prod ν _ _ measurableSet_Iic]
    have hr := congrArg (fun ζ : Measure Time => ζ t) (hrow r)
    simpa only [map_snd_restrict_prod μ _ _ ht, map_snd_restrict_prod ν _ _ ht] using hr
  have hc := congrArg (fun ζ : Measure Time => ζ s) hcol
  simpa only [map_fst_restrict_prod μ _ _ hs, map_fst_restrict_prod ν _ _ hs] using hc

theorem no_crossing_lower_orthant (μ : Measure (Time × Time))
    (hNo : ∀ r t : Time, μ (Iic r ×ˢ Ioi t) = 0 ∨ μ (Ioi r ×ˢ Iic t) = 0)
    (r t : Time) :
    μ (Iic r ×ˢ Iic t) = min (μ (Iic r ×ˢ univ)) (μ (univ ×ˢ Iic t)) := by
  have h₁ : Iic r ×ˢ univ ∩ univ ×ˢ Iic t = Iic r ×ˢ Iic t := by
    ext x
    simp only [mem_inter_iff, mem_prod, mem_Iic, mem_univ, and_true, true_and]
  have h₂ : (Iic r ×ˢ univ) \ (univ ×ˢ Iic t) = Iic r ×ˢ Ioi t := by ext x; simp
  have h₃ : (univ ×ˢ Iic t) \ (Iic r ×ˢ univ) = Ioi r ×ˢ Iic t := by ext x; simp [and_comm]
  have ha := measure_inter_add_sdiff (μ := μ) (t := univ ×ˢ Iic t) (Iic r ×ˢ univ)
    (MeasurableSet.univ.prod measurableSet_Iic)
  have hb := measure_inter_add_sdiff (μ := μ) (t := Iic r ×ˢ univ) (univ ×ˢ Iic t)
    (measurableSet_Iic.prod MeasurableSet.univ)
  rw [h₁, h₂] at ha
  rw [inter_comm, h₁, h₃] at hb
  rcases hNo r t with h | h
  · rw [h, add_zero] at ha
    rw [← ha, min_eq_left (measure_mono (by intro x hx; exact ⟨mem_univ _, hx.2⟩))]
  · rw [h, add_zero] at hb
    rw [← hb, min_eq_right (measure_mono (by intro x hx; exact ⟨hx.1, mem_univ _⟩))]

theorem no_crossing_quantile_coupling (μ : Measure (Time × Time)) [IsProbabilityMeasure μ]
    (hNo : ∀ r t : Time, μ (Iic r ×ˢ Ioi t) = 0 ∨ μ (Ioi r ×ˢ Iic t) = 0) :
    (volume : Measure Time).map
      (fun u => (boundedQuantile (μ.map Prod.fst) u, boundedQuantile (μ.map Prod.snd) u)) = μ := by
  apply measure_prod_ext_Iic
  intro r t
  rw [Measure.map_apply ((boundedQuantile_measurable _).prodMk (boundedQuantile_measurable _))
    (measurableSet_Iic.prod measurableSet_Iic), no_crossing_lower_orthant μ hNo]
  let a : Time := ⟨boundedCDF (μ.map Prod.fst) r,
    boundedCDF_nonneg _ _, boundedCDF_le_one _ _⟩
  let b : Time := ⟨boundedCDF (μ.map Prod.snd) t,
    boundedCDF_nonneg _ _, boundedCDF_le_one _ _⟩
  have hp : (fun u => (boundedQuantile (μ.map Prod.fst) u,
      boundedQuantile (μ.map Prod.snd) u)) ⁻¹' (Iic r ×ˢ Iic t) = Iic (min a b) := by
    ext u
    simp only [mem_preimage, mem_prod, mem_Iic, le_min_iff, boundedQuantile_le_iff]
    rfl
  rw [hp, unitInterval.volume_Iic]
  change ENNReal.ofReal (min (boundedCDF (μ.map Prod.fst) r)
    (boundedCDF (μ.map Prod.snd) t)) = _
  rw [ENNReal.ofReal_min, boundedCDF, boundedCDF, measureReal_def, measureReal_def,
    ENNReal.ofReal_toReal (measure_ne_top _ _), ENNReal.ofReal_toReal (measure_ne_top _ _),
    Measure.map_apply measurable_fst measurableSet_Iic,
    Measure.map_apply measurable_snd measurableSet_Iic]
  congr 2 <;> ext x <;> simp

theorem no_crossing_quantile_bin_integral (μ : Measure (Time × Time)) [IsProbabilityMeasure μ]
    (hNo : ∀ r t : Time, μ (Iic r ×ˢ Ioi t) = 0 ∨ μ (Ioi r ×ˢ Iic t) = 0)
    (a b : Time) :
    (∫ x in (univ ×ˢ Ioc a b), (x.1 : ℝ) ∂μ) =
      ∫ u in (Ioc (⟨boundedCDF (μ.map Prod.snd) a,
        boundedCDF_nonneg _ _, boundedCDF_le_one _ _⟩ : Time)
        (⟨boundedCDF (μ.map Prod.snd) b,
        boundedCDF_nonneg _ _, boundedCDF_le_one _ _⟩ : Time)),
        (boundedQuantile (μ.map Prod.fst) u : ℝ) := by
  let g : Time → Time × Time := fun u =>
    (boundedQuantile (μ.map Prod.fst) u, boundedQuantile (μ.map Prod.snd) u)
  have hg : Measurable g := (boundedQuantile_measurable _).prodMk (boundedQuantile_measurable _)
  have hmap : (volume : Measure Time).map g = μ := no_crossing_quantile_coupling μ hNo
  have hi := setIntegral_map (μ := (volume : Measure Time))
    (f := fun x : Time × Time => (x.1 : ℝ))
    (MeasurableSet.univ.prod (measurableSet_Ioc (a := a) (b := b)))
    (by fun_prop) hg.aemeasurable
  rw [hmap] at hi
  rw [hi]
  have hs : g ⁻¹' (univ ×ˢ Ioc a b) =
      Ioc (⟨boundedCDF (μ.map Prod.snd) a,
        boundedCDF_nonneg _ _, boundedCDF_le_one _ _⟩ : Time)
      (⟨boundedCDF (μ.map Prod.snd) b,
        boundedCDF_nonneg _ _, boundedCDF_le_one _ _⟩ : Time) := by
    ext u
    simp only [mem_preimage, g, mem_prod, mem_univ, true_and, mem_Ioc,
      lt_iff_not_ge, boundedQuantile_le_iff]
    rfl
  rw [hs]

instance (α : ℝ) (N : ℕ) : IsProbabilityMeasure (patternLaw α N) := by
  unfold patternLaw
  infer_instance

end SphericalPerceptronFreeEnergy
end

end OAI