import OAI.Probability.FreeIsing.Stochastic.SimpleIntegralIsometry

namespace OAI

noncomputable section

open MeasureTheory Filter
open scoped Topology BigOperators

namespace Problem367.MartingaleQuadraticVariation

variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {μ : Measure Ω}

def increment {I : Type*} (M : I → Ω → ℝ) (s t : I) : Ω → ℝ :=
  fun ω => M t ω - M s ω

def squareError {I : Type*} (M A : I → Ω → ℝ) (s t : I) : Ω → ℝ :=
  fun ω => (increment M s t ω) ^ 2 - increment A s t ω

theorem condExp_increment_eq_zero [IsFiniteMeasure μ]
    {I : Type*} [Preorder I] {ℱ : Filtration I mΩ}
    {M : I → Ω → ℝ} (hM : Martingale M ℱ μ) {s t : I} (hst : s ≤ t) :
    μ[increment M s t | ℱ s] =ᵐ[μ] 0 := by
  have hsub := condExp_sub (hM.integrable t) (hM.integrable s) (ℱ s)
  filter_upwards [hsub, hM.condExp_ae_eq hst, hM.condExp_ae_eq (le_refl s)]
    with ω hs ht hself
  simp only [Pi.sub_apply] at hs
  change μ[M t - M s | ℱ s] ω = 0
  rw [hs, ht, hself, sub_self]

theorem integrable_compensator [IsFiniteMeasure μ]
    {I : Type*} [Preorder I] {ℱ : Filtration I mΩ}
    {M A : I → Ω → ℝ}
    (hQ : Martingale (fun t ω => (M t ω) ^ 2 - A t ω) ℱ μ)
    (hM2 : ∀ t, MemLp (M t) 2 μ) (t : I) : Integrable (A t) μ := by
  simpa only [Pi.sub_def, sub_sub_cancel] using
    (hM2 t).integrable_sq.sub (hQ.integrable t)

theorem stronglyAdapted_compensator
    {I : Type*} [Preorder I] {ℱ : Filtration I mΩ}
    {M A : I → Ω → ℝ} (hM : Martingale M ℱ μ)
    (hQ : Martingale (fun t ω => (M t ω) ^ 2 - A t ω) ℱ μ) :
    StronglyAdapted ℱ A := by
  intro t
  simpa only [Pi.sub_def, Pi.pow_apply, sub_sub_cancel] using
    ((hM.stronglyMeasurable t).pow 2).sub (hQ.stronglyMeasurable t)

theorem condExp_squareError_eq_zero [IsFiniteMeasure μ]
    {I : Type*} [Preorder I] {ℱ : Filtration I mΩ}
    {M A : I → Ω → ℝ} (hM : Martingale M ℱ μ)
    (hQ : Martingale (fun t ω => (M t ω) ^ 2 - A t ω) ℱ μ)
    (hM2 : ∀ t, MemLp (M t) 2 μ) {s t : I} (hst : s ≤ t) :
    μ[squareError M A s t | ℱ s] =ᵐ[μ] 0 := by
  let Q : I → Ω → ℝ := fun r ω => (M r ω) ^ 2 - A r ω
  have hd : Integrable (increment M s t) μ := (hM.integrable t).sub (hM.integrable s)
  have hprod : Integrable (M s * increment M s t) μ :=
    (hM2 s).integrable_mul ((hM2 t).sub (hM2 s))
  have hpull := condExp_mul_of_stronglyMeasurable_left
    (hM.stronglyMeasurable s) hprod hd
  have hpzero : μ[M s * increment M s t | ℱ s] =ᵐ[μ] 0 := by
    filter_upwards [hpull, condExp_increment_eq_zero hM hst] with ω hp hz
    simp only [Pi.mul_apply, Pi.zero_apply] at hp hz ⊢
    rw [hp, hz, mul_zero]
  have hident : squareError M A s t =
      increment Q s t - (2 : ℝ) • (M s * increment M s t) := by
    funext ω
    simp only [squareError, increment, Pi.sub_apply, Pi.smul_apply, smul_eq_mul,
      Pi.mul_apply, Q]
    ring
  rw [hident]
  have hsub : μ[increment Q s t - (2 : ℝ) • (M s * increment M s t) | ℱ s] =ᵐ[μ]
      μ[increment Q s t | ℱ s] - μ[(2 : ℝ) • (M s * increment M s t) | ℱ s] :=
    condExp_sub ((hQ.integrable t).sub (hQ.integrable s))
      (hprod.smul (2 : ℝ)) (ℱ s)
  have hscale := condExp_smul (μ := μ) (m := ℱ s) (2 : ℝ)
    (M s * increment M s t)
  filter_upwards [hsub, condExp_increment_eq_zero hQ hst, hpzero, hscale]
    with ω hs hq hp hc
  simp only [Pi.sub_apply, Pi.smul_apply, Pi.zero_apply, smul_eq_mul] at hs hq hp hc ⊢
  change μ[increment Q s t | ℱ s] ω = 0 at hq
  rw [hs, hq, hc, hp]
  ring

theorem stronglyMeasurable_squareError
    {I : Type*} [Preorder I] {ℱ : Filtration I mΩ}
    {M A : I → Ω → ℝ} (hM : Martingale M ℱ μ)
    (hQ : Martingale (fun t ω => (M t ω) ^ 2 - A t ω) ℱ μ)
    {s t : I} (hst : s ≤ t) : StronglyMeasurable[ℱ t] (squareError M A s t) := by
  have hA := stronglyAdapted_compensator hM hQ
  exact (((hM.stronglyMeasurable t).sub
    ((hM.stronglyMeasurable s).mono (ℱ.mono hst))).pow 2).sub
      ((hA t).sub ((hA s).mono (ℱ.mono hst)))

theorem integrable_squareError [IsFiniteMeasure μ]
    {I : Type*} [Preorder I] {ℱ : Filtration I mΩ}
    {M A : I → Ω → ℝ}
    (hQ : Martingale (fun t ω => (M t ω) ^ 2 - A t ω) ℱ μ)
    (hM2 : ∀ t, MemLp (M t) 2 μ) (s t : I) :
    Integrable (squareError M A s t) μ :=
  ((hM2 t).sub (hM2 s)).integrable_sq.sub
    ((integrable_compensator hQ hM2 t).sub (integrable_compensator hQ hM2 s))

theorem weighted_error_isometry [IsFiniteMeasure μ]
    {ℱ : Filtration ℕ mΩ} {M A H : ℕ → Ω → ℝ}
    (hM : Martingale M ℱ μ)
    (hQ : Martingale (fun t ω => (M t ω) ^ 2 - A t ω) ℱ μ)
    (hM2 : ∀ t, MemLp (M t) 2 μ)
    (hH : ∀ i, StronglyMeasurable[ℱ i] (H i))
    (hY2 : ∀ i, MemLp (fun ω => H i ω * squareError M A i (i + 1) ω) 2 μ)
    (s : Finset ℕ) :
    (∫ ω, (∑ i ∈ s, H i ω * squareError M A i (i + 1) ω) ^ 2 ∂μ) =
      ∑ i ∈ s, ∫ ω, (H i ω * squareError M A i (i + 1) ω) ^ 2 ∂μ := by
  let D : ℕ → Ω → ℝ := fun i => squareError M A i (i + 1)
  have hD (i : ℕ) : StronglyMeasurable[ℱ (i + 1)] (D i) :=
    stronglyMeasurable_squareError hM hQ (Nat.le_succ i)
  have hDint (i : ℕ) : Integrable (D i) μ := integrable_squareError hQ hM2 _ _
  have hzero (i : ℕ) : μ[D i | ℱ i] =ᵐ[μ] 0 :=
    condExp_squareError_eq_zero hM hQ hM2 (Nat.le_succ i)
  apply SimpleIntegral.integral_sq_sum_of_orthogonal
  · intro i _ j _
    exact (hY2 i).integrable_mul (hY2 j)
  · intro i _ j _ hij
    rcases lt_or_gt_of_ne hij with hij | hji
    · exact SimpleIntegral.predictable_increments_orthogonal
        ℱ H D hH hD hDint hY2 hzero hij
    · simpa only [mul_comm] using
        SimpleIntegral.predictable_increments_orthogonal ℱ H D hH hD hDint hY2 hzero hji

theorem weighted_error_sq_le {h x a K : ℝ} (hK : 0 ≤ K) (hh : |h| ≤ K) :
    (h * (x ^ 2 - a)) ^ 2 ≤ 2 * K ^ 2 * (x ^ 4 + a ^ 2) := by
  have hh2 : h ^ 2 ≤ K ^ 2 := by
    simpa only [sq_abs] using (sq_le_sq₀ (abs_nonneg h) hK).2 hh
  have he : (x ^ 2 - a) ^ 2 ≤ 2 * (x ^ 4 + a ^ 2) := by
    nlinarith [sq_nonneg (x ^ 2 + a)]
  calc
    (h * (x ^ 2 - a)) ^ 2 = h ^ 2 * (x ^ 2 - a) ^ 2 := mul_pow _ _ _
    _ ≤ K ^ 2 * (x ^ 2 - a) ^ 2 := mul_le_mul_of_nonneg_right hh2 (sq_nonneg _)
    _ ≤ K ^ 2 * (2 * (x ^ 4 + a ^ 2)) := mul_le_mul_of_nonneg_left he (sq_nonneg _)
    _ = 2 * K ^ 2 * (x ^ 4 + a ^ 2) := by ring

theorem integral_weighted_error_sq_le [IsFiniteMeasure μ]
    {ℱ : Filtration ℕ mΩ} {M A H : ℕ → Ω → ℝ}
    (hM : Martingale M ℱ μ)
    (hQ : Martingale (fun t ω => (M t ω) ^ 2 - A t ω) ℱ μ)
    (hM2 : ∀ t, MemLp (M t) 2 μ)
    (hH : ∀ i, StronglyMeasurable[ℱ i] (H i))
    (hD4 : ∀ i, MemLp (fun ω => (increment M i (i + 1) ω) ^ 2) 2 μ)
    (hA2 : ∀ i, MemLp (increment A i (i + 1)) 2 μ)
    {K : ℝ} (hK : 0 ≤ K) (hbound : ∀ i, ∀ᵐ ω ∂μ, |H i ω| ≤ K)
    (s : Finset ℕ) :
    (∫ ω, (∑ i ∈ s, H i ω * squareError M A i (i + 1) ω) ^ 2 ∂μ) ≤
      2 * K ^ 2 * ∑ i ∈ s,
        ((∫ ω, (increment M i (i + 1) ω) ^ 4 ∂μ) +
          ∫ ω, (increment A i (i + 1) ω) ^ 2 ∂μ) := by
  have hY2 (i : ℕ) : MemLp (fun ω => H i ω * squareError M A i (i + 1) ω) 2 μ := by
    have hHtop : MemLp (H i) ⊤ μ := memLp_top_of_bound
      ((hH i).mono (ℱ.le i)).aestronglyMeasurable K (by simpa only [Real.norm_eq_abs] using hbound i)
    exact hHtop.fun_mul ((hD4 i).sub (hA2 i))
  rw [weighted_error_isometry hM hQ hM2 hH hY2 s, Finset.mul_sum]
  apply Finset.sum_le_sum
  intro i _
  have hfour : Integrable (fun ω => (increment M i (i + 1) ω) ^ 4) μ := by
    simpa only [← pow_mul] using (hD4 i).integrable_sq
  calc
    (∫ ω, (H i ω * squareError M A i (i + 1) ω) ^ 2 ∂μ) ≤
        ∫ ω, 2 * K ^ 2 * ((increment M i (i + 1) ω) ^ 4 +
          (increment A i (i + 1) ω) ^ 2) ∂μ := by
      apply integral_mono_ae (hY2 i).integrable_sq
        ((hfour.add (hA2 i).integrable_sq).const_mul _)
      filter_upwards [hbound i] with ω hω
      exact weighted_error_sq_le hK hω
    _ = _ := by rw [integral_const_mul, integral_add hfour (hA2 i).integrable_sq]

theorem integral_grid_weighted_error_sq_le [IsFiniteMeasure μ]
    {I : Type*} [Preorder I] {ℱ : Filtration I mΩ} {M A : I → Ω → ℝ}
    (hM : Martingale M ℱ μ)
    (hQ : Martingale (fun t ω => (M t ω) ^ 2 - A t ω) ℱ μ)
    (hM2 : ∀ t, MemLp (M t) 2 μ)
    (t : ℕ → I) (ht : Monotone t) (H : ℕ → Ω → ℝ)
    (hH : ∀ i, StronglyMeasurable[ℱ (t i)] (H i))
    (hD4 : ∀ i, MemLp (fun ω => (increment M (t i) (t (i + 1)) ω) ^ 2) 2 μ)
    (hA2 : ∀ i, MemLp (increment A (t i) (t (i + 1))) 2 μ)
    {K : ℝ} (hK : 0 ≤ K) (hbound : ∀ i, ∀ᵐ ω ∂μ, |H i ω| ≤ K)
    (s : Finset ℕ) :
    (∫ ω, (∑ i ∈ s, H i ω * squareError M A (t i) (t (i + 1)) ω) ^ 2 ∂μ) ≤
      2 * K ^ 2 * ∑ i ∈ s,
        ((∫ ω, (increment M (t i) (t (i + 1)) ω) ^ 4 ∂μ) +
          ∫ ω, (increment A (t i) (t (i + 1)) ω) ^ 2 ∂μ) := by
  let G : Filtration ℕ mΩ :=
    ⟨fun i => ℱ (t i), fun _ _ hij => ℱ.mono (ht hij), fun i => ℱ.le (t i)⟩
  have hMG : Martingale (fun i => M (t i)) G μ :=
    ⟨fun i => hM.stronglyMeasurable (t i), fun _ _ hij => hM.condExp_ae_eq (ht hij)⟩
  have hQG : Martingale (fun i ω => (M (t i) ω) ^ 2 - A (t i) ω) G μ :=
    ⟨fun i => hQ.stronglyMeasurable (t i), fun _ _ hij => hQ.condExp_ae_eq (ht hij)⟩
  exact integral_weighted_error_sq_le hMG hQG (fun i => hM2 (t i))
    hH hD4 hA2 hK hbound s

theorem memLp_finite_grid_weighted_error
    {I : Type*} {M A : I → Ω → ℝ} (t : ℕ → I) (H : ℕ → Ω → ℝ) (N : ℕ)
    (hH : ∀ i < N, AEStronglyMeasurable (H i) μ)
    (hD4 : ∀ i < N,
      MemLp (fun ω => (increment M (t i) (t (i + 1)) ω) ^ 2) 2 μ)
    (hA2 : ∀ i < N, MemLp (increment A (t i) (t (i + 1))) 2 μ)
    {K : ℝ} (hbound : ∀ i < N, ∀ᵐ ω ∂μ, |H i ω| ≤ K) :
    MemLp (fun ω => ∑ i ∈ Finset.range N,
      H i ω * squareError M A (t i) (t (i + 1)) ω) 2 μ := by
  apply memLp_finsetSum
  intro i hi
  have hi' := Finset.mem_range.mp hi
  have hHtop : MemLp (H i) ⊤ μ := memLp_top_of_bound (hH i hi') K
    (by simpa only [Real.norm_eq_abs] using hbound i hi')
  exact hHtop.fun_mul ((hD4 i hi').sub (hA2 i hi'))

theorem integral_finite_grid_weighted_error_sq_le [IsFiniteMeasure μ]
    {I : Type*} [Preorder I] {ℱ : Filtration I mΩ} {M A : I → Ω → ℝ}
    (hM : Martingale M ℱ μ)
    (hQ : Martingale (fun t ω => (M t ω) ^ 2 - A t ω) ℱ μ)
    (hM2 : ∀ t, MemLp (M t) 2 μ)
    (t : ℕ → I) (ht : Monotone t) (H : ℕ → Ω → ℝ) (N : ℕ)
    (hH : ∀ i < N, StronglyMeasurable[ℱ (t i)] (H i))
    (hD4 : ∀ i < N,
      MemLp (fun ω => (increment M (t i) (t (i + 1)) ω) ^ 2) 2 μ)
    (hA2 : ∀ i < N, MemLp (increment A (t i) (t (i + 1))) 2 μ)
    {K : ℝ} (hK : 0 ≤ K) (hbound : ∀ i < N, ∀ᵐ ω ∂μ, |H i ω| ≤ K) :
    (∫ ω, (∑ i ∈ Finset.range N,
      H i ω * squareError M A (t i) (t (i + 1)) ω) ^ 2 ∂μ) ≤
      2 * K ^ 2 * ∑ i ∈ Finset.range N,
        ((∫ ω, (increment M (t i) (t (i + 1)) ω) ^ 4 ∂μ) +
          ∫ ω, (increment A (t i) (t (i + 1)) ω) ^ 2 ∂μ) := by
  let u : ℕ → I := fun i => t (min i N)
  let G : ℕ → Ω → ℝ := fun i => if i < N then H i else 0
  have hu (i : ℕ) (hi : i ≤ N) : u i = t i := by simp only [u, min_eq_left hi]
  have huend (i : ℕ) (hi : N ≤ i) : u i = t N := by simp only [u, min_eq_right hi]
  have hmono : Monotone u := fun i j hij => ht (min_le_min_right N hij)
  have hG (i : ℕ) : StronglyMeasurable[ℱ (u i)] (G i) := by
    by_cases hi : i < N
    · rw [hu i hi.le]
      simpa only [G, ite_eq_left hi] using hH i hi
    · simp only [G, ite_eq_right hi]
      exact stronglyMeasurable_zero
  have hD (i : ℕ) : MemLp (fun ω => (increment M (u i) (u (i + 1)) ω) ^ 2) 2 μ := by
    by_cases hi : i < N
    · simpa only [hu i hi.le, hu (i + 1) (Nat.succ_le_of_lt hi)] using hD4 i hi
    · have hNi := Nat.le_of_not_gt hi
      simp only [huend i hNi, huend (i + 1) (hNi.trans (Nat.le_succ i)), increment,
        sub_self, zero_pow (by norm_num : 2 ≠ 0)]
      exact MemLp.zero
  have hA (i : ℕ) : MemLp (increment A (u i) (u (i + 1))) 2 μ := by
    by_cases hi : i < N
    · simpa only [hu i hi.le, hu (i + 1) (Nat.succ_le_of_lt hi)] using hA2 i hi
    · have hNi := Nat.le_of_not_gt hi
      rw [huend i hNi, huend (i + 1) (hNi.trans (Nat.le_succ i))]
      have hz : increment A (t N) (t N) = 0 := by
        funext ω
        exact sub_self _
      rw [hz]
      exact MemLp.zero
  have hB (i : ℕ) : ∀ᵐ ω ∂μ, |G i ω| ≤ K := by
    by_cases hi : i < N
    · simpa only [G, ite_eq_left hi] using hbound i hi
    · exact Filter.Eventually.of_forall (fun _ => by simpa only [G, ite_eq_right hi,
        Pi.zero_apply, abs_zero] using hK)
  have he := integral_grid_weighted_error_sq_le hM hQ hM2 u hmono G hG hD hA hK hB
    (Finset.range N)
  have hsum (ω : Ω) : (∑ i ∈ Finset.range N,
      G i ω * squareError M A (u i) (u (i + 1)) ω) =
      ∑ i ∈ Finset.range N, H i ω * squareError M A (t i) (t (i + 1)) ω := by
    apply Finset.sum_congr rfl
    intro i hi
    have hi' := Finset.mem_range.mp hi
    simp only [G, ite_eq_left hi', hu i hi'.le, hu (i + 1) (Nat.succ_le_of_lt hi')]
  have henergy : (∑ i ∈ Finset.range N,
      ((∫ ω, (increment M (u i) (u (i + 1)) ω) ^ 4 ∂μ) +
        ∫ ω, (increment A (u i) (u (i + 1)) ω) ^ 2 ∂μ)) =
      ∑ i ∈ Finset.range N,
        ((∫ ω, (increment M (t i) (t (i + 1)) ω) ^ 4 ∂μ) +
          ∫ ω, (increment A (t i) (t (i + 1)) ω) ^ 2 ∂μ) := by
    apply Finset.sum_congr rfl
    intro i hi
    have hi' := Finset.mem_range.mp hi
    rw [hu i hi'.le, hu (i + 1) (Nat.succ_le_of_lt hi')]
  simpa only [hsum, henergy] using he

theorem tendsto_integral_grid_weighted_error_sq [IsFiniteMeasure μ]
    {I : Type*} [Preorder I] {ℱ : Filtration I mΩ} {M A : I → Ω → ℝ}
    (hM : Martingale M ℱ μ)
    (hQ : Martingale (fun t ω => (M t ω) ^ 2 - A t ω) ℱ μ)
    (hM2 : ∀ t, MemLp (M t) 2 μ)
    (t : ℕ → ℕ → I) (ht : ∀ n, Monotone (t n)) (H : ℕ → ℕ → Ω → ℝ)
    (hH : ∀ n i, StronglyMeasurable[ℱ (t n i)] (H n i))
    (hD4 : ∀ n i,
      MemLp (fun ω => (increment M (t n i) (t n (i + 1)) ω) ^ 2) 2 μ)
    (hA2 : ∀ n i, MemLp (increment A (t n i) (t n (i + 1))) 2 μ)
    {K : ℝ} (hK : 0 ≤ K) (hbound : ∀ n i, ∀ᵐ ω ∂μ, |H n i ω| ≤ K)
    (s : ℕ → Finset ℕ)
    (hsmall : Tendsto (fun n => ∑ i ∈ s n,
      ((∫ ω, (increment M (t n i) (t n (i + 1)) ω) ^ 4 ∂μ) +
        ∫ ω, (increment A (t n i) (t n (i + 1)) ω) ^ 2 ∂μ)) atTop (𝓝 0)) :
    Tendsto (fun n => ∫ ω,
      (∑ i ∈ s n, H n i ω * squareError M A (t n i) (t n (i + 1)) ω) ^ 2 ∂μ)
      atTop (𝓝 0) := by
  apply squeeze_zero (fun _ => integral_nonneg (fun _ => sq_nonneg _))
    (fun n => integral_grid_weighted_error_sq_le hM hQ hM2 (t n) (ht n) (H n)
      (hH n) (hD4 n) (hA2 n) hK (hbound n) (s n))
  simpa only [mul_zero] using hsmall.const_mul (2 * K ^ 2)

theorem tendsto_integral_finite_grid_weighted_error_sq [IsFiniteMeasure μ]
    {I : Type*} [Preorder I] {ℱ : Filtration I mΩ} {M A : I → Ω → ℝ}
    (hM : Martingale M ℱ μ)
    (hQ : Martingale (fun t ω => (M t ω) ^ 2 - A t ω) ℱ μ)
    (hM2 : ∀ t, MemLp (M t) 2 μ)
    (t : ℕ → ℕ → I) (ht : ∀ n, Monotone (t n)) (N : ℕ → ℕ)
    (H : ℕ → ℕ → Ω → ℝ)
    (hH : ∀ n i, i < N n → StronglyMeasurable[ℱ (t n i)] (H n i))
    (hD4 : ∀ n i, i < N n →
      MemLp (fun ω => (increment M (t n i) (t n (i + 1)) ω) ^ 2) 2 μ)
    (hA2 : ∀ n i, i < N n → MemLp (increment A (t n i) (t n (i + 1))) 2 μ)
    {K : ℝ} (hK : 0 ≤ K)
    (hbound : ∀ n i, i < N n → ∀ᵐ ω ∂μ, |H n i ω| ≤ K)
    (hfour : Tendsto (fun n => ∑ i ∈ Finset.range (N n),
      ∫ ω, (increment M (t n i) (t n (i + 1)) ω) ^ 4 ∂μ) atTop (𝓝 0))
    (hcomp : Tendsto (fun n => ∑ i ∈ Finset.range (N n),
      ∫ ω, (increment A (t n i) (t n (i + 1)) ω) ^ 2 ∂μ) atTop (𝓝 0)) :
    Tendsto (fun n => ∫ ω, (∑ i ∈ Finset.range (N n),
      H n i ω * squareError M A (t n i) (t n (i + 1)) ω) ^ 2 ∂μ) atTop (𝓝 0) := by
  apply squeeze_zero (fun _ => integral_nonneg (fun _ => sq_nonneg _))
    (fun n => integral_finite_grid_weighted_error_sq_le hM hQ hM2 (t n) (ht n)
      (H n) (N n) (hH n) (hD4 n) (hA2 n) hK (hbound n))
  simpa only [Finset.sum_add_distrib, add_zero, mul_zero] using
    (hfour.add hcomp).const_mul (2 * K ^ 2)

end Problem367.MartingaleQuadraticVariation

end

end OAI