From 2f5dbe4364ebb83cf92a79035033a1477da537c3 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Thu, 26 Mar 2026 11:27:11 +0100
Subject: [PATCH 01/37] Komlos lemma initial draft

---
 .../StochasticIntegral/ConvexWeights.lean     | 46 ++++++++++
 BrownianMotion/StochasticIntegral/Komlos.lean | 89 ++++++++++++++-----
 2 files changed, 114 insertions(+), 21 deletions(-)
 create mode 100644 BrownianMotion/StochasticIntegral/ConvexWeights.lean

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
new file mode 100644
index 00000000..7b1201dc
--- /dev/null
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -0,0 +1,46 @@
+module
+
+public import Mathlib.Analysis.InnerProductSpace.Defs
+
+/-
+# Convex Weights
+This is kept in a separate file for now, might become part of `Mathlib.Analysis.Convex.Combination`
+when upstreamed.
+-/
+
+@[expose] public section
+
+variable {R E : Type*} [Field R] [AddCommGroup E] [Module R E]
+  [LinearOrder R] [IsStrictOrderedRing R] {ι : Type*}
+
+lemma convex_weights_of_mem_convexHull_indexed {s : ι → E} {x : E}
+  (h : x ∈ convexHull R (Set.range s)) :
+    ∃ (w : ι →₀ R), (∀ i, 0 ≤ w i) ∧ ∑ i : w.support, w i = 1 ∧ ∑ i : w.support, w i • s i = x := by
+  sorry
+
+def convexWeights (cw : ι →₀ ℝ) : Prop :=
+  ∀ n : cw.support, 0 ≤ cw n ∧ ∑ n : cw.support, cw n = 1
+-- We might also choose the equivalent condition ∀ n : ι, 0 ≤ cw
+
+noncomputable def cwmul (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) : ℕ →₀ ℝ :=
+  Finsupp.onFinset (a.support.biUnion (fun k ↦ (b k).support))
+    (fun m ↦ ∑ k ∈ a.support, a k * (b k m))
+    (fun m hm ↦ by
+      simp only [Finset.mem_biUnion, Finsupp.mem_support_iff]
+      by_contra h
+      push_neg at h
+      apply hm
+      apply Finset.sum_eq_zero
+      intro k hk
+      rcases eq_or_ne (a k) 0 with ha | ha
+      · simp [ha]
+      · simp [h k (Finsupp.mem_support_iff.mp hk)])
+
+lemma convexWeights_cwmul {a : ℕ →₀ ℝ} {b : ℕ → ℕ →₀ ℝ}
+  (ha : convexWeights a) (hb : ∀ k, convexWeights (b k)) : convexWeights (cwmul a b) := by
+  sorry
+
+noncomputable def cwIteratedMul (k : ℕ) (cw : ℕ → ℕ → ℕ →₀ ℝ) : ℕ → ℕ →₀ ℝ :=
+  match k with
+  | 0 => fun n ↦ cw 0 n
+  | k + 1 => fun n ↦ cwmul (cw k n) (cwIteratedMul k cw)
diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index fa4521f5..d701645c 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -7,6 +7,9 @@ module
 
 public import Mathlib.Analysis.InnerProductSpace.Basic
 public import Mathlib.MeasureTheory.Function.UniformIntegrable
+public import Mathlib.Probability.Moments.Basic
+public import Mathlib.Topology.UniformSpace.Cauchy
+public import BrownianMotion.StochasticIntegral.ConvexWeights
 
 /-!
 # Komlos lemmas
@@ -20,40 +23,40 @@ variable {E Ω : Type*} {mΩ : MeasurableSpace Ω}
 open Filter MeasureTheory
 open scoped Topology NNReal ENNReal
 
-lemma komlos_convex [AddCommMonoid E] [Module ℝ≥0 E]
+lemma komlos_convex [AddCommMonoid E] [Module ℝ E]
   {f : ℕ → E} {φ : E → ℝ} (hφ_nonneg : 0 ≤ φ)
   (hφ_bdd : ∃ M : ℝ, ∀ n, φ (f n) ≤ M) :
-  ∃ g : ℕ → E, (∀ n, g n ∈ convexHull ℝ≥0 (Set.range fun m ↦ f (n + m))) ∧
+  ∃ g : ℕ → E, (∀ n, g n ∈ convexHull ℝ (Set.range fun m ↦ f (n + m))) ∧
     ∀ δ > 0, ∃ N, ∀ n m, N ≤ n → N ≤ m →
-      2⁻¹ * φ (g n) + 2⁻¹ * φ (g m) - φ ((2 : ℝ≥0)⁻¹ • (g n + g m)) < δ := by
+      2⁻¹ * φ (g n) + 2⁻¹ * φ (g m) - φ ((2 : ℝ)⁻¹ • (g n + g m)) < δ := by
   obtain ⟨M, hM⟩ := hφ_bdd
-  let r : ℕ → ℝ := fun n ↦ sInf (Set.image φ (convexHull ℝ≥0 (Set.range (fun m ↦ f (n + m)))))
+  let r : ℕ → ℝ := fun n ↦ sInf (Set.image φ (convexHull ℝ (Set.range (fun m ↦ f (n + m)))))
   have hr_nondec n : r n ≤ r (n + 1) := by
     apply_rules [csInf_le_csInf]
     · exact ⟨0, Set.forall_mem_image.2 fun x hx ↦ hφ_nonneg x⟩
-    · exact ⟨_, ⟨ _, subset_convexHull ℝ≥0 _ ⟨0, rfl⟩, rfl⟩⟩
-    · refine Set.image_mono <| convexHull_min ?_ (convex_convexHull ℝ≥0 _)
-      rintro _ ⟨m, rfl⟩; exact subset_convexHull ℝ≥0 _ ⟨m + 1, by simp [add_comm, add_left_comm]⟩
+    · exact ⟨_, ⟨ _, subset_convexHull ℝ _ ⟨0, rfl⟩, rfl⟩⟩
+    · refine Set.image_mono <| convexHull_min ?_ (convex_convexHull ℝ _)
+      rintro _ ⟨m, rfl⟩; exact subset_convexHull ℝ _ ⟨m + 1, by simp [add_comm, add_left_comm]⟩
   obtain ⟨A, hA⟩ : ∃ A, Filter.Tendsto r Filter.atTop (nhds A) := by
     refine ⟨_, tendsto_atTop_ciSup (monotone_nat_of_le_succ hr_nondec) ?_⟩
     exact ⟨M, Set.forall_mem_range.mpr fun n ↦ csInf_le
       ⟨0, Set.forall_mem_image.mpr fun x hx ↦ hφ_nonneg x⟩
-        (Set.mem_image_of_mem _ <| subset_convexHull ℝ≥0 _
+        (Set.mem_image_of_mem _ <| subset_convexHull ℝ _
           <| Set.mem_range_self 0) |> le_trans <| by simpa using hM n⟩
   obtain ⟨g, hg⟩ :
-      ∃ g : ℕ → E, (∀ n, g n ∈ convexHull ℝ≥0 (Set.range (fun m ↦ f (n + m))))
+      ∃ g : ℕ → E, (∀ n, g n ∈ convexHull ℝ (Set.range (fun m ↦ f (n + m))))
           ∧ (∀ n, φ (g n) ≤ A + 1 / (n + 1)) := by
     have h_exists_g :
-        ∀ n, ∃ g ∈ convexHull ℝ≥0 (Set.range (fun m ↦ f (n + m))), φ g ≤ A + 1 / (n + 1) := by
+        ∀ n, ∃ g ∈ convexHull ℝ (Set.range (fun m ↦ f (n + m))), φ g ≤ A + 1 / (n + 1) := by
       intro n
       have h_exists_g :
-          ∃ g ∈ convexHull ℝ≥0 (Set.range (fun m ↦ f (n + m))), φ g < A + 1 / (n + 1) := by
+          ∃ g ∈ convexHull ℝ (Set.range (fun m ↦ f (n + m))), φ g < A + 1 / (n + 1) := by
         have h_exists_g : r n < A + 1 / (n + 1) := by
           exact lt_add_of_le_of_pos (le_of_tendsto_of_tendsto tendsto_const_nhds hA
             (Filter.eventually_atTop.2 ⟨n, fun m hm ↦ by
               induction hm <;> [tauto; linarith [hr_nondec ‹_›]]⟩)) (by positivity)
         contrapose! h_exists_g
-        exact le_csInf ⟨ _, Set.mem_image_of_mem _ <| subset_convexHull ℝ≥0 _
+        exact le_csInf ⟨ _, Set.mem_image_of_mem _ <| subset_convexHull ℝ _
           <| Set.mem_range_self 0 ⟩ fun x hx ↦ by
             rcases hx with ⟨ g, hg, rfl ⟩; exact h_exists_g g hg
       exact ⟨h_exists_g.choose, h_exists_g.choose_spec.1, le_of_lt h_exists_g.choose_spec.2⟩
@@ -67,11 +70,11 @@ lemma komlos_convex [AddCommMonoid E] [Module ℝ≥0 E]
     exact ⟨N + ⌈ε⁻¹⌉₊, by linarith [abs_lt.mp (hN (N + ⌈ε⁻¹⌉₊) (by grind))], by
       simpa using inv_le_of_inv_le₀ εpos (by linarith [Nat.le_ceil (ε⁻¹)])⟩
   refine ⟨N, fun n m hn hm ↦ ?_⟩
-  have h_convex : φ ((1 / 2 : ℝ≥0) • (g n + g m)) ≥ A - ε := by
+  have h_convex : φ ((1 / 2 : ℝ) • (g n + g m)) ≥ A - ε := by
     have h_convex :
-        (1 / 2 : ℝ≥0) • (g n + g m) ∈ convexHull ℝ≥0 (Set.range (fun m ↦ f (N + m))) := by
+        (1 / 2 : ℝ) • (g n + g m) ∈ convexHull ℝ (Set.range (fun m ↦ f (N + m))) := by
       simp only [one_div, gt_iff_lt, ge_iff_le, tsub_le_iff_right, smul_add] at *
-      refine convex_convexHull ℝ≥0 _ ?_ ?_ ?_ ?_ ?_ <;> norm_num
+      refine convex_convexHull ℝ _ ?_ ?_ ?_ ?_ ?_ <;> norm_num
       · refine convexHull_mono (Set.range_subset_iff.2 fun m ↦ ?_) (hg.1 n)
         exact ⟨m + (n - N), by grind⟩
       · refine convexHull_mono ?_ (hg.1 m)
@@ -87,8 +90,8 @@ lemma komlos_convex [AddCommMonoid E] [Module ℝ≥0 E]
 set_option backward.isDefEq.respectTransparency false in
 lemma komlos_norm [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
     {f : ℕ → E} (h_bdd : ∃ M : ℝ, ∀ n, ‖f n‖ ≤ M) :
-    ∃ (g : ℕ → E) (x : E), (∀ n, g n ∈ convexHull ℝ≥0 (Set.range fun m ↦ f (n + m))) ∧
-      Tendsto g atTop (𝓝 x) := by
+    ∃ (g : ℕ → E), (∀ n, g n ∈ convexHull ℝ (Set.range fun m ↦ f (n + m))) ∧
+      ∃ (x : E), Tendsto g atTop (𝓝 x) := by
   let φ : E → ℝ := fun f ↦ ‖f‖ ^ 2
   have φ_nonneg : 0 ≤ φ := fun f ↦ sq_nonneg ‖f‖
   have φ_bdd : ∃ M : ℝ, ∀ n, φ (f n) ≤ M := by
@@ -97,8 +100,8 @@ lemma komlos_norm [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
   rcases komlos_convex φ_nonneg φ_bdd with ⟨g, hg, h⟩
   use g
   have parallelogram_identity (x y : E) :
-      2⁻¹ * ‖x‖ ^ 2 + 2⁻¹ * ‖y‖ ^ 2 - ‖(2 : ℝ≥0)⁻¹ • (x + y)‖ ^ 2 = ‖y - x‖ ^ 2 / 4 := by
-    have : (2 : ℝ≥0)⁻¹ • (x + y) = (2 : ℝ)⁻¹ • (x + y) := by rfl
+      2⁻¹ * ‖x‖ ^ 2 + 2⁻¹ * ‖y‖ ^ 2 - ‖(2 : ℝ)⁻¹ • (x + y)‖ ^ 2 = ‖y - x‖ ^ 2 / 4 := by
+    have : (2 : ℝ)⁻¹ • (x + y) = (2 : ℝ)⁻¹ • (x + y) := by rfl
     rw [this, norm_smul_of_nonneg (by norm_num), mul_pow, add_comm x y]
     let para := parallelogram_law_with_norm ℝ y x
     linear_combination - para / 4
@@ -115,12 +118,56 @@ lemma komlos_norm [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
     rw [dist_eq_norm]
     exact (pow_lt_pow_iff_left₀ (norm_nonneg (g m - g n)) (by positivity) (by norm_num)).mp this
   rcases CompleteSpace.complete g_cauchy with ⟨x, hx⟩
-  exact ⟨x, hg, hx⟩
+  sorry
+
+def C [AddCommMonoid E] [Module ℝ E] (x : ℕ → E) : Set (ℕ → E) :=
+  {g : ℕ → E | ∀ n, g n ∈ convexHull ℝ (Set.range fun m ↦ x (n + m))}
+
+-- Lemma 2.11 in the blueprint
+lemma komlos_convergence [NormedAddCommGroup E] [Module ℝ E] [IsBoundedSMul ℝ E]
+  {x : ℕ → E} {xlim : E} (hxlim : Tendsto x atTop (𝓝 xlim)) :
+  ∀ ε > 0, ∃ N, ∀ y ∈ C x, ∀ n ≥ N, ‖y n - xlim‖ < ε := by
+  intro ε εpos
+  obtain ⟨N, hN⟩ : ∃ N, ∀ n ≥ N, ‖x n - xlim‖ < ε := by
+    rcases Metric.tendsto_atTop.mp hxlim ε εpos with ⟨N, hN⟩
+    use N
+    intro n hn
+    rw [← dist_eq_norm (x n) xlim]
+    exact hN n hn
+  use N
+  intro y hy n hn
+  obtain ⟨N, a, ha_sum, ha_pos, hay⟩ : (∃ N : ℕ → Finset ℕ, ∃ a : (n : ℕ) → ℕ → ℝ,
+    (∑ m ∈ N n, a n m) = 1 ∧ (∀ m ∈ N n, 0 ≤ a n m) ∧ (∀ n, y n = ∑ m ∈ N n, a n m • x n)) := by
+    sorry
+  rw [hay n]
+  rw [show xlim = (1 : ℝ) • xlim by simp]
+  rw [← ha_sum]
+  rw [Finset.sum_smul]
+  rw [← Finset.sum_sub_distrib]
+  simp_rw [← smul_sub]
+  apply lt_of_le_of_lt (norm_sum_le (N n) (fun m ↦ a n m • (x n - xlim)))
+
+  have hsum_le :
+      ∑ i ∈ N n, ‖a n i • (x n - xlim)‖ ≤ ∑ i ∈ N n, ‖a n i‖ * ‖x n - xlim‖ := by
+    exact Finset.sum_le_sum (fun m hm ↦ norm_smul_le (a n m) (x n - xlim))
+
+  refine lt_of_le_of_lt hsum_le ?_
+  rw [← Finset.sum_mul]
+
+  have hanorm : ∑ i ∈ N n, ‖a n i‖ = ∑ i ∈ N n, a n i := by
+      apply Finset.sum_congr rfl
+      intro m hm
+      refine Real.norm_of_nonneg ?_
+      exact ha_pos m hm
+
+  rw [hanorm, ha_sum]
+  simp only [one_mul, gt_iff_lt]
+  exact RCLike.ofReal_lt_ofReal.mp (hN n hn)
 
 theorem komlos_L1 [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
     [MeasurableSpace E] [BorelSpace E] {f : ℕ → Ω → E} {P : Measure Ω}
     (hf : UniformIntegrable f 1 P) :
-    ∃ (g : ℕ → Ω → E) (glim : Ω → E), (∀ n, g n ∈ convexHull ℝ≥0 (Set.range fun m ↦ f (n + m))) ∧
+    ∃ (g : ℕ → Ω → E) (glim : Ω → E), (∀ n, g n ∈ convexHull ℝ (Set.range fun m ↦ f (n + m))) ∧
       Tendsto (fun n ↦ eLpNorm (g n - glim) 1 P) atTop (𝓝 0) := by
   sorry
 

From 7fa3bd6f29a8737ffc9004ed86528c1e12cdeb88 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Wed, 8 Apr 2026 10:36:12 +0200
Subject: [PATCH 02/37] feat(blueprint): more details on Komlos construction

---
 .../StochasticIntegral/ConvexWeights.lean     |  8 ++++---
 blueprint/lean_decls                          |  1 +
 blueprint/src/chapters/doob_meyer.tex         | 21 +++++++++++++++----
 3 files changed, 23 insertions(+), 7 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
index 7b1201dc..e0a587ec 100644
--- a/BrownianMotion/StochasticIntegral/ConvexWeights.lean
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -16,13 +16,15 @@ variable {R E : Type*} [Field R] [AddCommGroup E] [Module R E]
 lemma convex_weights_of_mem_convexHull_indexed {s : ι → E} {x : E}
   (h : x ∈ convexHull R (Set.range s)) :
     ∃ (w : ι →₀ R), (∀ i, 0 ≤ w i) ∧ ∑ i : w.support, w i = 1 ∧ ∑ i : w.support, w i • s i = x := by
-  sorry
+      sorry
 
 def convexWeights (cw : ι →₀ ℝ) : Prop :=
   ∀ n : cw.support, 0 ≤ cw n ∧ ∑ n : cw.support, cw n = 1
 -- We might also choose the equivalent condition ∀ n : ι, 0 ≤ cw
 
-noncomputable def cwmul (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) : ℕ →₀ ℝ :=
+noncomputable section
+
+def cwmul (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) : ℕ →₀ ℝ :=
   Finsupp.onFinset (a.support.biUnion (fun k ↦ (b k).support))
     (fun m ↦ ∑ k ∈ a.support, a k * (b k m))
     (fun m hm ↦ by
@@ -40,7 +42,7 @@ lemma convexWeights_cwmul {a : ℕ →₀ ℝ} {b : ℕ → ℕ →₀ ℝ}
   (ha : convexWeights a) (hb : ∀ k, convexWeights (b k)) : convexWeights (cwmul a b) := by
   sorry
 
-noncomputable def cwIteratedMul (k : ℕ) (cw : ℕ → ℕ → ℕ →₀ ℝ) : ℕ → ℕ →₀ ℝ :=
+def cwIteratedMul (k : ℕ) (cw : ℕ → ℕ → ℕ →₀ ℝ) : ℕ → ℕ →₀ ℝ :=
   match k with
   | 0 => fun n ↦ cw 0 n
   | k + 1 => fun n ↦ cwmul (cw k n) (cwIteratedMul k cw)
diff --git a/blueprint/lean_decls b/blueprint/lean_decls
index 93f9f1db..e7bb5f15 100644
--- a/blueprint/lean_decls
+++ b/blueprint/lean_decls
@@ -396,6 +396,7 @@ ProbabilityTheory.SimpleProcess.integral_top
 tendsto_of_no_upcrossings
 komlos_convex
 komlos_norm
+cwmul
 komlos_L1
 komlos_ennreal
 MeasureTheory.predictablePart
diff --git a/blueprint/src/chapters/doob_meyer.tex b/blueprint/src/chapters/doob_meyer.tex
index 908171d7..3853220b 100644
--- a/blueprint/src/chapters/doob_meyer.tex
+++ b/blueprint/src/chapters/doob_meyer.tex
@@ -96,15 +96,19 @@ \section{Komlòs Lemma}
 \end{proof}
 
 By convex weights on $\mathbb{N}$, we mean a sequence of non-negative real numbers $(a_n)_{n \in \mathbb{N}}$ with finitely many nonzero entries such that $\sum_{n \in \mathbb{N}} a_n = 1$.
+
+\begin{definition}\label{def:convex_weights_product}
+  \lean{cwmul}
 If $(a_m)_{m \in \mathbb{N}}$ are convex weights and $(b^n_m)_{n,m \in \mathbb{N}}$ is such that for all $n$, the $(b^n_m)$ are convex weights, then we denote by $(a_\cdot) * (b^\cdot_\cdot)$ the convex weights defined by $((a_\cdot) * (b^\cdot_\cdot))_m = \sum_{k} a_k b^k_m$.
+\end{definition}
 
 
 \begin{lemma}\label{lem:komlos_convex_weights} Let $E$ be a Hilbert space and for $i \in \mathbb{N}$, let $(x_n^{(i)})_{n \in \mathbb{N}}$ be a bounded sequence in $E$. Then there exists a sequence of convex weights $(\lambda^{k,n}_\cdot)_{k, n \in \mathbb{N}}$ with $\lambda^{k,n}_m = 0$ for $m < n$ such that for all $k \in \mathbb{N}$, $\left(\sum_{m \ge n} \left((\lambda^{k,n}_\cdot) * \ldots * (\lambda^{1,\cdot}_\cdot)\right)_m x_m^{(k)}\right)_{n \in \mathbb{N}}$ converges.
 \end{lemma}
 
 \begin{proof}
-  \uses{lem:komlos_norm}
-First by lemma \ref{lem:komlos_norm} applied to $(x_n^{(1)})_{n\in\mathbb{N}}$ in the Hilbert space $E$, there exist $g_n^1 \in convex(x_n^{(1)}, x_{n+1}^{(1)}, \ldots)$ (call its weights $\lambda^{1,n}_n,\cdots,\lambda^{1,n}_{N^1_n}$) such that $g_n^1$ converges to some $g^1$.
+  \uses{lem:komlos_norm,def:convex_weights_product}
+First by Lemma~\ref{lem:komlos_norm} applied to $(x_n^{(1)})_{n\in\mathbb{N}}$ in the Hilbert space $E$, there exist $g_n^1 \in convex(x_n^{(1)}, x_{n+1}^{(1)}, \ldots)$ (call its weights $\lambda^{1,n}_n,\cdots,\lambda^{1,n}_{N^1_n}$) such that $g_n^1$ converges to some $g^1$.
 
 Secondly define $\tilde{g}_n^2$, convex combination of $x_n^{(2)}, x_{n+1}^{(2)}, \ldots$ with weights $\lambda^{1,n}_n,\cdots,\lambda^{1,n}_{N^1_n}$.
 Applying lemma~\ref{lem:komlos_norm} to $(\tilde{g}_n^2)_{n\in\mathbb{N}}$ gives us $g_n^2 \in convex(\tilde{g}_n^2, \tilde{g}_{n+1}^2, \ldots)$ (call its weights $\lambda^{1,n}_n,\cdots,\lambda^{2,n}_{N^2_n}$) such that $g_n^2$ converges to some $g^2$.
@@ -112,13 +116,22 @@ \section{Komlòs Lemma}
 
 We continue iterating this process inductively.
 At iteration $k$ we have weights $(\lambda^{k,n}_\cdot * \ldots * \lambda^{1,\cdot}_\cdot)$.
-We define $\tilde{g}_n^{k+1}$ as the convex combination of $x_n^{(k+1)}, x_{n+1}^{(k+1)}, \ldots$ with those weights.
-We apply Lemma~\ref{lem:komlos_norm} to $(\tilde{g}_n^{k+1})_{n\in\mathbb{N}}$ to get $g_n^{k+1} \in convex(\tilde{g}_n^{k+1}, \tilde{g}_{n+1}^{k+1}, \ldots)$ such that $g_n^{k+1}$ converges to some $g^{k+1}$. We denote its weights by $\lambda^{k+1,n}_n,\cdots,\lambda^{k+1,n}_{N^{k+1}_n}$.
+We define $\tilde{g}_n^{k+1}$ as the convex combination of $x_n^{(k+1)}, x_{n+1}^{(k+1)}, \ldots$ with those weights:
+\[ \tilde{g}_n^{k+1} = \sum_{l} (\lambda^{k,n}_\cdot * \ldots * \lambda^{1,\cdot}_\cdot)_l x^{(k+1)}_l \]
+We apply Lemma~\ref{lem:komlos_norm} to $(\tilde{g}_n^{k+1})_{n\in\mathbb{N}}$ to get $g_n^{k+1} \in convex(\tilde{g}_n^{k+1}, \tilde{g}_{n+1}^{k+1}, \ldots)$ such that $g_n^{k+1}$ converges to some $g^{k+1}$. We denote its weights by $\lambda^{k+1,n}_n,\cdots,\lambda^{k+1,n}_{N^{k+1}_n}$ and can then write:
+
+\begin{align*}
+  g_n^{k+1} & = \sum_{m} \lambda^{k+1,n}_m \tilde{g}_m^{k+1}
+  = \sum_{m} \lambda^{k+1,n}_m \left( \sum_{l} (\lambda^{k,m}_\cdot * \ldots * \lambda^{1,\cdot}_\cdot)_l x_l^{(k+1)} \right) \\
+  & = \sum_{l} \left( \sum_{m} \lambda^{k+1,n}_m (\lambda^{k,m}_\cdot * \ldots * \lambda^{1,\cdot}_\cdot)_l \right) x_l^{(k+1)} \\
+  & = \sum_{l} (\lambda^{k+1,n}_{\cdot} * (\lambda^{k,\cdot}_\cdot * \ldots * \lambda^{1,\cdot}_\cdot))_l x_l^{(k+1)}
+\end{align*}
 
 We have thus defined, for all $k, n \in \mathbb{N}$, convex weights $(\lambda^{k,n}_m)$ (that are zero for $m < n$) such that $\sum_{m \ge n}((\lambda^{k,n}_\cdot * \ldots * \lambda^{1, \cdot}_\cdot))_m x_m^{(k)}$ converges to $g^k$.
 \end{proof}
 
 
+
 \begin{lemma}\label{lem:komlos_convex_weights_tendsto}
   \uses{lem:komlos_convex_weights}
 Let $E$ be a Hilbert space and for $i \in \mathbb{N}$, let $(x_n^{(i)})_{n \in \mathbb{N}}$ be a bounded sequence in $E$.

From 03c0e095da46ae07f8c02a1985be78ad54faa7a1 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Wed, 8 Apr 2026 11:30:02 +0200
Subject: [PATCH 03/37] refactor(blueprint): reindex \tilde{g}

Change \tilde{g}^{k+1} to \tilde{g}^k which allows for a more natural formalisation
---
 blueprint/src/chapters/doob_meyer.tex | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/blueprint/src/chapters/doob_meyer.tex b/blueprint/src/chapters/doob_meyer.tex
index 3853220b..deb22831 100644
--- a/blueprint/src/chapters/doob_meyer.tex
+++ b/blueprint/src/chapters/doob_meyer.tex
@@ -103,25 +103,27 @@ \section{Komlòs Lemma}
 \end{definition}
 
 
-\begin{lemma}\label{lem:komlos_convex_weights} Let $E$ be a Hilbert space and for $i \in \mathbb{N}$, let $(x_n^{(i)})_{n \in \mathbb{N}}$ be a bounded sequence in $E$. Then there exists a sequence of convex weights $(\lambda^{k,n}_\cdot)_{k, n \in \mathbb{N}}$ with $\lambda^{k,n}_m = 0$ for $m < n$ such that for all $k \in \mathbb{N}$, $\left(\sum_{m \ge n} \left((\lambda^{k,n}_\cdot) * \ldots * (\lambda^{1,\cdot}_\cdot)\right)_m x_m^{(k)}\right)_{n \in \mathbb{N}}$ converges.
+\begin{lemma}\label{lem:komlos_convex_weights}
+  \lean{komlos_convex_weights}
+Let $E$ be a Hilbert space and for $i \in \mathbb{N}$, let $(x_n^{(i)})_{n \in \mathbb{N}}$ be a bounded sequence in $E$. Then there exists a sequence of convex weights $(\lambda^{k,n}_\cdot)_{k, n \in \mathbb{N}}$ with $\lambda^{k,n}_m = 0$ for $m < n$ such that for all $k \in \mathbb{N}$, $\left(\sum_{m \ge n} \left((\lambda^{k,n}_\cdot) * \ldots * (\lambda^{1,\cdot}_\cdot)\right)_m x_m^{(k)}\right)_{n \in \mathbb{N}}$ converges.
 \end{lemma}
 
 \begin{proof}
   \uses{lem:komlos_norm,def:convex_weights_product}
 First by Lemma~\ref{lem:komlos_norm} applied to $(x_n^{(1)})_{n\in\mathbb{N}}$ in the Hilbert space $E$, there exist $g_n^1 \in convex(x_n^{(1)}, x_{n+1}^{(1)}, \ldots)$ (call its weights $\lambda^{1,n}_n,\cdots,\lambda^{1,n}_{N^1_n}$) such that $g_n^1$ converges to some $g^1$.
 
-Secondly define $\tilde{g}_n^2$, convex combination of $x_n^{(2)}, x_{n+1}^{(2)}, \ldots$ with weights $\lambda^{1,n}_n,\cdots,\lambda^{1,n}_{N^1_n}$.
-Applying lemma~\ref{lem:komlos_norm} to $(\tilde{g}_n^2)_{n\in\mathbb{N}}$ gives us $g_n^2 \in convex(\tilde{g}_n^2, \tilde{g}_{n+1}^2, \ldots)$ (call its weights $\lambda^{1,n}_n,\cdots,\lambda^{2,n}_{N^2_n}$) such that $g_n^2$ converges to some $g^2$.
+Secondly define $\tilde{g}_n^1$, convex combination of $x_n^{(2)}, x_{n+1}^{(2)}, \ldots$ with weights $\lambda^{1,n}_n,\cdots,\lambda^{1,n}_{N^1_n}$.
+Applying lemma~\ref{lem:komlos_norm} to $(\tilde{g}_n^1)_{n\in\mathbb{N}}$ gives us $g_n^2 \in convex(\tilde{g}_n^1, \tilde{g}_{n+1}^1, \ldots)$ (call its weights $\lambda^{2,n}_n,\cdots,\lambda^{2,n}_{N^2_n}$) such that $g_n^2$ converges to some $g^2$.
 $g_n^2$ is a convex combination of $x_n^{(2)}, x_{n+1}^{(2)}, \ldots$ with weights $(\lambda^{2,n}_\cdot) * (\lambda^{1,\cdot}_\cdot)$.
 
 We continue iterating this process inductively.
 At iteration $k$ we have weights $(\lambda^{k,n}_\cdot * \ldots * \lambda^{1,\cdot}_\cdot)$.
-We define $\tilde{g}_n^{k+1}$ as the convex combination of $x_n^{(k+1)}, x_{n+1}^{(k+1)}, \ldots$ with those weights:
-\[ \tilde{g}_n^{k+1} = \sum_{l} (\lambda^{k,n}_\cdot * \ldots * \lambda^{1,\cdot}_\cdot)_l x^{(k+1)}_l \]
-We apply Lemma~\ref{lem:komlos_norm} to $(\tilde{g}_n^{k+1})_{n\in\mathbb{N}}$ to get $g_n^{k+1} \in convex(\tilde{g}_n^{k+1}, \tilde{g}_{n+1}^{k+1}, \ldots)$ such that $g_n^{k+1}$ converges to some $g^{k+1}$. We denote its weights by $\lambda^{k+1,n}_n,\cdots,\lambda^{k+1,n}_{N^{k+1}_n}$ and can then write:
+We define $\tilde{g}_n^k$ as the convex combination of $x_n^{(k+1)}, x_{n+1}^{(k+1)}, \ldots$ with those weights:
+\[ \tilde{g}_n^k = \sum_{l} (\lambda^{k,n}_\cdot * \ldots * \lambda^{1,\cdot}_\cdot)_l x^{(k+1)}_l \]
+We apply Lemma~\ref{lem:komlos_norm} to $(\tilde{g}_n^k)_{n\in\mathbb{N}}$ to get $g_n^{k+1} \in convex(\tilde{g}_n^k, \tilde{g}_{n+1}^k, \ldots)$ such that $g_n^{k+1}$ converges to some $g^{k+1}$. We denote its weights by $\lambda^{k+1,n}_n,\cdots,\lambda^{k+1,n}_{N^{k+1}_n}$ and can then write:
 
 \begin{align*}
-  g_n^{k+1} & = \sum_{m} \lambda^{k+1,n}_m \tilde{g}_m^{k+1}
+  g_n^{k+1} & = \sum_{m} \lambda^{k+1,n}_m \tilde{g}_m^k
   = \sum_{m} \lambda^{k+1,n}_m \left( \sum_{l} (\lambda^{k,m}_\cdot * \ldots * \lambda^{1,\cdot}_\cdot)_l x_l^{(k+1)} \right) \\
   & = \sum_{l} \left( \sum_{m} \lambda^{k+1,n}_m (\lambda^{k,m}_\cdot * \ldots * \lambda^{1,\cdot}_\cdot)_l \right) x_l^{(k+1)} \\
   & = \sum_{l} (\lambda^{k+1,n}_{\cdot} * (\lambda^{k,\cdot}_\cdot * \ldots * \lambda^{1,\cdot}_\cdot))_l x_l^{(k+1)}

From 9bd30d48fbc718b032a82568aae1ee4f523614ca Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Thu, 9 Apr 2026 10:23:08 +0200
Subject: [PATCH 04/37] feat(Komlos Lemma): detailed formal draft for Komlos
 construction

* The lemma komlos_step contains the main construction for building the convex weights \lambda^{k,n}_m. The proof still contains sorrys but the main argument is formalised which makes me confident that the approach to formalising convex weights is going to work.
* The file ConvexWeights.lean contains auxiliary constructions related to convex weights, e.g. their (iterated) multiplication
---
 .../StochasticIntegral/ConvexWeights.lean     | 46 ++++++++--
 BrownianMotion/StochasticIntegral/Komlos.lean | 92 +++++++++++++++++++
 blueprint/lean_decls                          |  1 +
 3 files changed, 131 insertions(+), 8 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
index e0a587ec..92952882 100644
--- a/BrownianMotion/StochasticIntegral/ConvexWeights.lean
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -3,9 +3,7 @@ module
 public import Mathlib.Analysis.InnerProductSpace.Defs
 
 /-
-# Convex Weights
-This is kept in a separate file for now, might become part of `Mathlib.Analysis.Convex.Combination`
-when upstreamed.
+# Lemmas on Convex Weights
 -/
 
 @[expose] public section
@@ -15,12 +13,16 @@ variable {R E : Type*} [Field R] [AddCommGroup E] [Module R E]
 
 lemma convex_weights_of_mem_convexHull_indexed {s : ι → E} {x : E}
   (h : x ∈ convexHull R (Set.range s)) :
-    ∃ (w : ι →₀ R), (∀ i, 0 ≤ w i) ∧ ∑ i : w.support, w i = 1 ∧ ∑ i : w.support, w i • s i = x := by
+    ∃ (w : ι →₀ R), (∀ i, 0 ≤ w i) ∧ ∑ i ∈ w.support, w i = 1 ∧ ∑ i ∈ w.support, w i • s i = x := by
       sorry
 
+lemma finsupp_choice {X ι₁ ι₂ : Type*} [Zero X] {P : ι₁ → (ι₂ → X) → Prop}
+  (h : ∀ i : ι₁, ∃ (w : ι₂ →₀ X), P i w) :
+  ∃ W : ι₁ → ι₂ →₀ X, ∀ i : ι₁, P i (W i) :=
+  ⟨fun i => Classical.choose (h i), fun i => Classical.choose_spec (h i)⟩
+
 def convexWeights (cw : ι →₀ ℝ) : Prop :=
-  ∀ n : cw.support, 0 ≤ cw n ∧ ∑ n : cw.support, cw n = 1
--- We might also choose the equivalent condition ∀ n : ι, 0 ≤ cw
+  ∀ n ∈ cw.support, 0 ≤ cw n ∧ ∑ n ∈ cw.support, cw n = 1
 
 noncomputable section
 
@@ -38,11 +40,39 @@ def cwmul (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) : ℕ →₀ ℝ :=
       · simp [ha]
       · simp [h k (Finsupp.mem_support_iff.mp hk)])
 
+lemma cwmul_eq (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) :
+  cwmul a b = fun m ↦ ∑ k ∈ a.support, a k * (b k m) := rfl
+
+lemma cwmul_eq' (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) :
+  cwmul a b = fun m ↦ ∑ k ∈ a.support.biUnion (fun k ↦ (b k).support), a k * (b k m) :=
+  sorry
+
 lemma convexWeights_cwmul {a : ℕ →₀ ℝ} {b : ℕ → ℕ →₀ ℝ}
   (ha : convexWeights a) (hb : ∀ k, convexWeights (b k)) : convexWeights (cwmul a b) := by
   sorry
 
-def cwIteratedMul (k : ℕ) (cw : ℕ → ℕ → ℕ →₀ ℝ) : ℕ → ℕ →₀ ℝ :=
+def cwIteratedMul (cw : ℕ → ℕ → ℕ →₀ ℝ) (k : ℕ) : ℕ → ℕ →₀ ℝ :=
   match k with
   | 0 => fun n ↦ cw 0 n
-  | k + 1 => fun n ↦ cwmul (cw k n) (cwIteratedMul k cw)
+  | k + 1 => fun n ↦ cwmul (cw (k+1) n) (cwIteratedMul cw k)
+
+lemma cwIteratedMul_update (cw : ℕ → ℕ → ℕ →₀ ℝ) {k k' : ℕ} {f : ℕ → ℕ →₀ ℝ} (hk' : k' > k) :
+  cwIteratedMul cw k = cwIteratedMul (Function.update cw k' f) k := by
+  sorry
+
+lemma cwmul_support_subset (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) :
+    (cwmul a b).support ⊆ a.support.biUnion (fun k ↦ (b k).support) :=
+  Finsupp.support_onFinset_subset
+
+lemma support_subset_cwmul_support {a : ℕ →₀ ℝ} {b : ℕ → ℕ →₀ ℝ} {i : ℕ} (hi : i ∈ a.support)
+    (ha : ∀ k ∈ a.support, 0 ≤ a k) (hb : ∀ k ∈ a.support, ∀ m, 0 ≤ b k m) :
+    (b i).support ⊆ (cwmul a b).support := by
+  intro j hj
+  simp only [cwmul, Finsupp.mem_support_onFinset]
+  apply ne_of_gt
+  apply Finset.sum_pos'
+  · intro k hk
+    exact mul_nonneg (ha k hk) (hb k hk j)
+  · refine ⟨i, hi, mul_pos ?_ ?_⟩
+    · exact lt_of_le_of_ne (ha i hi) (Ne.symm (Finsupp.mem_support_iff.mp hi))
+    · exact lt_of_le_of_ne (hb i hi j) (Ne.symm (Finsupp.mem_support_iff.mp hj))
diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index d701645c..cc0c1425 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -164,6 +164,98 @@ lemma komlos_convergence [NormedAddCommGroup E] [Module ℝ E] [IsBoundedSMul 
   simp only [one_mul, gt_iff_lt]
   exact RCLike.ofReal_lt_ofReal.mp (hN n hn)
 
+noncomputable section
+variable [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E] [Module ℝ E]
+
+def gtilde (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E) (k : ℕ) (n : ℕ) : E :=
+  ∑ m ∈ (cwIteratedMul cw k n).support, (cwIteratedMul cw k n m) • (x (k+1) m)
+  -- note that it has to be k+1, not k for x!
+
+omit [InnerProductSpace ℝ E] [CompleteSpace E] in
+lemma gtilde_update (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E) {k k' : ℕ} {f : ℕ → ℕ →₀ ℝ}
+    (hk' : k' > k) :
+    gtilde cw x k = gtilde (Function.update cw k' f) x k := by
+  funext n
+  simp only [gtilde]
+  rw [← cwIteratedMul_update cw hk']
+
+/-
+TODO: There needs to be a condition that all cw are nonnegative! This leads to more puzzling when
+using this lemma to show the full komlos statement.
+-/
+lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
+  {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ)
+  (cw : ℕ → ℕ → ℕ →₀ ℝ) (hcw: ∀ k n m, 0 ≤ cw k n m) :
+  ∃ (cw_new : ℕ → ℕ → ℕ →₀ ℝ),
+    (∃ glim : E, Tendsto (fun n ↦ ∑ m ∈ (cwIteratedMul cw_new (k + 1) n).support,
+      cwIteratedMul cw_new (k + 1) n m • x (k+1) n) atTop (𝓝 glim))
+    ∧ (∀ i ≤ k, cw_new i = cw i)
+    ∧ (∀ k n m, 0 ≤ cw_new k n m) := by
+
+  have gtilde_bound : ∃ M, ∀ n, ‖gtilde cw x k n‖ ≤ M := by sorry -- maybe turn this into a lemma
+
+  obtain ⟨g_step, gstep_conv, gstep_lim⟩ := komlos_norm (gtilde_bound)
+  -- Change this: We want ∑ i : w.support, w i • gtilde cw x k i = g_step n
+  -- and an extra condition that the weights are 0 up to index n!
+
+  have cw_step_exists : ∃ w : ℕ → ℕ →₀ ℝ,
+    (∀ n m, 0 ≤ w n m) ∧ (∀ n, ∀ m ≤ n, w n m = 0)
+    ∧ (∀ n, ∑ i ∈ (w n).support, w n i = 1)
+    ∧ ∀ n, ∑ i ∈ (w n).support, (w n) i • gtilde cw x k i = g_step n := by
+    have original_weights : ∀ n, ∃ w : ℕ →₀ ℝ, (∀ i, 0 ≤ w i) ∧ ∑ i ∈ w.support, w i = 1
+      ∧ ∑ i ∈ w.support, w i • gtilde cw x k (n + i) = g_step n := by
+      exact (fun n ↦ convex_weights_of_mem_convexHull_indexed (gstep_conv n))
+
+    -- Need to use choice to finish this, along the lines of:
+    -- exact ⟨fun n => Classical.choose (weights n), fun n => Classical.choose_spec (weights n)⟩
+    sorry
+
+  obtain ⟨cw_step, ⟨hnonneg, hzero, hsum, hcombo⟩⟩ := cw_step_exists
+
+  let cw_new := Function.update cw (k+1) cw_step
+
+  have g_new_expression (n : ℕ) : g_step n = ∑ m ∈ (cwIteratedMul cw_new (k + 1) n).support,
+    cwIteratedMul cw_new (k + 1) n m • x (k+1) m := by
+    rw [← hcombo n]
+
+    have aux: (cwIteratedMul cw_new (k + 1) n) = (cwmul (cw_step n) (cwIteratedMul cw k)) := by
+      rw [cwIteratedMul]
+      beta_reduce
+      unfold cw_new
+      rw [Function.update_self, cwIteratedMul_update cw (show k+1 > k by omega)]
+
+    rw [aux]
+    unfold gtilde
+    rw [cwmul_eq]
+    beta_reduce
+
+    set cwold := cwIteratedMul cw k
+    simp_rw [Finset.sum_smul, Finset.smul_sum, smul_smul]
+    rw [Finset.sum_comm]
+
+    refine Finset.sum_congr rfl ?_
+    intro i hi
+
+    have subset: (cwold i).support ⊆ (cwmul (cw_step n) cwold).support := by
+      refine support_subset_cwmul_support hi ?_ ?_
+      · sorry
+      · unfold cwold -- here we need to use hcw, probably through a further intermediate lemma
+        sorry
+
+    -- TODO: Use Finset.sum_subset or similar to finish this proof
+    sorry
+
+  have old_indices_untouched: ∀ i ≤ k, cw_new i = cw i := sorry -- trivial by construction
+
+  sorry
+
+lemma komlos_convex_weights [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
+    {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
+    ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ),
+    let g k n := ∑ m ∈ (cwIteratedMul cw k n).support, cwIteratedMul cw k n m • (gtilde cw x k n);
+    ∀ k : ℕ, ∃ glim : E, Tendsto (g k) atTop (𝓝 glim) := by
+  sorry
+
 theorem komlos_L1 [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
     [MeasurableSpace E] [BorelSpace E] {f : ℕ → Ω → E} {P : Measure Ω}
     (hf : UniformIntegrable f 1 P) :
diff --git a/blueprint/lean_decls b/blueprint/lean_decls
index e7bb5f15..ef621ce8 100644
--- a/blueprint/lean_decls
+++ b/blueprint/lean_decls
@@ -397,6 +397,7 @@ tendsto_of_no_upcrossings
 komlos_convex
 komlos_norm
 cwmul
+komlos_convex_weights
 komlos_L1
 komlos_ennreal
 MeasureTheory.predictablePart

From e2d056d3c2f8f729183749fd7ef698edab8f73d8 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Thu, 9 Apr 2026 12:45:01 +0200
Subject: [PATCH 05/37] fix(Komlos lemma): correct typos and author note

---
 BrownianMotion/StochasticIntegral/Komlos.lean | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index cc0c1425..434df368 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -1,7 +1,7 @@
 /-
 Copyright (c) 2025 Rémy Degenne. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Rémy Degenne
+Authors: Rémy Degenne, Jonas Bayer
 -/
 module
 
@@ -179,24 +179,18 @@ lemma gtilde_update (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E
   simp only [gtilde]
   rw [← cwIteratedMul_update cw hk']
 
-/-
-TODO: There needs to be a condition that all cw are nonnegative! This leads to more puzzling when
-using this lemma to show the full komlos statement.
--/
 lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
   {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ)
   (cw : ℕ → ℕ → ℕ →₀ ℝ) (hcw: ∀ k n m, 0 ≤ cw k n m) :
   ∃ (cw_new : ℕ → ℕ → ℕ →₀ ℝ),
     (∃ glim : E, Tendsto (fun n ↦ ∑ m ∈ (cwIteratedMul cw_new (k + 1) n).support,
-      cwIteratedMul cw_new (k + 1) n m • x (k+1) n) atTop (𝓝 glim))
+      cwIteratedMul cw_new (k + 1) n m • x (k+1) m) atTop (𝓝 glim))
     ∧ (∀ i ≤ k, cw_new i = cw i)
     ∧ (∀ k n m, 0 ≤ cw_new k n m) := by
 
   have gtilde_bound : ∃ M, ∀ n, ‖gtilde cw x k n‖ ≤ M := by sorry -- maybe turn this into a lemma
 
   obtain ⟨g_step, gstep_conv, gstep_lim⟩ := komlos_norm (gtilde_bound)
-  -- Change this: We want ∑ i : w.support, w i • gtilde cw x k i = g_step n
-  -- and an extra condition that the weights are 0 up to index n!
 
   have cw_step_exists : ∃ w : ℕ → ℕ →₀ ℝ,
     (∀ n m, 0 ≤ w n m) ∧ (∀ n, ∀ m ≤ n, w n m = 0)
@@ -252,7 +246,8 @@ lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
 lemma komlos_convex_weights [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
     {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
     ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ),
-    let g k n := ∑ m ∈ (cwIteratedMul cw k n).support, cwIteratedMul cw k n m • (gtilde cw x k n);
+    let g k n := ∑ m ∈ (cwIteratedMul cw (k + 1) n).support,
+      cwIteratedMul cw (k + 1) n m • x (k+1) m;
     ∀ k : ℕ, ∃ glim : E, Tendsto (g k) atTop (𝓝 glim) := by
   sorry
 

From 09843d65f0d03f1891f7227d92548de04742ef20 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Sun, 12 Apr 2026 15:46:18 +0200
Subject: [PATCH 06/37] feat(Komlos): congruence lemma for komlos_formula

---
 .../StochasticIntegral/ConvexWeights.lean     | 15 +++++
 BrownianMotion/StochasticIntegral/Komlos.lean | 63 ++++++++++++++++---
 2 files changed, 71 insertions(+), 7 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
index 92952882..dbfe6d4a 100644
--- a/BrownianMotion/StochasticIntegral/ConvexWeights.lean
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -60,6 +60,21 @@ lemma cwIteratedMul_update (cw : ℕ → ℕ → ℕ →₀ ℝ) {k k' : ℕ} {f
   cwIteratedMul cw k = cwIteratedMul (Function.update cw k' f) k := by
   sorry
 
+lemma cwIteratedMul_cong (cw1 cw2 : ℕ → ℕ → ℕ →₀ ℝ) (k : ℕ) (h : ∀ i ≤ k, cw1 i = cw2 i) :
+  cwIteratedMul cw1 k = cwIteratedMul cw2 k := by
+  induction k with
+  | zero => rw [cwIteratedMul]
+            simp_all only [nonpos_iff_eq_zero, forall_eq]
+            rfl
+  | succ n hn =>
+    have : cwIteratedMul cw1 n = cwIteratedMul cw2 n := by
+      apply hn
+      intro i hi
+      exact h i (show i ≤ n + 1 by omega)
+    rw [cwIteratedMul, this, h]
+    · rw [cwIteratedMul]
+    · simp
+
 lemma cwmul_support_subset (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) :
     (cwmul a b).support ⊆ a.support.biUnion (fun k ↦ (b k).support) :=
   Finsupp.support_onFinset_subset
diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 434df368..e6e3baca 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -179,12 +179,21 @@ lemma gtilde_update (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E
   simp only [gtilde]
   rw [← cwIteratedMul_update cw hk']
 
+def komlos_formula (x : ℕ → ℕ → E) (cw : ℕ → ℕ → ℕ →₀ ℝ) (k n : ℕ) : E :=
+  ∑ m ∈ (cwIteratedMul cw k n).support, cwIteratedMul cw k n m • x k m
+
+lemma komlos_formula_cong (x : ℕ → ℕ → E) {cw1 : ℕ → ℕ → ℕ →₀ ℝ} {cw2 : ℕ → ℕ → ℕ →₀ ℝ} {k : ℕ}
+  (h : ∀ k' ≤ k, cw1 k' = cw2 k') :
+  komlos_formula x cw1 k = komlos_formula x cw2 k := by
+  unfold komlos_formula
+  rw [cwIteratedMul_cong]
+  exact h
+
 lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
   {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ)
   (cw : ℕ → ℕ → ℕ →₀ ℝ) (hcw: ∀ k n m, 0 ≤ cw k n m) :
   ∃ (cw_new : ℕ → ℕ → ℕ →₀ ℝ),
-    (∃ glim : E, Tendsto (fun n ↦ ∑ m ∈ (cwIteratedMul cw_new (k + 1) n).support,
-      cwIteratedMul cw_new (k + 1) n m • x (k+1) m) atTop (𝓝 glim))
+    (∃ glim : E, Tendsto (komlos_formula x cw (k+1)) atTop (𝓝 glim))
     ∧ (∀ i ≤ k, cw_new i = cw i)
     ∧ (∀ k n m, 0 ≤ cw_new k n m) := by
 
@@ -243,13 +252,53 @@ lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
 
   sorry
 
+lemma komlos_up_to [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
+  {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
+  ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ),
+    (∀ k' ≤ k, ∃ glim : E, Tendsto (komlos_formula x cw k') atTop (𝓝 glim))
+    ∧ (∀ k n m, 0 ≤ cw k n m) := by
+    sorry
+
+lemma komlos_at [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
+  {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
+  ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ),
+    (∃ glim : E, Tendsto (komlos_formula x cw k) atTop (𝓝 glim))
+    ∧ (∀ k n m, 0 ≤ cw k n m) := by
+    sorry
+
 lemma komlos_convex_weights [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
     {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
-    ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ),
-    let g k n := ∑ m ∈ (cwIteratedMul cw (k + 1) n).support,
-      cwIteratedMul cw (k + 1) n m • x (k+1) m;
-    ∀ k : ℕ, ∃ glim : E, Tendsto (g k) atTop (𝓝 glim) := by
-  sorry
+    ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ), ∀ k : ℕ,
+    ∃ glim : E, Tendsto (komlos_formula x cw k) atTop (𝓝 glim) := by
+
+  let cwStage (k : ℕ) : ℕ → ℕ → ℕ →₀ ℝ := Classical.choose (komlos_up_to hx k)
+
+  have hcwStage (k : ℕ) : ∀ k' ≤ k,
+    ∃ glim : E, Tendsto (komlos_formula x (cwStage k) k') atTop (𝓝 glim) := by
+    unfold cwStage
+    let ⟨left, _⟩ := (Classical.choose_spec (komlos_up_to hx k))
+    apply left
+
+  have hcwStage2 (k : ℕ) :
+    ∃ glim : E, Tendsto (komlos_formula x (cwStage k) k) atTop (𝓝 glim) := by
+    exact hcwStage k k (by omega)
+
+  let cwProp (k : ℕ) : _ := Classical.choose_spec (komlos_up_to hx k)
+
+  let cw (k : ℕ) : ℕ → ℕ →₀ ℝ := cwStage k k
+
+  have agreement (k i : ℕ) (hi : i ≤ k) :
+    cw i = cwStage k i := by
+    sorry
+
+  have transfer (k : ℕ) : komlos_formula x cw k = komlos_formula x (cwStage k) k := by
+    apply komlos_formula_cong x
+    exact agreement k
+
+  use cw
+  intro k
+  simp_rw [transfer k]
+  exact hcwStage2 k
 
 theorem komlos_L1 [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
     [MeasurableSpace E] [BorelSpace E] {f : ℕ → Ω → E} {P : Measure Ω}

From f50663448558dad4fdaa88dd8a8b2a2e4727511b Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Sun, 12 Apr 2026 19:19:39 +0100
Subject: [PATCH 07/37] refactor(ConvexWeights): golf proof

---
 .../StochasticIntegral/ConvexWeights.lean        | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
index dbfe6d4a..c4e152ea 100644
--- a/BrownianMotion/StochasticIntegral/ConvexWeights.lean
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -60,20 +60,14 @@ lemma cwIteratedMul_update (cw : ℕ → ℕ → ℕ →₀ ℝ) {k k' : ℕ} {f
   cwIteratedMul cw k = cwIteratedMul (Function.update cw k' f) k := by
   sorry
 
-lemma cwIteratedMul_cong (cw1 cw2 : ℕ → ℕ → ℕ →₀ ℝ) (k : ℕ) (h : ∀ i ≤ k, cw1 i = cw2 i) :
+lemma cwIteratedMul_cong {cw1 cw2 : ℕ → ℕ → ℕ →₀ ℝ} {k : ℕ} (h : ∀ i ≤ k, cw1 i = cw2 i) :
   cwIteratedMul cw1 k = cwIteratedMul cw2 k := by
   induction k with
-  | zero => rw [cwIteratedMul]
-            simp_all only [nonpos_iff_eq_zero, forall_eq]
-            rfl
+  | zero => simp_all only [cwIteratedMul, nonpos_iff_eq_zero, forall_eq]
   | succ n hn =>
-    have : cwIteratedMul cw1 n = cwIteratedMul cw2 n := by
-      apply hn
-      intro i hi
-      exact h i (show i ≤ n + 1 by omega)
-    rw [cwIteratedMul, this, h]
-    · rw [cwIteratedMul]
-    · simp
+    have : cwIteratedMul cw1 n = cwIteratedMul cw2 n :=
+      hn (fun i hi => h i (Nat.le_succ_of_le hi))
+    simp only [cwIteratedMul, Std.le_refl, h, this]
 
 lemma cwmul_support_subset (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) :
     (cwmul a b).support ⊆ a.support.biUnion (fun k ↦ (b k).support) :=

From 836eba6c95de9f209deed284f9170fbd301082bf Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Tue, 14 Apr 2026 09:39:15 +0100
Subject: [PATCH 08/37] feat(Komlos): complete scaffolding for
 komlos_convex_weights

only easy sorrys remaining
---
 BrownianMotion/StochasticIntegral/Komlos.lean | 83 +++++++++++++------
 1 file changed, 56 insertions(+), 27 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index e6e3baca..f3c0088a 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -189,11 +189,18 @@ lemma komlos_formula_cong (x : ℕ → ℕ → E) {cw1 : ℕ → ℕ → ℕ →
   rw [cwIteratedMul_cong]
   exact h
 
+lemma komlos_base [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
+  {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
+  ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ),
+    (∃ glim : E, Tendsto (komlos_formula x cw 0) atTop (𝓝 glim))
+    ∧ (∀ k n m, 0 ≤ cw k n m) := by sorry
+
+
 lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
   {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ)
   (cw : ℕ → ℕ → ℕ →₀ ℝ) (hcw: ∀ k n m, 0 ≤ cw k n m) :
   ∃ (cw_new : ℕ → ℕ → ℕ →₀ ℝ),
-    (∃ glim : E, Tendsto (komlos_formula x cw (k+1)) atTop (𝓝 glim))
+    (∃ glim : E, Tendsto (komlos_formula x cw_new (k+1)) atTop (𝓝 glim))
     ∧ (∀ i ≤ k, cw_new i = cw i)
     ∧ (∀ k n m, 0 ≤ cw_new k n m) := by
 
@@ -252,46 +259,68 @@ lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
 
   sorry
 
-lemma komlos_up_to [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
-  {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
-  ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ),
-    (∀ k' ≤ k, ∃ glim : E, Tendsto (komlos_formula x cw k') atTop (𝓝 glim))
-    ∧ (∀ k n m, 0 ≤ cw k n m) := by
+def komlos_stage [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
+  {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (stage : ℕ) :
+  { w : ℕ → ℕ → ℕ →₀ ℝ // ∀ k n m, 0 ≤ w k n m } :=
+  match stage with
+  | 0 => by
+    use Classical.choose (komlos_base hx)
     sorry
+  | stage+1 => by
+      let ⟨pre, hpre⟩ := komlos_stage hx stage
+      let aux := komlos_step hx stage pre hpre
+      use Classical.choose (aux)
+      sorry
 
-lemma komlos_at [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
+lemma komlos_stage_lim [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
   {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
-  ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ),
-    (∃ glim : E, Tendsto (komlos_formula x cw k) atTop (𝓝 glim))
-    ∧ (∀ k n m, 0 ≤ cw k n m) := by
-    sorry
+  (∃ glim : E, Tendsto (komlos_formula x (komlos_stage hx k) k) atTop (𝓝 glim)) := by
+  induction k with
+  | zero => sorry
+  | succ k _ =>
+    let aux := komlos_step hx k (komlos_stage hx k).val (komlos_stage hx k).prop
+    exact Classical.choose_spec aux |>.1
+
+lemma agreement_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
+  {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
+  ∀ i ≤ k, (komlos_stage hx k).val i = (komlos_stage hx (k+1)).val i := by
+  intro i hi
+  let aux := komlos_step hx k (komlos_stage hx k).val (komlos_stage hx k).prop
+  let ⟨_, aux2, _⟩ := Classical.choose_spec aux
+  exact Eq.symm (aux2 i hi)
+
+lemma agreement_needed [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
+  {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (i k : ℕ) (hi : i ≤ k) :
+  (komlos_stage hx i).val i = (komlos_stage hx k).val i := by
+  let n := k-i
+  suffices (komlos_stage hx i).val i = (komlos_stage hx (i+n)).val i from by
+    unfold n at this
+    rw [show i + (k - i) = k by omega] at this
+    exact this
+  induction n with
+  | zero => rfl
+  | succ n hn =>
+  rw [← add_assoc, hn]
+  apply agreement_step hx (i+n) i (by omega)
 
 lemma komlos_convex_weights [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
     {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
     ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ), ∀ k : ℕ,
     ∃ glim : E, Tendsto (komlos_formula x cw k) atTop (𝓝 glim) := by
 
-  let cwStage (k : ℕ) : ℕ → ℕ → ℕ →₀ ℝ := Classical.choose (komlos_up_to hx k)
-
-  have hcwStage (k : ℕ) : ∀ k' ≤ k,
-    ∃ glim : E, Tendsto (komlos_formula x (cwStage k) k') atTop (𝓝 glim) := by
-    unfold cwStage
-    let ⟨left, _⟩ := (Classical.choose_spec (komlos_up_to hx k))
-    apply left
-
   have hcwStage2 (k : ℕ) :
-    ∃ glim : E, Tendsto (komlos_formula x (cwStage k) k) atTop (𝓝 glim) := by
-    exact hcwStage k k (by omega)
-
-  let cwProp (k : ℕ) : _ := Classical.choose_spec (komlos_up_to hx k)
+    ∃ glim : E, Tendsto (komlos_formula x (komlos_stage hx k).val k) atTop (𝓝 glim) := by
+    apply komlos_stage_lim
 
-  let cw (k : ℕ) : ℕ → ℕ →₀ ℝ := cwStage k k
+  let cw (k : ℕ) : ℕ → ℕ →₀ ℝ := (komlos_stage hx k).val k
 
   have agreement (k i : ℕ) (hi : i ≤ k) :
-    cw i = cwStage k i := by
-    sorry
+    cw i = (komlos_stage hx k).val i := by
+    unfold cw
+    apply agreement_needed hx
+    exact hi
 
-  have transfer (k : ℕ) : komlos_formula x cw k = komlos_formula x (cwStage k) k := by
+  have transfer (k : ℕ) : komlos_formula x cw k = komlos_formula x (komlos_stage hx k).val k := by
     apply komlos_formula_cong x
     exact agreement k
 

From 948367609d1533517ca02c64c9bdcfdddecbd8df Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Tue, 21 Apr 2026 11:15:00 +0100
Subject: [PATCH 09/37] refactor: rename to follow Mathlib style guide

---
 .../StochasticIntegral/ConvexWeights.lean     | 61 ++++++--------
 BrownianMotion/StochasticIntegral/Komlos.lean | 84 +++++++++++++------
 blueprint/lean_decls                          |  4 +-
 blueprint/src/chapters/doob_meyer.tex         |  2 +-
 4 files changed, 86 insertions(+), 65 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
index c4e152ea..518a33d4 100644
--- a/BrownianMotion/StochasticIntegral/ConvexWeights.lean
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -12,21 +12,13 @@ variable {R E : Type*} [Field R] [AddCommGroup E] [Module R E]
   [LinearOrder R] [IsStrictOrderedRing R] {ι : Type*}
 
 lemma convex_weights_of_mem_convexHull_indexed {s : ι → E} {x : E}
-  (h : x ∈ convexHull R (Set.range s)) :
+    (h : x ∈ convexHull R (Set.range s)) :
     ∃ (w : ι →₀ R), (∀ i, 0 ≤ w i) ∧ ∑ i ∈ w.support, w i = 1 ∧ ∑ i ∈ w.support, w i • s i = x := by
       sorry
 
-lemma finsupp_choice {X ι₁ ι₂ : Type*} [Zero X] {P : ι₁ → (ι₂ → X) → Prop}
-  (h : ∀ i : ι₁, ∃ (w : ι₂ →₀ X), P i w) :
-  ∃ W : ι₁ → ι₂ →₀ X, ∀ i : ι₁, P i (W i) :=
-  ⟨fun i => Classical.choose (h i), fun i => Classical.choose_spec (h i)⟩
-
-def convexWeights (cw : ι →₀ ℝ) : Prop :=
-  ∀ n ∈ cw.support, 0 ≤ cw n ∧ ∑ n ∈ cw.support, cw n = 1
-
 noncomputable section
 
-def cwmul (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) : ℕ →₀ ℝ :=
+def convexWeightsMul (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) : ℕ →₀ ℝ :=
   Finsupp.onFinset (a.support.biUnion (fun k ↦ (b k).support))
     (fun m ↦ ∑ k ∈ a.support, a k * (b k m))
     (fun m hm ↦ by
@@ -40,44 +32,43 @@ def cwmul (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) : ℕ →₀ ℝ :=
       · simp [ha]
       · simp [h k (Finsupp.mem_support_iff.mp hk)])
 
-lemma cwmul_eq (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) :
-  cwmul a b = fun m ↦ ∑ k ∈ a.support, a k * (b k m) := rfl
 
-lemma cwmul_eq' (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) :
-  cwmul a b = fun m ↦ ∑ k ∈ a.support.biUnion (fun k ↦ (b k).support), a k * (b k m) :=
-  sorry
+lemma convexWeightsMul_eq (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) :
+  convexWeightsMul a b = fun m ↦ ∑ k ∈ a.support, a k * (b k m) := rfl
 
-lemma convexWeights_cwmul {a : ℕ →₀ ℝ} {b : ℕ → ℕ →₀ ℝ}
-  (ha : convexWeights a) (hb : ∀ k, convexWeights (b k)) : convexWeights (cwmul a b) := by
-  sorry
+-- Need to add lemmas that show compatibility between convexWeightsMul (+ iterated variant) with the complex
+-- weights conditions: nonegativity and summing up to one
 
-def cwIteratedMul (cw : ℕ → ℕ → ℕ →₀ ℝ) (k : ℕ) : ℕ → ℕ →₀ ℝ :=
-  match k with
+def convexWeightsConvolution (cw : ℕ → ℕ → ℕ →₀ ℝ) : ℕ → ℕ → ℕ →₀ ℝ
   | 0 => fun n ↦ cw 0 n
-  | k + 1 => fun n ↦ cwmul (cw (k+1) n) (cwIteratedMul cw k)
+  | k + 1 => fun n ↦ convexWeightsMul (cw (k+1) n) (convexWeightsConvolution cw k)
 
-lemma cwIteratedMul_update (cw : ℕ → ℕ → ℕ →₀ ℝ) {k k' : ℕ} {f : ℕ → ℕ →₀ ℝ} (hk' : k' > k) :
-  cwIteratedMul cw k = cwIteratedMul (Function.update cw k' f) k := by
-  sorry
 
-lemma cwIteratedMul_cong {cw1 cw2 : ℕ → ℕ → ℕ →₀ ℝ} {k : ℕ} (h : ∀ i ≤ k, cw1 i = cw2 i) :
-  cwIteratedMul cw1 k = cwIteratedMul cw2 k := by
+lemma convexWeightsConvolution_cong {cw1 cw2 : ℕ → ℕ → ℕ →₀ ℝ} {k : ℕ}
+    (h : ∀ i ≤ k, cw1 i = cw2 i) :
+    convexWeightsConvolution cw1 k = convexWeightsConvolution cw2 k := by
   induction k with
-  | zero => simp_all only [cwIteratedMul, nonpos_iff_eq_zero, forall_eq]
+  | zero => simp_all only [convexWeightsConvolution, nonpos_iff_eq_zero, forall_eq]
   | succ n hn =>
-    have : cwIteratedMul cw1 n = cwIteratedMul cw2 n :=
+    have : convexWeightsConvolution cw1 n = convexWeightsConvolution cw2 n :=
       hn (fun i hi => h i (Nat.le_succ_of_le hi))
-    simp only [cwIteratedMul, Std.le_refl, h, this]
+    simp only [convexWeightsConvolution, Std.le_refl, h, this]
+
+lemma convexWeightsConvolution_update (cw : ℕ → ℕ → ℕ →₀ ℝ) {k k' : ℕ} {f : ℕ → ℕ →₀ ℝ}
+    (hk' : k' > k) :
+    convexWeightsConvolution cw k = convexWeightsConvolution (Function.update cw k' f) k := by
+  rw [convexWeightsConvolution_cong]
+  grind
 
-lemma cwmul_support_subset (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) :
-    (cwmul a b).support ⊆ a.support.biUnion (fun k ↦ (b k).support) :=
+lemma convexWeightsMul_support_subset (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) :
+    (convexWeightsMul a b).support ⊆ a.support.biUnion (fun k ↦ (b k).support) :=
   Finsupp.support_onFinset_subset
 
-lemma support_subset_cwmul_support {a : ℕ →₀ ℝ} {b : ℕ → ℕ →₀ ℝ} {i : ℕ} (hi : i ∈ a.support)
-    (ha : ∀ k ∈ a.support, 0 ≤ a k) (hb : ∀ k ∈ a.support, ∀ m, 0 ≤ b k m) :
-    (b i).support ⊆ (cwmul a b).support := by
+lemma support_subset_convexWeightsMul_support {a : ℕ →₀ ℝ} {b : ℕ → ℕ →₀ ℝ} {i : ℕ}
+    (hi : i ∈ a.support) (ha : ∀ k ∈ a.support, 0 ≤ a k) (hb : ∀ k ∈ a.support, ∀ m, 0 ≤ b k m) :
+    (b i).support ⊆ (convexWeightsMul a b).support := by
   intro j hj
-  simp only [cwmul, Finsupp.mem_support_onFinset]
+  simp only [convexWeightsMul, Finsupp.mem_support_onFinset]
   apply ne_of_gt
   apply Finset.sum_pos'
   · intro k hk
diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index f3c0088a..4949396c 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -168,39 +168,67 @@ noncomputable section
 variable [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E] [Module ℝ E]
 
 def gtilde (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E) (k : ℕ) (n : ℕ) : E :=
-  ∑ m ∈ (cwIteratedMul cw k n).support, (cwIteratedMul cw k n m) • (x (k+1) m)
+  ∑ m ∈ (convexWeightsConvolution cw k n).support, (convexWeightsConvolution cw k n m) • (x (k+1) m)
   -- note that it has to be k+1, not k for x!
 
+def gtilde' (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E) (k : ℕ) (n : ℕ) : E :=
+  (convexWeightsConvolution cw k n).sum (fun m cwm ↦ cwm • (x (k+1) m))
+
 omit [InnerProductSpace ℝ E] [CompleteSpace E] in
 lemma gtilde_update (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E) {k k' : ℕ} {f : ℕ → ℕ →₀ ℝ}
     (hk' : k' > k) :
     gtilde cw x k = gtilde (Function.update cw k' f) x k := by
   funext n
   simp only [gtilde]
-  rw [← cwIteratedMul_update cw hk']
+  rw [← convexWeightsConvolution_update cw hk']
 
-def komlos_formula (x : ℕ → ℕ → E) (cw : ℕ → ℕ → ℕ →₀ ℝ) (k n : ℕ) : E :=
-  ∑ m ∈ (cwIteratedMul cw k n).support, cwIteratedMul cw k n m • x k m
+def komlosFormula (x : ℕ → ℕ → E) (cw : ℕ → ℕ → ℕ →₀ ℝ) (k n : ℕ) : E :=
+  ∑ m ∈ (convexWeightsConvolution cw k n).support, convexWeightsConvolution cw k n m • x k m
 
-lemma komlos_formula_cong (x : ℕ → ℕ → E) {cw1 : ℕ → ℕ → ℕ →₀ ℝ} {cw2 : ℕ → ℕ → ℕ →₀ ℝ} {k : ℕ}
+omit [InnerProductSpace ℝ E] [CompleteSpace E] in
+lemma komlosFormula_cong (x : ℕ → ℕ → E) {cw1 : ℕ → ℕ → ℕ →₀ ℝ} {cw2 : ℕ → ℕ → ℕ →₀ ℝ} {k : ℕ}
   (h : ∀ k' ≤ k, cw1 k' = cw2 k') :
-  komlos_formula x cw1 k = komlos_formula x cw2 k := by
-  unfold komlos_formula
-  rw [cwIteratedMul_cong]
+  komlosFormula x cw1 k = komlosFormula x cw2 k := by
+  unfold komlosFormula
+  rw [convexWeightsConvolution_cong]
   exact h
 
 lemma komlos_base [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
   {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
   ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ),
-    (∃ glim : E, Tendsto (komlos_formula x cw 0) atTop (𝓝 glim))
-    ∧ (∀ k n m, 0 ≤ cw k n m) := by sorry
+    (∃ glim : E, Tendsto (komlosFormula x cw 0) atTop (𝓝 glim))
+    ∧ (∀ k n m, 0 ≤ cw k n m) := by
+    obtain ⟨g, g_conv, g_lim⟩ := komlos_norm (hx 0)
+
+    have exist_weights (n : ℕ) : ∃ w : ℕ →₀ ℝ, (∀ (i : ℕ), 0 ≤ w i) ∧
+      ∑ i ∈ w.support, w i = 1 ∧ ∑ i ∈ w.support, w i • x 0 i = g n := by
+      obtain ⟨w, hw1, hw2, hw3⟩ := convex_weights_of_mem_convexHull_indexed (g_conv n)
+      let φ : ℕ → ℕ := fun i ↦ n + i
+      let w' := Finsupp.onFinset (Finset.image (fun i ↦ i + n) w.support) (fun i ↦ w (i - n))
+        (by sorry) -- currently unprovable
+      use w'
+      have nonneg (i : ℕ) : 0 ≤ w' i := by sorry
+      have sum_one : ∑ i ∈ w'.support, w' i = 1 := by sorry
+      have sum_g : ∑ i ∈ w'.support, w' i • x 0 i = g n := by sorry
+      trivial
+
+    let cw (n : ℕ) := Classical.choose (exist_weights n)
+
+    use (fun k ↦ cw)
+    constructor
+    · have hg (n : ℕ) : ∑ i ∈ (cw n).support, (cw n) i • x 0 i = g n := by
+        exact (Classical.choose_spec (exist_weights n)).2.2
+      unfold komlosFormula
+      simp only [convexWeightsConvolution, hg, g_lim]
+    · intro k n m
+      exact (Classical.choose_spec (exist_weights n)).1 m
 
 
 lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
   {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ)
   (cw : ℕ → ℕ → ℕ →₀ ℝ) (hcw: ∀ k n m, 0 ≤ cw k n m) :
   ∃ (cw_new : ℕ → ℕ → ℕ →₀ ℝ),
-    (∃ glim : E, Tendsto (komlos_formula x cw_new (k+1)) atTop (𝓝 glim))
+    (∃ glim : E, Tendsto (komlosFormula x cw_new (k+1)) atTop (𝓝 glim))
     ∧ (∀ i ≤ k, cw_new i = cw i)
     ∧ (∀ k n m, 0 ≤ cw_new k n m) := by
 
@@ -224,30 +252,32 @@ lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
 
   let cw_new := Function.update cw (k+1) cw_step
 
-  have g_new_expression (n : ℕ) : g_step n = ∑ m ∈ (cwIteratedMul cw_new (k + 1) n).support,
-    cwIteratedMul cw_new (k + 1) n m • x (k+1) m := by
+  have g_new_expression (n : ℕ) :
+    g_step n = ∑ m ∈ (convexWeightsConvolution cw_new (k + 1) n).support,
+    convexWeightsConvolution cw_new (k + 1) n m • x (k+1) m := by
     rw [← hcombo n]
 
-    have aux: (cwIteratedMul cw_new (k + 1) n) = (cwmul (cw_step n) (cwIteratedMul cw k)) := by
-      rw [cwIteratedMul]
+    have aux: (convexWeightsConvolution cw_new (k + 1) n) =
+      (convexWeightsMul (cw_step n) (convexWeightsConvolution cw k)) := by
+      rw [convexWeightsConvolution]
       beta_reduce
       unfold cw_new
-      rw [Function.update_self, cwIteratedMul_update cw (show k+1 > k by omega)]
+      rw [Function.update_self, convexWeightsConvolution_update cw (show k+1 > k by grind)]
 
     rw [aux]
     unfold gtilde
-    rw [cwmul_eq]
+    rw [convexWeightsMul_eq]
     beta_reduce
 
-    set cwold := cwIteratedMul cw k
+    set cwold := convexWeightsConvolution cw k
     simp_rw [Finset.sum_smul, Finset.smul_sum, smul_smul]
     rw [Finset.sum_comm]
 
     refine Finset.sum_congr rfl ?_
     intro i hi
 
-    have subset: (cwold i).support ⊆ (cwmul (cw_step n) cwold).support := by
-      refine support_subset_cwmul_support hi ?_ ?_
+    have subset: (cwold i).support ⊆ (convexWeightsMul (cw_step n) cwold).support := by
+      refine support_subset_convexWeightsMul_support hi ?_ ?_
       · sorry
       · unfold cwold -- here we need to use hcw, probably through a further intermediate lemma
         sorry
@@ -274,7 +304,7 @@ def komlos_stage [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace
 
 lemma komlos_stage_lim [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
   {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
-  (∃ glim : E, Tendsto (komlos_formula x (komlos_stage hx k) k) atTop (𝓝 glim)) := by
+  (∃ glim : E, Tendsto (komlosFormula x (komlos_stage hx k) k) atTop (𝓝 glim)) := by
   induction k with
   | zero => sorry
   | succ k _ =>
@@ -295,21 +325,21 @@ lemma agreement_needed [NormedAddCommGroup E] [InnerProductSpace ℝ E] [Complet
   let n := k-i
   suffices (komlos_stage hx i).val i = (komlos_stage hx (i+n)).val i from by
     unfold n at this
-    rw [show i + (k - i) = k by omega] at this
+    rw [show i + (k - i) = k by grind] at this
     exact this
   induction n with
   | zero => rfl
   | succ n hn =>
   rw [← add_assoc, hn]
-  apply agreement_step hx (i+n) i (by omega)
+  apply agreement_step hx (i+n) i (by grind)
 
 lemma komlos_convex_weights [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
     {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
     ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ), ∀ k : ℕ,
-    ∃ glim : E, Tendsto (komlos_formula x cw k) atTop (𝓝 glim) := by
+    ∃ glim : E, Tendsto (komlosFormula x cw k) atTop (𝓝 glim) := by
 
   have hcwStage2 (k : ℕ) :
-    ∃ glim : E, Tendsto (komlos_formula x (komlos_stage hx k).val k) atTop (𝓝 glim) := by
+    ∃ glim : E, Tendsto (komlosFormula x (komlos_stage hx k).val k) atTop (𝓝 glim) := by
     apply komlos_stage_lim
 
   let cw (k : ℕ) : ℕ → ℕ →₀ ℝ := (komlos_stage hx k).val k
@@ -320,8 +350,8 @@ lemma komlos_convex_weights [NormedAddCommGroup E] [InnerProductSpace ℝ E] [Co
     apply agreement_needed hx
     exact hi
 
-  have transfer (k : ℕ) : komlos_formula x cw k = komlos_formula x (komlos_stage hx k).val k := by
-    apply komlos_formula_cong x
+  have transfer (k : ℕ) : komlosFormula x cw k = komlosFormula x (komlos_stage hx k).val k := by
+    apply komlosFormula_cong x
     exact agreement k
 
   use cw
diff --git a/blueprint/lean_decls b/blueprint/lean_decls
index ef621ce8..764db2d4 100644
--- a/blueprint/lean_decls
+++ b/blueprint/lean_decls
@@ -396,7 +396,7 @@ ProbabilityTheory.SimpleProcess.integral_top
 tendsto_of_no_upcrossings
 komlos_convex
 komlos_norm
-cwmul
+convexWeightsMul
 komlos_convex_weights
 komlos_L1
 komlos_ennreal
@@ -433,4 +433,4 @@ ProbabilityTheory.IsSquareIntegrable.tendsto_eLpNorm_two_limitProcess
 ProbabilityTheory.IsLocalMartingale.isLocalSubmartingale_sq_norm
 ProbabilityTheory.quadraticVariation
 MeasureTheory.Filtration.predictable_le_prod
-ProbabilityTheory.L2Predictable
\ No newline at end of file
+ProbabilityTheory.L2Predictable
diff --git a/blueprint/src/chapters/doob_meyer.tex b/blueprint/src/chapters/doob_meyer.tex
index deb22831..c44beb5c 100644
--- a/blueprint/src/chapters/doob_meyer.tex
+++ b/blueprint/src/chapters/doob_meyer.tex
@@ -98,7 +98,7 @@ \section{Komlòs Lemma}
 By convex weights on $\mathbb{N}$, we mean a sequence of non-negative real numbers $(a_n)_{n \in \mathbb{N}}$ with finitely many nonzero entries such that $\sum_{n \in \mathbb{N}} a_n = 1$.
 
 \begin{definition}\label{def:convex_weights_product}
-  \lean{cwmul}
+  \lean{convexWeightsMul}
 If $(a_m)_{m \in \mathbb{N}}$ are convex weights and $(b^n_m)_{n,m \in \mathbb{N}}$ is such that for all $n$, the $(b^n_m)$ are convex weights, then we denote by $(a_\cdot) * (b^\cdot_\cdot)$ the convex weights defined by $((a_\cdot) * (b^\cdot_\cdot))_m = \sum_{k} a_k b^k_m$.
 \end{definition}
 

From 92091c39df2aeab7ca905426ffa733f049b558fe Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Tue, 21 Apr 2026 11:30:04 +0100
Subject: [PATCH 10/37] refactor: use Finsupp.sum instead of Finset.sum

---
 BrownianMotion/StochasticIntegral/Komlos.lean | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 4949396c..cd85cec8 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -168,12 +168,9 @@ noncomputable section
 variable [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E] [Module ℝ E]
 
 def gtilde (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E) (k : ℕ) (n : ℕ) : E :=
-  ∑ m ∈ (convexWeightsConvolution cw k n).support, (convexWeightsConvolution cw k n m) • (x (k+1) m)
-  -- note that it has to be k+1, not k for x!
-
-def gtilde' (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E) (k : ℕ) (n : ℕ) : E :=
   (convexWeightsConvolution cw k n).sum (fun m cwm ↦ cwm • (x (k+1) m))
 
+
 omit [InnerProductSpace ℝ E] [CompleteSpace E] in
 lemma gtilde_update (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E) {k k' : ℕ} {f : ℕ → ℕ →₀ ℝ}
     (hk' : k' > k) :
@@ -183,7 +180,7 @@ lemma gtilde_update (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E
   rw [← convexWeightsConvolution_update cw hk']
 
 def komlosFormula (x : ℕ → ℕ → E) (cw : ℕ → ℕ → ℕ →₀ ℝ) (k n : ℕ) : E :=
-  ∑ m ∈ (convexWeightsConvolution cw k n).support, convexWeightsConvolution cw k n m • x k m
+  (convexWeightsConvolution cw k n).sum (fun m cwm ↦ cwm • x k m)
 
 omit [InnerProductSpace ℝ E] [CompleteSpace E] in
 lemma komlosFormula_cong (x : ℕ → ℕ → E) {cw1 : ℕ → ℕ → ℕ →₀ ℝ} {cw2 : ℕ → ℕ → ℕ →₀ ℝ} {k : ℕ}
@@ -216,10 +213,14 @@ lemma komlos_base [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
 
     use (fun k ↦ cw)
     constructor
-    · have hg (n : ℕ) : ∑ i ∈ (cw n).support, (cw n) i • x 0 i = g n := by
-        exact (Classical.choose_spec (exist_weights n)).2.2
+    · have hg (n : ℕ) : (cw n).sum (fun m cwm ↦ cwm • x 0 m) = g n := by
+        have := (Classical.choose_spec (exist_weights n)).2.2
+        simp only [Finsupp.sum]
+        exact this
       unfold komlosFormula
-      simp only [convexWeightsConvolution, hg, g_lim]
+      simp only [convexWeightsConvolution]
+      simp_rw [hg]
+      exact g_lim
     · intro k n m
       exact (Classical.choose_spec (exist_weights n)).1 m
 
@@ -253,8 +254,7 @@ lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
   let cw_new := Function.update cw (k+1) cw_step
 
   have g_new_expression (n : ℕ) :
-    g_step n = ∑ m ∈ (convexWeightsConvolution cw_new (k + 1) n).support,
-    convexWeightsConvolution cw_new (k + 1) n m • x (k+1) m := by
+    g_step n = (convexWeightsConvolution cw_new (k + 1) n).sum (fun m cwm ↦ cwm • x (k+1) m) := by
     rw [← hcombo n]
 
     have aux: (convexWeightsConvolution cw_new (k + 1) n) =
@@ -266,11 +266,11 @@ lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
 
     rw [aux]
     unfold gtilde
-    rw [convexWeightsMul_eq]
+    rw [Finsupp.sum, convexWeightsMul_eq]
     beta_reduce
 
     set cwold := convexWeightsConvolution cw k
-    simp_rw [Finset.sum_smul, Finset.smul_sum, smul_smul]
+    simp_rw [Finset.sum_smul]
     rw [Finset.sum_comm]
 
     refine Finset.sum_congr rfl ?_

From a0d556e533113eb8bdc738cc8030f317fb22af3e Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Tue, 21 Apr 2026 12:20:48 +0100
Subject: [PATCH 11/37] feat(Komlos): finish proof of komlos_base

---
 .../StochasticIntegral/ConvexWeights.lean     |  3 ++-
 BrownianMotion/StochasticIntegral/Komlos.lean | 19 +++++++++----------
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
index 518a33d4..ba7f6e54 100644
--- a/BrownianMotion/StochasticIntegral/ConvexWeights.lean
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -13,7 +13,8 @@ variable {R E : Type*} [Field R] [AddCommGroup E] [Module R E]
 
 lemma convex_weights_of_mem_convexHull_indexed {s : ι → E} {x : E}
     (h : x ∈ convexHull R (Set.range s)) :
-    ∃ (w : ι →₀ R), (∀ i, 0 ≤ w i) ∧ ∑ i ∈ w.support, w i = 1 ∧ ∑ i ∈ w.support, w i • s i = x := by
+    ∃ (w : ι →₀ R), (∀ i, 0 ≤ w i) ∧ w.sum (fun _ wi ↦ wi) = 1
+      ∧ w.sum (fun i wi ↦ wi • s i) = x := by
       sorry
 
 noncomputable section
diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index cd85cec8..396b8a98 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -198,16 +198,15 @@ lemma komlos_base [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
     obtain ⟨g, g_conv, g_lim⟩ := komlos_norm (hx 0)
 
     have exist_weights (n : ℕ) : ∃ w : ℕ →₀ ℝ, (∀ (i : ℕ), 0 ≤ w i) ∧
-      ∑ i ∈ w.support, w i = 1 ∧ ∑ i ∈ w.support, w i • x 0 i = g n := by
-      obtain ⟨w, hw1, hw2, hw3⟩ := convex_weights_of_mem_convexHull_indexed (g_conv n)
-      let φ : ℕ → ℕ := fun i ↦ n + i
-      let w' := Finsupp.onFinset (Finset.image (fun i ↦ i + n) w.support) (fun i ↦ w (i - n))
-        (by sorry) -- currently unprovable
-      use w'
-      have nonneg (i : ℕ) : 0 ≤ w' i := by sorry
-      have sum_one : ∑ i ∈ w'.support, w' i = 1 := by sorry
-      have sum_g : ∑ i ∈ w'.support, w' i • x 0 i = g n := by sorry
-      trivial
+      ∑ i ∈ w.support, w i = 1 ∧ w.sum (fun i wi ↦ wi  • x 0 i) = g n := by
+      obtain ⟨w, hw⟩ := convex_weights_of_mem_convexHull_indexed (g_conv n)
+      let w' := Finsupp.embDomain ⟨fun i ↦ n + i, add_right_injective n⟩ w
+      have sum_w' : w'.sum (fun i wi ↦ wi • x 0 i) = g n := by
+        rw [Finsupp.sum_embDomain]
+        simp [hw]
+      have nonneg (i : ℕ) : 0 ≤ w' i := by grind
+      have sum_one : w'.sum (fun _ wi ↦ wi) = 1 := by grind [Finsupp.sum_embDomain]
+      use w'; trivial
 
     let cw (n : ℕ) := Classical.choose (exist_weights n)
 

From 970c607ae4bdc3aa7c634caeaba8639691666a41 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Tue, 21 Apr 2026 15:36:13 +0100
Subject: [PATCH 12/37] feat(Komlos): progress in komlos_step

---
 BrownianMotion/StochasticIntegral/Komlos.lean | 131 +++++++++++++-----
 1 file changed, 94 insertions(+), 37 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 396b8a98..0c21d507 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -170,7 +170,6 @@ variable [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E] [Mod
 def gtilde (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E) (k : ℕ) (n : ℕ) : E :=
   (convexWeightsConvolution cw k n).sum (fun m cwm ↦ cwm • (x (k+1) m))
 
-
 omit [InnerProductSpace ℝ E] [CompleteSpace E] in
 lemma gtilde_update (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E) {k k' : ℕ} {f : ℕ → ℕ →₀ ℝ}
     (hk' : k' > k) :
@@ -190,39 +189,69 @@ lemma komlosFormula_cong (x : ℕ → ℕ → E) {cw1 : ℕ → ℕ → ℕ →
   rw [convexWeightsConvolution_cong]
   exact h
 
+omit [InnerProductSpace ℝ E] [CompleteSpace E] in
+lemma exist_weights {x g : ℕ → E}
+    (h_convex : ∀ n, g n ∈ convexHull ℝ (Set.range fun m ↦ x (n + m))) :
+    ∀ n, ∃ w : ℕ →₀ ℝ, (∀ i, 0 ≤ w i) ∧ (∀ m < n, w m = 0)
+      ∧ w.sum (fun _ wi ↦ wi) = 1
+      ∧ w.sum (fun i wi ↦ wi • x i) = g n := by
+  intro n
+  obtain ⟨w, hw_nonneg, hw_sum, hw_combo⟩ := convex_weights_of_mem_convexHull_indexed (h_convex n)
+  let w' := Finsupp.embDomain ⟨fun i ↦ n + i, add_right_injective n⟩ w
+  have nonneg (i : ℕ) : 0 ≤ w' i := by grind
+  have zero_lt (m : ℕ) (hm : m < n) : w' m = 0 := by
+    rw [Finsupp.embDomain_apply]
+    split_ifs with h
+    · exfalso
+      rcases h with ⟨i, hi⟩
+      have hnm : n ≤ m := by
+        rw [← hi]
+        exact Nat.le_add_right n i
+      exact (Nat.not_le_of_lt hm hnm).elim
+    · rfl
+  have sum_one : w'.sum (fun _ wi ↦ wi) = 1 := by grind [Finsupp.sum_embDomain]
+  have sum_eq : w'.sum (fun i wi ↦ wi • x i) = g n := by
+    rw [Finsupp.sum_embDomain]
+    simp [hw_combo]
+  exact ⟨w', nonneg, zero_lt, sum_one, sum_eq⟩
+
 lemma komlos_base [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
   {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
   ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ),
     (∃ glim : E, Tendsto (komlosFormula x cw 0) atTop (𝓝 glim))
     ∧ (∀ k n m, 0 ≤ cw k n m) := by
-    obtain ⟨g, g_conv, g_lim⟩ := komlos_norm (hx 0)
-
-    have exist_weights (n : ℕ) : ∃ w : ℕ →₀ ℝ, (∀ (i : ℕ), 0 ≤ w i) ∧
-      ∑ i ∈ w.support, w i = 1 ∧ w.sum (fun i wi ↦ wi  • x 0 i) = g n := by
-      obtain ⟨w, hw⟩ := convex_weights_of_mem_convexHull_indexed (g_conv n)
-      let w' := Finsupp.embDomain ⟨fun i ↦ n + i, add_right_injective n⟩ w
-      have sum_w' : w'.sum (fun i wi ↦ wi • x 0 i) = g n := by
-        rw [Finsupp.sum_embDomain]
-        simp [hw]
-      have nonneg (i : ℕ) : 0 ≤ w' i := by grind
-      have sum_one : w'.sum (fun _ wi ↦ wi) = 1 := by grind [Finsupp.sum_embDomain]
-      use w'; trivial
-
-    let cw (n : ℕ) := Classical.choose (exist_weights n)
+    obtain ⟨g, h_convex, h_lim⟩ := komlos_norm (hx 0)
 
+    let cw (n : ℕ) := Classical.choose
+      (exist_weights (x := fun m ↦ x 0 m) (g := g) h_convex n)
     use (fun k ↦ cw)
+
     constructor
     · have hg (n : ℕ) : (cw n).sum (fun m cwm ↦ cwm • x 0 m) = g n := by
-        have := (Classical.choose_spec (exist_weights n)).2.2
-        simp only [Finsupp.sum]
-        exact this
+        exact (Classical.choose_spec
+          (exist_weights (x := fun m ↦ x 0 m) (g := g) h_convex n)).2.2.2
       unfold komlosFormula
       simp only [convexWeightsConvolution]
       simp_rw [hg]
-      exact g_lim
+      exact h_lim
     · intro k n m
-      exact (Classical.choose_spec (exist_weights n)).1 m
-
+      exact (Classical.choose_spec
+        (exist_weights (x := fun m ↦ x 0 m) (g := g) h_convex n)).1 m
+
+lemma convex_combination_bounded [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
+  {x : ℕ → E} {w : ℕ → ℕ →₀ ℝ} (hw : ∀ n, (w n).sum (fun _ wi ↦ wi) = 1)
+  (hw_nonneg : ∀ n m, 0 ≤ (w n) m)
+  (hx : ∃ M : ℝ, ∀ n, ‖x n‖ ≤ M) :
+  ∃ M, ∀ n, ‖(w n).sum (fun i wi ↦ wi • x i)‖ ≤ M := by
+  obtain ⟨M, hM⟩ := hx
+  use M
+  intro n
+  have h_sum : ‖(w n).sum (fun i wi => wi • x i)‖ ≤ ∑ i ∈ (w n).support, (w n i) * ‖x i‖ := by
+    convert norm_sum_le _ _ using 2
+    simp +decide [norm_smul, abs_of_nonneg (hw_nonneg _ _)]
+  refine le_trans h_sum (le_trans (Finset.sum_le_sum fun i hi =>
+    mul_le_mul_of_nonneg_left (hM i) (hw_nonneg n i)) ?_)
+  simp_all [← Finset.sum_mul _ _ _, Finsupp.sum]
 
 lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
   {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ)
@@ -232,21 +261,30 @@ lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
     ∧ (∀ i ≤ k, cw_new i = cw i)
     ∧ (∀ k n m, 0 ≤ cw_new k n m) := by
 
-  have gtilde_bound : ∃ M, ∀ n, ‖gtilde cw x k n‖ ≤ M := by sorry -- maybe turn this into a lemma
+  have gtilde_bound : ∃ M, ∀ n, ‖gtilde cw x k n‖ ≤ M := by
+    unfold gtilde
+    apply convex_combination_bounded ?_ ?_ (hx (k+1))
+    · sorry
+    -- this requires an extra assumption on cw: we need that the cw sum up to one since otherwise
+    -- gtilde might not be bounded
+    · sorry
 
   obtain ⟨g_step, gstep_conv, gstep_lim⟩ := komlos_norm (gtilde_bound)
 
   have cw_step_exists : ∃ w : ℕ → ℕ →₀ ℝ,
-    (∀ n m, 0 ≤ w n m) ∧ (∀ n, ∀ m ≤ n, w n m = 0)
-    ∧ (∀ n, ∑ i ∈ (w n).support, w n i = 1)
-    ∧ ∀ n, ∑ i ∈ (w n).support, (w n) i • gtilde cw x k i = g_step n := by
-    have original_weights : ∀ n, ∃ w : ℕ →₀ ℝ, (∀ i, 0 ≤ w i) ∧ ∑ i ∈ w.support, w i = 1
-      ∧ ∑ i ∈ w.support, w i • gtilde cw x k (n + i) = g_step n := by
-      exact (fun n ↦ convex_weights_of_mem_convexHull_indexed (gstep_conv n))
-
-    -- Need to use choice to finish this, along the lines of:
-    -- exact ⟨fun n => Classical.choose (weights n), fun n => Classical.choose_spec (weights n)⟩
-    sorry
+    (∀ n m, 0 ≤ w n m) ∧ (∀ n, ∀ m < n, w n m = 0)
+    ∧ (∀ n, (w n).sum (fun _ wi ↦ wi) = 1)
+    ∧ ∀ n, (w n).sum (fun i wi ↦ wi • gtilde cw x k i) = g_step n := by
+    refine ⟨fun n ↦ Classical.choose (exist_weights gstep_conv n), ?_⟩
+    refine ⟨?_, ?_, ?_, ?_⟩
+    · intro n m
+      exact (Classical.choose_spec (exist_weights gstep_conv n)).1 m
+    · intro n m hm
+      exact (Classical.choose_spec (exist_weights gstep_conv n)).2.1 m hm
+    · intro n
+      exact (Classical.choose_spec (exist_weights gstep_conv n)).2.2.1
+    · intro n
+      exact (Classical.choose_spec (exist_weights gstep_conv n)).2.2.2
 
   obtain ⟨cw_step, ⟨hnonneg, hzero, hsum, hcombo⟩⟩ := cw_step_exists
 
@@ -265,7 +303,8 @@ lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
 
     rw [aux]
     unfold gtilde
-    rw [Finsupp.sum, convexWeightsMul_eq]
+    simp only [Finsupp.sum]
+    rw [convexWeightsMul_eq (cw_step n) (convexWeightsConvolution cw k)]
     beta_reduce
 
     set cwold := convexWeightsConvolution cw k
@@ -277,16 +316,34 @@ lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
 
     have subset: (cwold i).support ⊆ (convexWeightsMul (cw_step n) cwold).support := by
       refine support_subset_convexWeightsMul_support hi ?_ ?_
-      · sorry
+      · grind only
       · unfold cwold -- here we need to use hcw, probably through a further intermediate lemma
+        intro a ha m
         sorry
 
-    -- TODO: Use Finset.sum_subset or similar to finish this proof
-    sorry
+    rw [Finset.smul_sum]
+    simp_rw [← smul_smul]
+    apply Finset.sum_subset subset ?_
+    intro m hm1 hm2
+    have is_zero: cwold i m = 0 := by
+      grind => instantiate only [= Finsupp.mem_support_iff]
+    rw [is_zero]
+    simp
 
   have old_indices_untouched: ∀ i ≤ k, cw_new i = cw i := sorry -- trivial by construction
 
-  sorry
+  use cw_new
+  refine ⟨?_, by trivial, ?_⟩
+  · obtain ⟨glim, hglim⟩ := gstep_lim
+    use glim
+    exact Tendsto.congr g_new_expression hglim
+  · unfold cw_new
+    intro k' n m
+    rw [Function.update]
+    split_ifs
+    · simp only [eq_rec_constant]
+      exact hnonneg _ _
+    · exact hcw k' n m
 
 def komlos_stage [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
   {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (stage : ℕ) :

From 3c023fed713efca00ff821ecd0434fb5fa019133 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Tue, 21 Apr 2026 16:22:44 +0100
Subject: [PATCH 13/37] feat(ConvexWeights): Add missing basic lemmas

---
 .../StochasticIntegral/ConvexWeights.lean     | 21 +++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
index ba7f6e54..a90edc5c 100644
--- a/BrownianMotion/StochasticIntegral/ConvexWeights.lean
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -2,7 +2,7 @@ module
 
 public import Mathlib.Analysis.InnerProductSpace.Defs
 
-/-
+/-`
 # Lemmas on Convex Weights
 -/
 
@@ -37,14 +37,19 @@ def convexWeightsMul (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) : ℕ →
 lemma convexWeightsMul_eq (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) :
   convexWeightsMul a b = fun m ↦ ∑ k ∈ a.support, a k * (b k m) := rfl
 
--- Need to add lemmas that show compatibility between convexWeightsMul (+ iterated variant) with the complex
--- weights conditions: nonegativity and summing up to one
+variable {a : ℕ →₀ ℝ} {b : ℕ → ℕ →₀ ℝ}
+
+lemma convexWeightsMul_nonneg (ha : ∀ n, a n ≥ 0) (hb : ∀ n m, b n m ≥ 0) (m : ℕ) :
+  convexWeightsMul a b m ≥ 0 := by sorry
+
+lemma convexWeightsMul_sum_one (ha_nonneg : ∀ n, a n ≥ 0) (hb_nonneg : ∀ n m, b n m ≥ 0)
+  (ha_sum_one : a.sum (fun _ ai ↦ ai) = 1) (hb_sum_one : ∀ n, (b n).sum (fun _ bi ↦ bi) = 1) :
+  (convexWeightsMul a b).sum (fun _ mi ↦ mi) = 1 := by sorry
 
 def convexWeightsConvolution (cw : ℕ → ℕ → ℕ →₀ ℝ) : ℕ → ℕ → ℕ →₀ ℝ
   | 0 => fun n ↦ cw 0 n
   | k + 1 => fun n ↦ convexWeightsMul (cw (k+1) n) (convexWeightsConvolution cw k)
 
-
 lemma convexWeightsConvolution_cong {cw1 cw2 : ℕ → ℕ → ℕ →₀ ℝ} {k : ℕ}
     (h : ∀ i ≤ k, cw1 i = cw2 i) :
     convexWeightsConvolution cw1 k = convexWeightsConvolution cw2 k := by
@@ -77,3 +82,11 @@ lemma support_subset_convexWeightsMul_support {a : ℕ →₀ ℝ} {b : ℕ →
   · refine ⟨i, hi, mul_pos ?_ ?_⟩
     · exact lt_of_le_of_ne (ha i hi) (Ne.symm (Finsupp.mem_support_iff.mp hi))
     · exact lt_of_le_of_ne (hb i hi j) (Ne.symm (Finsupp.mem_support_iff.mp hj))
+
+lemma convexWeightsConvolution_nonneg {cw : ℕ → ℕ → ℕ →₀ ℝ}
+  (h : ∀ k n m, 0 ≤ cw k n m) (k n m : ℕ) :
+  0 ≤ convexWeightsConvolution cw k n m := by sorry
+
+lemma convexWeightsConvolution_sum_one {cw : ℕ → ℕ → ℕ →₀ ℝ} (h_nonneg : ∀ k n m, 0 ≤ cw k n m)
+  (h_sum_one : ∀ k n, (cw k n).sum (fun _ wi ↦ wi) = 1) (k n : ℕ) :
+  (convexWeightsConvolution cw k n).sum (fun _ wi ↦ wi) = 1 := by sorry

From 79e5f5fa5917596a3e67dcb18c39af22d88a510a Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Tue, 21 Apr 2026 16:33:39 +0100
Subject: [PATCH 14/37] feat(ConvexWeights): AI-generated proofs for simple
 lemmas

---
 .../StochasticIntegral/ConvexWeights.lean     | 55 ++++++++++++++++---
 1 file changed, 47 insertions(+), 8 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
index a90edc5c..6361b2bb 100644
--- a/BrownianMotion/StochasticIntegral/ConvexWeights.lean
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -2,7 +2,7 @@ module
 
 public import Mathlib.Analysis.InnerProductSpace.Defs
 
-/-`
+/-
 # Lemmas on Convex Weights
 -/
 
@@ -12,10 +12,21 @@ variable {R E : Type*} [Field R] [AddCommGroup E] [Module R E]
   [LinearOrder R] [IsStrictOrderedRing R] {ι : Type*}
 
 lemma convex_weights_of_mem_convexHull_indexed {s : ι → E} {x : E}
-    (h : x ∈ convexHull R (Set.range s)) :
+  (hx : x ∈ convexHull R (Set.range s)) :
     ∃ (w : ι →₀ R), (∀ i, 0 ≤ w i) ∧ w.sum (fun _ wi ↦ wi) = 1
       ∧ w.sum (fun i wi ↦ wi • s i) = x := by
-      sorry
+  rw [ mem_convexHull_iff ] at hx
+  specialize hx ( { y | ∃ w : ι →₀ R, ( ∀ i, 0 ≤ w i ) ∧ w.sum (fun _ wi => wi) = 1
+    ∧ w.sum (fun i wi => wi • s i) = y } ) ?_ ?_ <;> norm_num at *;
+  · rintro _ ⟨ i, rfl ⟩ ; exact ⟨ Finsupp.single i 1, fun j => by by_cases h : j = i <;> aesop,
+      by simp, by simp⟩ ;
+  · rintro x ⟨ w₁, hw₁, hw₁', rfl ⟩ y ⟨ w₂, hw₂, hw₂', rfl ⟩ a b ha hb hab;
+    refine ⟨ a • w₁ + b • w₂, ?_, ?_, ?_ ⟩ <;> simp_all [ Finsupp.sum_add_index', Finsupp.smul_sum ];
+    · exact fun i => add_nonneg (mul_nonneg ha ( hw₁ i )) (mul_nonneg hb ( hw₂ i ));
+    · simp_all +decide [ Finsupp.sum_smul_index ];
+      simp_all +decide [ ← Finset.mul_sum _ _ _, Finsupp.sum ];
+    · simp +decide [ Finsupp.sum_add_index', Finsupp.sum_smul_index, smul_smul, add_smul];
+  · exact hx
 
 noncomputable section
 
@@ -40,11 +51,26 @@ lemma convexWeightsMul_eq (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) :
 variable {a : ℕ →₀ ℝ} {b : ℕ → ℕ →₀ ℝ}
 
 lemma convexWeightsMul_nonneg (ha : ∀ n, a n ≥ 0) (hb : ∀ n m, b n m ≥ 0) (m : ℕ) :
-  convexWeightsMul a b m ≥ 0 := by sorry
+  convexWeightsMul a b m ≥ 0 := by
+    exact Finset.sum_nonneg fun _ _ => mul_nonneg ( ha _ ) ( hb _ _ )
 
 lemma convexWeightsMul_sum_one (ha_nonneg : ∀ n, a n ≥ 0) (hb_nonneg : ∀ n m, b n m ≥ 0)
   (ha_sum_one : a.sum (fun _ ai ↦ ai) = 1) (hb_sum_one : ∀ n, (b n).sum (fun _ bi ↦ bi) = 1) :
-  (convexWeightsMul a b).sum (fun _ mi ↦ mi) = 1 := by sorry
+  (convexWeightsMul a b).sum (fun _ mi ↦ mi) = 1 := by
+    convert ha_sum_one using 1
+    convert Finset.sum_comm using 1
+    refine Finset.sum_congr rfl fun i hi => ?_;
+    rw [← Finset.mul_sum _ _ _,
+      show ( ∑ x ∈ ( convexWeightsMul a b ).support, ( b i ) x ) = 1 from ?_ ];
+    · norm_num;
+    · rw [← hb_sum_one i, Finsupp.sum_of_support_subset];
+      · intro j hj
+        simp_all only [ge_iff_le, Finsupp.mem_support_iff, ne_eq, convexWeightsMul,
+        Finsupp.onFinset_apply]
+        exact ne_of_gt (lt_of_lt_of_le (mul_pos (lt_of_le_of_ne (ha_nonneg i ) (Ne.symm hi ) )
+        (lt_of_le_of_ne (hb_nonneg i j ) (Ne.symm hj ) ) ) (Finset.single_le_sum
+        (fun k _ => mul_nonneg (ha_nonneg k ) (hb_nonneg k j )) (by aesop)))
+      · aesop
 
 def convexWeightsConvolution (cw : ℕ → ℕ → ℕ →₀ ℝ) : ℕ → ℕ → ℕ →₀ ℝ
   | 0 => fun n ↦ cw 0 n
@@ -85,8 +111,21 @@ lemma support_subset_convexWeightsMul_support {a : ℕ →₀ ℝ} {b : ℕ →
 
 lemma convexWeightsConvolution_nonneg {cw : ℕ → ℕ → ℕ →₀ ℝ}
   (h : ∀ k n m, 0 ≤ cw k n m) (k n m : ℕ) :
-  0 ≤ convexWeightsConvolution cw k n m := by sorry
+  0 ≤ convexWeightsConvolution cw k n m := by
+    unfold convexWeightsConvolution
+    induction k <;> simp only [h]
+    apply_rules [convexWeightsMul_nonneg]
+    rename_i k hk
+    refine Nat.recOn k ?_ ?_ <;> simp only [Nat.zero_eq, ge_iff_le]
+    · exact fun n m ↦ le_of_eq_of_le rfl (h 0 n m)
+    · intro n hn n' m
+      exact convexWeightsMul_nonneg (fun k => h _ _ _ ) (fun k m => hn _ _) _
 
 lemma convexWeightsConvolution_sum_one {cw : ℕ → ℕ → ℕ →₀ ℝ} (h_nonneg : ∀ k n m, 0 ≤ cw k n m)
-  (h_sum_one : ∀ k n, (cw k n).sum (fun _ wi ↦ wi) = 1) (k n : ℕ) :
-  (convexWeightsConvolution cw k n).sum (fun _ wi ↦ wi) = 1 := by sorry
+  (h_sum_one : ∀ k n, (cw k n).sum (fun _ wi ↦ wi) = 1) (k : ℕ) :
+  ∀ n, (convexWeightsConvolution cw k n).sum (fun _ wi ↦ wi) = 1 := by
+    refine Nat.recOn k ?_ ?_ <;> simp_all only [convexWeightsConvolution, implies_true]
+    intro n hn n_1
+    exact convexWeightsMul_sum_one (fun k => h_nonneg _ _ _)
+      (fun k m => convexWeightsConvolution_nonneg (fun k n m => h_nonneg k n m) _ _ _)
+      (h_sum_one _ _) (fun k => hn k)

From 59ba5afb7f0ce784625f1e245c73d6ec9775148e Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Tue, 21 Apr 2026 17:07:54 +0100
Subject: [PATCH 15/37] refactor(Komlos): general cleanup

---
 .../StochasticIntegral/ConvexWeights.lean     |  30 +++-
 BrownianMotion/StochasticIntegral/Komlos.lean | 162 +++++-------------
 2 files changed, 64 insertions(+), 128 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
index 6361b2bb..b14a0487 100644
--- a/BrownianMotion/StochasticIntegral/ConvexWeights.lean
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -18,14 +18,15 @@ lemma convex_weights_of_mem_convexHull_indexed {s : ι → E} {x : E}
   rw [ mem_convexHull_iff ] at hx
   specialize hx ( { y | ∃ w : ι →₀ R, ( ∀ i, 0 ≤ w i ) ∧ w.sum (fun _ wi => wi) = 1
     ∧ w.sum (fun i wi => wi • s i) = y } ) ?_ ?_ <;> norm_num at *;
-  · rintro _ ⟨ i, rfl ⟩ ; exact ⟨ Finsupp.single i 1, fun j => by by_cases h : j = i <;> aesop,
+  · rintro _ ⟨ i, rfl ⟩
+    exact ⟨Finsupp.single i 1, fun j => by by_cases h : j = i <;> aesop,
       by simp, by simp⟩ ;
-  · rintro x ⟨ w₁, hw₁, hw₁', rfl ⟩ y ⟨ w₂, hw₂, hw₂', rfl ⟩ a b ha hb hab;
-    refine ⟨ a • w₁ + b • w₂, ?_, ?_, ?_ ⟩ <;> simp_all [ Finsupp.sum_add_index', Finsupp.smul_sum ];
+  · rintro x ⟨w₁, hw₁, hw₁', rfl⟩ y ⟨w₂, hw₂, hw₂', rfl⟩ a b ha hb hab;
+    refine ⟨a • w₁ + b • w₂, ?_, ?_, ?_⟩
     · exact fun i => add_nonneg (mul_nonneg ha ( hw₁ i )) (mul_nonneg hb ( hw₂ i ));
-    · simp_all +decide [ Finsupp.sum_smul_index ];
-      simp_all +decide [ ← Finset.mul_sum _ _ _, Finsupp.sum ];
-    · simp +decide [ Finsupp.sum_add_index', Finsupp.sum_smul_index, smul_smul, add_smul];
+    · simp_all [Finsupp.sum_add_index', Finsupp.sum_smul_index];
+      simp_all [← Finset.mul_sum _ _ _, Finsupp.sum]
+    · simp [Finsupp.smul_sum, Finsupp.sum_add_index', Finsupp.sum_smul_index, smul_smul, add_smul];
   · exact hx
 
 noncomputable section
@@ -44,7 +45,6 @@ def convexWeightsMul (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) : ℕ →
       · simp [ha]
       · simp [h k (Finsupp.mem_support_iff.mp hk)])
 
-
 lemma convexWeightsMul_eq (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) :
   convexWeightsMul a b = fun m ↦ ∑ k ∈ a.support, a k * (b k m) := rfl
 
@@ -129,3 +129,19 @@ lemma convexWeightsConvolution_sum_one {cw : ℕ → ℕ → ℕ →₀ ℝ} (h_
     exact convexWeightsMul_sum_one (fun k => h_nonneg _ _ _)
       (fun k m => convexWeightsConvolution_nonneg (fun k n m => h_nonneg k n m) _ _ _)
       (h_sum_one _ _) (fun k => hn k)
+
+omit [AddCommGroup E] in
+lemma convex_combination_bounded [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+  {x : ℕ → E} {w : ℕ → ℕ →₀ ℝ} (hw : ∀ n, (w n).sum (fun _ wi ↦ wi) = 1)
+  (hw_nonneg : ∀ n m, 0 ≤ (w n) m)
+  (hx : ∃ M : ℝ, ∀ n, ‖x n‖ ≤ M) :
+  ∃ M, ∀ n, ‖(w n).sum (fun i wi ↦ wi • x i)‖ ≤ M := by
+  obtain ⟨M, hM⟩ := hx
+  use M
+  intro n
+  have h_sum : ‖(w n).sum (fun i wi => wi • x i)‖ ≤ ∑ i ∈ (w n).support, (w n i) * ‖x i‖ := by
+    convert norm_sum_le _ _ using 2
+    simp [norm_smul, abs_of_nonneg (hw_nonneg _ _)]
+  refine le_trans h_sum (le_trans (Finset.sum_le_sum fun i hi =>
+    mul_le_mul_of_nonneg_left (hM i) (hw_nonneg n i)) ?_)
+  simp_all [← Finset.sum_mul _ _ _, Finsupp.sum]
diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 0c21d507..d65698d0 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -118,59 +118,14 @@ lemma komlos_norm [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
     rw [dist_eq_norm]
     exact (pow_lt_pow_iff_left₀ (norm_nonneg (g m - g n)) (by positivity) (by norm_num)).mp this
   rcases CompleteSpace.complete g_cauchy with ⟨x, hx⟩
-  sorry
-
-def C [AddCommMonoid E] [Module ℝ E] (x : ℕ → E) : Set (ℕ → E) :=
-  {g : ℕ → E | ∀ n, g n ∈ convexHull ℝ (Set.range fun m ↦ x (n + m))}
-
--- Lemma 2.11 in the blueprint
-lemma komlos_convergence [NormedAddCommGroup E] [Module ℝ E] [IsBoundedSMul ℝ E]
-  {x : ℕ → E} {xlim : E} (hxlim : Tendsto x atTop (𝓝 xlim)) :
-  ∀ ε > 0, ∃ N, ∀ y ∈ C x, ∀ n ≥ N, ‖y n - xlim‖ < ε := by
-  intro ε εpos
-  obtain ⟨N, hN⟩ : ∃ N, ∀ n ≥ N, ‖x n - xlim‖ < ε := by
-    rcases Metric.tendsto_atTop.mp hxlim ε εpos with ⟨N, hN⟩
-    use N
-    intro n hn
-    rw [← dist_eq_norm (x n) xlim]
-    exact hN n hn
-  use N
-  intro y hy n hn
-  obtain ⟨N, a, ha_sum, ha_pos, hay⟩ : (∃ N : ℕ → Finset ℕ, ∃ a : (n : ℕ) → ℕ → ℝ,
-    (∑ m ∈ N n, a n m) = 1 ∧ (∀ m ∈ N n, 0 ≤ a n m) ∧ (∀ n, y n = ∑ m ∈ N n, a n m • x n)) := by
-    sorry
-  rw [hay n]
-  rw [show xlim = (1 : ℝ) • xlim by simp]
-  rw [← ha_sum]
-  rw [Finset.sum_smul]
-  rw [← Finset.sum_sub_distrib]
-  simp_rw [← smul_sub]
-  apply lt_of_le_of_lt (norm_sum_le (N n) (fun m ↦ a n m • (x n - xlim)))
-
-  have hsum_le :
-      ∑ i ∈ N n, ‖a n i • (x n - xlim)‖ ≤ ∑ i ∈ N n, ‖a n i‖ * ‖x n - xlim‖ := by
-    exact Finset.sum_le_sum (fun m hm ↦ norm_smul_le (a n m) (x n - xlim))
-
-  refine lt_of_le_of_lt hsum_le ?_
-  rw [← Finset.sum_mul]
-
-  have hanorm : ∑ i ∈ N n, ‖a n i‖ = ∑ i ∈ N n, a n i := by
-      apply Finset.sum_congr rfl
-      intro m hm
-      refine Real.norm_of_nonneg ?_
-      exact ha_pos m hm
-
-  rw [hanorm, ha_sum]
-  simp only [one_mul, gt_iff_lt]
-  exact RCLike.ofReal_lt_ofReal.mp (hN n hn)
+  tauto
 
 noncomputable section
-variable [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E] [Module ℝ E]
+variable [NormedAddCommGroup E] [InnerProductSpace ℝ E]
 
 def gtilde (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E) (k : ℕ) (n : ℕ) : E :=
   (convexWeightsConvolution cw k n).sum (fun m cwm ↦ cwm • (x (k+1) m))
 
-omit [InnerProductSpace ℝ E] [CompleteSpace E] in
 lemma gtilde_update (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E) {k k' : ℕ} {f : ℕ → ℕ →₀ ℝ}
     (hk' : k' > k) :
     gtilde cw x k = gtilde (Function.update cw k' f) x k := by
@@ -181,16 +136,13 @@ lemma gtilde_update (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E
 def komlosFormula (x : ℕ → ℕ → E) (cw : ℕ → ℕ → ℕ →₀ ℝ) (k n : ℕ) : E :=
   (convexWeightsConvolution cw k n).sum (fun m cwm ↦ cwm • x k m)
 
-omit [InnerProductSpace ℝ E] [CompleteSpace E] in
 lemma komlosFormula_cong (x : ℕ → ℕ → E) {cw1 : ℕ → ℕ → ℕ →₀ ℝ} {cw2 : ℕ → ℕ → ℕ →₀ ℝ} {k : ℕ}
   (h : ∀ k' ≤ k, cw1 k' = cw2 k') :
   komlosFormula x cw1 k = komlosFormula x cw2 k := by
-  unfold komlosFormula
-  rw [convexWeightsConvolution_cong]
+  unfold komlosFormula; rw [convexWeightsConvolution_cong]
   exact h
 
-omit [InnerProductSpace ℝ E] [CompleteSpace E] in
-lemma exist_weights {x g : ℕ → E}
+lemma convex_weights_of_mem_convexHull_reindexed {x g : ℕ → E}
     (h_convex : ∀ n, g n ∈ convexHull ℝ (Set.range fun m ↦ x (n + m))) :
     ∀ n, ∃ w : ℕ →₀ ℝ, (∀ i, 0 ≤ w i) ∧ (∀ m < n, w m = 0)
       ∧ w.sum (fun _ wi ↦ wi) = 1
@@ -215,46 +167,24 @@ lemma exist_weights {x g : ℕ → E}
     simp [hw_combo]
   exact ⟨w', nonneg, zero_lt, sum_one, sum_eq⟩
 
-lemma komlos_base [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
-  {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
+variable [CompleteSpace E]
+
+lemma komlos_base {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
   ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ),
     (∃ glim : E, Tendsto (komlosFormula x cw 0) atTop (𝓝 glim))
     ∧ (∀ k n m, 0 ≤ cw k n m) := by
     obtain ⟨g, h_convex, h_lim⟩ := komlos_norm (hx 0)
-
-    let cw (n : ℕ) := Classical.choose
-      (exist_weights (x := fun m ↦ x 0 m) (g := g) h_convex n)
+    let cw (n : ℕ) := Classical.choose (convex_weights_of_mem_convexHull_reindexed h_convex n)
     use (fun k ↦ cw)
-
     constructor
     · have hg (n : ℕ) : (cw n).sum (fun m cwm ↦ cwm • x 0 m) = g n := by
-        exact (Classical.choose_spec
-          (exist_weights (x := fun m ↦ x 0 m) (g := g) h_convex n)).2.2.2
+        exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed h_convex n)).2.2.2
       unfold komlosFormula
-      simp only [convexWeightsConvolution]
-      simp_rw [hg]
-      exact h_lim
+      simp only [convexWeightsConvolution, hg, h_lim]
     · intro k n m
-      exact (Classical.choose_spec
-        (exist_weights (x := fun m ↦ x 0 m) (g := g) h_convex n)).1 m
-
-lemma convex_combination_bounded [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
-  {x : ℕ → E} {w : ℕ → ℕ →₀ ℝ} (hw : ∀ n, (w n).sum (fun _ wi ↦ wi) = 1)
-  (hw_nonneg : ∀ n m, 0 ≤ (w n) m)
-  (hx : ∃ M : ℝ, ∀ n, ‖x n‖ ≤ M) :
-  ∃ M, ∀ n, ‖(w n).sum (fun i wi ↦ wi • x i)‖ ≤ M := by
-  obtain ⟨M, hM⟩ := hx
-  use M
-  intro n
-  have h_sum : ‖(w n).sum (fun i wi => wi • x i)‖ ≤ ∑ i ∈ (w n).support, (w n i) * ‖x i‖ := by
-    convert norm_sum_le _ _ using 2
-    simp +decide [norm_smul, abs_of_nonneg (hw_nonneg _ _)]
-  refine le_trans h_sum (le_trans (Finset.sum_le_sum fun i hi =>
-    mul_le_mul_of_nonneg_left (hM i) (hw_nonneg n i)) ?_)
-  simp_all [← Finset.sum_mul _ _ _, Finsupp.sum]
-
-lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
-  {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ)
+      exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed h_convex n)).1 m
+
+lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ)
   (cw : ℕ → ℕ → ℕ →₀ ℝ) (hcw: ∀ k n m, 0 ≤ cw k n m) :
   ∃ (cw_new : ℕ → ℕ → ℕ →₀ ℝ),
     (∃ glim : E, Tendsto (komlosFormula x cw_new (k+1)) atTop (𝓝 glim))
@@ -267,7 +197,7 @@ lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
     · sorry
     -- this requires an extra assumption on cw: we need that the cw sum up to one since otherwise
     -- gtilde might not be bounded
-    · sorry
+    · exact fun n m ↦ convexWeightsConvolution_nonneg hcw k n m
 
   obtain ⟨g_step, gstep_conv, gstep_lim⟩ := komlos_norm (gtilde_bound)
 
@@ -275,16 +205,17 @@ lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
     (∀ n m, 0 ≤ w n m) ∧ (∀ n, ∀ m < n, w n m = 0)
     ∧ (∀ n, (w n).sum (fun _ wi ↦ wi) = 1)
     ∧ ∀ n, (w n).sum (fun i wi ↦ wi • gtilde cw x k i) = g_step n := by
-    refine ⟨fun n ↦ Classical.choose (exist_weights gstep_conv n), ?_⟩
+    refine ⟨fun n ↦ Classical.choose (convex_weights_of_mem_convexHull_reindexed gstep_conv n), ?_⟩
     refine ⟨?_, ?_, ?_, ?_⟩
     · intro n m
-      exact (Classical.choose_spec (exist_weights gstep_conv n)).1 m
+      exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed gstep_conv n)).1 m
     · intro n m hm
-      exact (Classical.choose_spec (exist_weights gstep_conv n)).2.1 m hm
+      exact (Classical.choose_spec
+        (convex_weights_of_mem_convexHull_reindexed gstep_conv n)).2.1 m hm
     · intro n
-      exact (Classical.choose_spec (exist_weights gstep_conv n)).2.2.1
+      exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed gstep_conv n)).2.2.1
     · intro n
-      exact (Classical.choose_spec (exist_weights gstep_conv n)).2.2.2
+      exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed gstep_conv n)).2.2.2
 
   obtain ⟨cw_step, ⟨hnonneg, hzero, hsum, hcombo⟩⟩ := cw_step_exists
 
@@ -297,7 +228,6 @@ lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
     have aux: (convexWeightsConvolution cw_new (k + 1) n) =
       (convexWeightsMul (cw_step n) (convexWeightsConvolution cw k)) := by
       rw [convexWeightsConvolution]
-      beta_reduce
       unfold cw_new
       rw [Function.update_self, convexWeightsConvolution_update cw (show k+1 > k by grind)]
 
@@ -305,7 +235,6 @@ lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
     unfold gtilde
     simp only [Finsupp.sum]
     rw [convexWeightsMul_eq (cw_step n) (convexWeightsConvolution cw k)]
-    beta_reduce
 
     set cwold := convexWeightsConvolution cw k
     simp_rw [Finset.sum_smul]
@@ -317,9 +246,9 @@ lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
     have subset: (cwold i).support ⊆ (convexWeightsMul (cw_step n) cwold).support := by
       refine support_subset_convexWeightsMul_support hi ?_ ?_
       · grind only
-      · unfold cwold -- here we need to use hcw, probably through a further intermediate lemma
+      · unfold cwold
         intro a ha m
-        sorry
+        exact convexWeightsConvolution_nonneg hcw k a m
 
     rw [Finset.smul_sum]
     simp_rw [← smul_smul]
@@ -330,10 +259,10 @@ lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
     rw [is_zero]
     simp
 
-  have old_indices_untouched: ∀ i ≤ k, cw_new i = cw i := sorry -- trivial by construction
+  have old_indices_untouched: ∀ i ≤ k, cw_new i = cw i := by grind
 
   use cw_new
-  refine ⟨?_, by trivial, ?_⟩
+  refine ⟨?_, old_indices_untouched, ?_⟩
   · obtain ⟨glim, hglim⟩ := gstep_lim
     use glim
     exact Tendsto.congr g_new_expression hglim
@@ -345,38 +274,34 @@ lemma komlos_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
       exact hnonneg _ _
     · exact hcw k' n m
 
-def komlos_stage [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
-  {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (stage : ℕ) :
+def komlos_stage {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (stage : ℕ) :
   { w : ℕ → ℕ → ℕ →₀ ℝ // ∀ k n m, 0 ≤ w k n m } :=
   match stage with
   | 0 => by
     use Classical.choose (komlos_base hx)
-    sorry
+    exact Classical.choose_spec (komlos_base hx) |>.2
   | stage+1 => by
-      let ⟨pre, hpre⟩ := komlos_stage hx stage
-      let aux := komlos_step hx stage pre hpre
-      use Classical.choose (aux)
-      sorry
+      let ⟨previous, hprevious⟩ := komlos_stage hx stage
+      let step := komlos_step hx stage previous hprevious
+      use Classical.choose step
+      exact Classical.choose_spec step |>.2.2
 
-lemma komlos_stage_lim [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
-  {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
+lemma komlos_stage_lim {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
   (∃ glim : E, Tendsto (komlosFormula x (komlos_stage hx k) k) atTop (𝓝 glim)) := by
   induction k with
-  | zero => sorry
-  | succ k _ =>
-    let aux := komlos_step hx k (komlos_stage hx k).val (komlos_stage hx k).prop
-    exact Classical.choose_spec aux |>.1
+  | zero => exact Classical.choose_spec (komlos_base hx) |>.1
+  | succ k _ => exact
+      Classical.choose_spec (komlos_step hx k (komlos_stage hx k).val (komlos_stage hx k).prop) |>.1
 
-lemma agreement_step [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
-  {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
+lemma agreement_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
   ∀ i ≤ k, (komlos_stage hx k).val i = (komlos_stage hx (k+1)).val i := by
   intro i hi
   let aux := komlos_step hx k (komlos_stage hx k).val (komlos_stage hx k).prop
   let ⟨_, aux2, _⟩ := Classical.choose_spec aux
   exact Eq.symm (aux2 i hi)
 
-lemma agreement_needed [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
-  {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (i k : ℕ) (hi : i ≤ k) :
+lemma agreement_necessary_condition {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M)
+  (i k : ℕ) (hi : i ≤ k) :
   (komlos_stage hx i).val i = (komlos_stage hx k).val i := by
   let n := k-i
   suffices (komlos_stage hx i).val i = (komlos_stage hx (i+n)).val i from by
@@ -389,34 +314,29 @@ lemma agreement_needed [NormedAddCommGroup E] [InnerProductSpace ℝ E] [Complet
   rw [← add_assoc, hn]
   apply agreement_step hx (i+n) i (by grind)
 
-lemma komlos_convex_weights [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
+-- TODO: Add convex weight conditions: nonnegativity and summing up to 1
+lemma komlos_convex_weights
     {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
     ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ), ∀ k : ℕ,
     ∃ glim : E, Tendsto (komlosFormula x cw k) atTop (𝓝 glim) := by
-
   have hcwStage2 (k : ℕ) :
     ∃ glim : E, Tendsto (komlosFormula x (komlos_stage hx k).val k) atTop (𝓝 glim) := by
     apply komlos_stage_lim
-
   let cw (k : ℕ) : ℕ → ℕ →₀ ℝ := (komlos_stage hx k).val k
-
   have agreement (k i : ℕ) (hi : i ≤ k) :
     cw i = (komlos_stage hx k).val i := by
     unfold cw
-    apply agreement_needed hx
+    apply agreement_necessary_condition hx
     exact hi
-
   have transfer (k : ℕ) : komlosFormula x cw k = komlosFormula x (komlos_stage hx k).val k := by
     apply komlosFormula_cong x
     exact agreement k
-
   use cw
   intro k
   simp_rw [transfer k]
   exact hcwStage2 k
 
-theorem komlos_L1 [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
-    [MeasurableSpace E] [BorelSpace E] {f : ℕ → Ω → E} {P : Measure Ω}
+theorem komlos_L1 [MeasurableSpace E] [BorelSpace E] {f : ℕ → Ω → E} {P : Measure Ω}
     (hf : UniformIntegrable f 1 P) :
     ∃ (g : ℕ → Ω → E) (glim : Ω → E), (∀ n, g n ∈ convexHull ℝ (Set.range fun m ↦ f (n + m))) ∧
       Tendsto (fun n ↦ eLpNorm (g n - glim) 1 P) atTop (𝓝 0) := by

From 81ccba71e846c95070a60296ec46601cf2f47e0f Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Wed, 22 Apr 2026 10:44:05 +0100
Subject: [PATCH 16/37] feat(Komlos): Prove remaining sorry

---
 BrownianMotion/StochasticIntegral/Komlos.lean | 76 +++++++++----------
 1 file changed, 36 insertions(+), 40 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index d65698d0..72aa146f 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -172,35 +172,32 @@ variable [CompleteSpace E]
 lemma komlos_base {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
   ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ),
     (∃ glim : E, Tendsto (komlosFormula x cw 0) atTop (𝓝 glim))
-    ∧ (∀ k n m, 0 ≤ cw k n m) := by
+    ∧ (∀ k n m, 0 ≤ cw k n m) ∧ (∀ k n, (cw k n).sum (fun _ wi ↦ wi) = 1) := by
     obtain ⟨g, h_convex, h_lim⟩ := komlos_norm (hx 0)
     let cw (n : ℕ) := Classical.choose (convex_weights_of_mem_convexHull_reindexed h_convex n)
     use (fun k ↦ cw)
-    constructor
+    refine ⟨?_, ?_, ?_⟩
     · have hg (n : ℕ) : (cw n).sum (fun m cwm ↦ cwm • x 0 m) = g n := by
         exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed h_convex n)).2.2.2
       unfold komlosFormula
       simp only [convexWeightsConvolution, hg, h_lim]
-    · intro k n m
-      exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed h_convex n)).1 m
+    · intro k n
+      exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed h_convex n)).1
+    · intro k n
+      exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed h_convex n)).2.2.1
 
 lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ)
-  (cw : ℕ → ℕ → ℕ →₀ ℝ) (hcw: ∀ k n m, 0 ≤ cw k n m) :
+  (cw : ℕ → ℕ → ℕ →₀ ℝ) (cw_nonneg : ∀ k n m, 0 ≤ cw k n m)
+  (cw_sum_one : ∀ k n, (cw k n).sum (fun _ wi ↦ wi) = 1) :
   ∃ (cw_new : ℕ → ℕ → ℕ →₀ ℝ),
     (∃ glim : E, Tendsto (komlosFormula x cw_new (k+1)) atTop (𝓝 glim))
     ∧ (∀ i ≤ k, cw_new i = cw i)
-    ∧ (∀ k n m, 0 ≤ cw_new k n m) := by
-
-  have gtilde_bound : ∃ M, ∀ n, ‖gtilde cw x k n‖ ≤ M := by
-    unfold gtilde
-    apply convex_combination_bounded ?_ ?_ (hx (k+1))
-    · sorry
-    -- this requires an extra assumption on cw: we need that the cw sum up to one since otherwise
-    -- gtilde might not be bounded
-    · exact fun n m ↦ convexWeightsConvolution_nonneg hcw k n m
-
+    ∧ (∀ k n m, 0 ≤ cw_new k n m)
+    ∧ (∀ k n, (cw_new k n).sum (fun _ wi ↦ wi) = 1) := by
+  have gtilde_bound : ∃ M, ∀ n, ‖gtilde cw x k n‖ ≤ M := convex_combination_bounded
+      (convexWeightsConvolution_sum_one cw_nonneg cw_sum_one k)
+      (convexWeightsConvolution_nonneg cw_nonneg k) (hx (k+1))
   obtain ⟨g_step, gstep_conv, gstep_lim⟩ := komlos_norm (gtilde_bound)
-
   have cw_step_exists : ∃ w : ℕ → ℕ →₀ ℝ,
     (∀ n m, 0 ≤ w n m) ∧ (∀ n, ∀ m < n, w n m = 0)
     ∧ (∀ n, (w n).sum (fun _ wi ↦ wi) = 1)
@@ -216,40 +213,31 @@ lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n,
       exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed gstep_conv n)).2.2.1
     · intro n
       exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed gstep_conv n)).2.2.2
-
   obtain ⟨cw_step, ⟨hnonneg, hzero, hsum, hcombo⟩⟩ := cw_step_exists
-
   let cw_new := Function.update cw (k+1) cw_step
-
   have g_new_expression (n : ℕ) :
     g_step n = (convexWeightsConvolution cw_new (k + 1) n).sum (fun m cwm ↦ cwm • x (k+1) m) := by
     rw [← hcombo n]
-
-    have aux: (convexWeightsConvolution cw_new (k + 1) n) =
-      (convexWeightsMul (cw_step n) (convexWeightsConvolution cw k)) := by
-      rw [convexWeightsConvolution]
-      unfold cw_new
-      rw [Function.update_self, convexWeightsConvolution_update cw (show k+1 > k by grind)]
-
+    set cwold := convexWeightsConvolution cw k
+    have aux: (convexWeightsConvolution cw_new (k + 1) n) = (convexWeightsMul (cw_step n) cwold)
+      := by
+      unfold cw_new cwold
+      rw [convexWeightsConvolution, Function.update_self,
+          convexWeightsConvolution_update cw (show k+1 > k by grind)]
     rw [aux]
     unfold gtilde
     simp only [Finsupp.sum]
     rw [convexWeightsMul_eq (cw_step n) (convexWeightsConvolution cw k)]
-
-    set cwold := convexWeightsConvolution cw k
     simp_rw [Finset.sum_smul]
     rw [Finset.sum_comm]
-
     refine Finset.sum_congr rfl ?_
     intro i hi
-
     have subset: (cwold i).support ⊆ (convexWeightsMul (cw_step n) cwold).support := by
       refine support_subset_convexWeightsMul_support hi ?_ ?_
       · grind only
       · unfold cwold
         intro a ha m
-        exact convexWeightsConvolution_nonneg hcw k a m
-
+        exact convexWeightsConvolution_nonneg cw_nonneg k a m
     rw [Finset.smul_sum]
     simp_rw [← smul_smul]
     apply Finset.sum_subset subset ?_
@@ -258,11 +246,17 @@ lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n,
       grind => instantiate only [= Finsupp.mem_support_iff]
     rw [is_zero]
     simp
-
   have old_indices_untouched: ∀ i ≤ k, cw_new i = cw i := by grind
-
+  have sum_one (k' n : ℕ) : ((cw_new k' n).sum fun x wi ↦ wi) = 1 := by
+    unfold cw_new
+    by_cases hk': k+1 = k'
+    · simp_rw [hk']
+      simp only [Function.update_self]
+      exact (hsum n)
+    · rw [← cw_sum_one k' n, Function.update_of_ne]
+      grind
   use cw_new
-  refine ⟨?_, old_indices_untouched, ?_⟩
+  refine ⟨?_, old_indices_untouched, ?_, sum_one⟩
   · obtain ⟨glim, hglim⟩ := gstep_lim
     use glim
     exact Tendsto.congr g_new_expression hglim
@@ -272,17 +266,17 @@ lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n,
     split_ifs
     · simp only [eq_rec_constant]
       exact hnonneg _ _
-    · exact hcw k' n m
+    · exact cw_nonneg k' n m
 
 def komlos_stage {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (stage : ℕ) :
-  { w : ℕ → ℕ → ℕ →₀ ℝ // ∀ k n m, 0 ≤ w k n m } :=
+  { w : ℕ → ℕ → ℕ →₀ ℝ // (∀ k n m, 0 ≤ w k n m) ∧ ∀ k n, (w k n).sum (fun _ wi ↦ wi) = 1} :=
   match stage with
   | 0 => by
     use Classical.choose (komlos_base hx)
     exact Classical.choose_spec (komlos_base hx) |>.2
   | stage+1 => by
       let ⟨previous, hprevious⟩ := komlos_stage hx stage
-      let step := komlos_step hx stage previous hprevious
+      let step := komlos_step hx stage previous hprevious.1 hprevious.2
       use Classical.choose step
       exact Classical.choose_spec step |>.2.2
 
@@ -291,12 +285,14 @@ lemma komlos_stage_lim {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, 
   induction k with
   | zero => exact Classical.choose_spec (komlos_base hx) |>.1
   | succ k _ => exact
-      Classical.choose_spec (komlos_step hx k (komlos_stage hx k).val (komlos_stage hx k).prop) |>.1
+      Classical.choose_spec (komlos_step hx k
+        (komlos_stage hx k).val (komlos_stage hx k).prop.1 (komlos_stage hx k).prop.2) |>.1
 
 lemma agreement_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
   ∀ i ≤ k, (komlos_stage hx k).val i = (komlos_stage hx (k+1)).val i := by
   intro i hi
-  let aux := komlos_step hx k (komlos_stage hx k).val (komlos_stage hx k).prop
+  let aux := komlos_step hx k (komlos_stage hx k).val (komlos_stage hx k).prop.1
+    (komlos_stage hx k).prop.2
   let ⟨_, aux2, _⟩ := Classical.choose_spec aux
   exact Eq.symm (aux2 i hi)
 

From 1bf5e1f722bfbeef0749c21c0b33dd03fa557cc7 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Wed, 22 Apr 2026 11:19:41 +0100
Subject: [PATCH 17/37] fix(blueprint): add missing \leanok

---
 BrownianMotion/StochasticIntegral/ConvexWeights.lean | 2 +-
 blueprint/src/chapters/doob_meyer.tex                | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
index b14a0487..83a2d6e5 100644
--- a/BrownianMotion/StochasticIntegral/ConvexWeights.lean
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -37,7 +37,7 @@ def convexWeightsMul (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) : ℕ →
     (fun m hm ↦ by
       simp only [Finset.mem_biUnion, Finsupp.mem_support_iff]
       by_contra h
-      push_neg at h
+      push Not at h
       apply hm
       apply Finset.sum_eq_zero
       intro k hk
diff --git a/blueprint/src/chapters/doob_meyer.tex b/blueprint/src/chapters/doob_meyer.tex
index c44beb5c..b52765f0 100644
--- a/blueprint/src/chapters/doob_meyer.tex
+++ b/blueprint/src/chapters/doob_meyer.tex
@@ -98,18 +98,20 @@ \section{Komlòs Lemma}
 By convex weights on $\mathbb{N}$, we mean a sequence of non-negative real numbers $(a_n)_{n \in \mathbb{N}}$ with finitely many nonzero entries such that $\sum_{n \in \mathbb{N}} a_n = 1$.
 
 \begin{definition}\label{def:convex_weights_product}
-  \lean{convexWeightsMul}
+  \lean{convexWeightsMul} \leanok
 If $(a_m)_{m \in \mathbb{N}}$ are convex weights and $(b^n_m)_{n,m \in \mathbb{N}}$ is such that for all $n$, the $(b^n_m)$ are convex weights, then we denote by $(a_\cdot) * (b^\cdot_\cdot)$ the convex weights defined by $((a_\cdot) * (b^\cdot_\cdot))_m = \sum_{k} a_k b^k_m$.
 \end{definition}
 
 
 \begin{lemma}\label{lem:komlos_convex_weights}
   \lean{komlos_convex_weights}
+  \leanok
 Let $E$ be a Hilbert space and for $i \in \mathbb{N}$, let $(x_n^{(i)})_{n \in \mathbb{N}}$ be a bounded sequence in $E$. Then there exists a sequence of convex weights $(\lambda^{k,n}_\cdot)_{k, n \in \mathbb{N}}$ with $\lambda^{k,n}_m = 0$ for $m < n$ such that for all $k \in \mathbb{N}$, $\left(\sum_{m \ge n} \left((\lambda^{k,n}_\cdot) * \ldots * (\lambda^{1,\cdot}_\cdot)\right)_m x_m^{(k)}\right)_{n \in \mathbb{N}}$ converges.
 \end{lemma}
 
 \begin{proof}
   \uses{lem:komlos_norm,def:convex_weights_product}
+  \leanok
 First by Lemma~\ref{lem:komlos_norm} applied to $(x_n^{(1)})_{n\in\mathbb{N}}$ in the Hilbert space $E$, there exist $g_n^1 \in convex(x_n^{(1)}, x_{n+1}^{(1)}, \ldots)$ (call its weights $\lambda^{1,n}_n,\cdots,\lambda^{1,n}_{N^1_n}$) such that $g_n^1$ converges to some $g^1$.
 
 Secondly define $\tilde{g}_n^1$, convex combination of $x_n^{(2)}, x_{n+1}^{(2)}, \ldots$ with weights $\lambda^{1,n}_n,\cdots,\lambda^{1,n}_{N^1_n}$.

From d8472a356c196c3aa27b23421cd03e4bb7257ce6 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Wed, 22 Apr 2026 14:11:57 +0100
Subject: [PATCH 18/37] refactor(Komlos): separate out lemma from long proof

---
 .../StochasticIntegral/ConvexWeights.lean     | 14 ++++++++
 BrownianMotion/StochasticIntegral/Komlos.lean | 33 ++++---------------
 2 files changed, 20 insertions(+), 27 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
index 83a2d6e5..257d1d3c 100644
--- a/BrownianMotion/StochasticIntegral/ConvexWeights.lean
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -145,3 +145,17 @@ lemma convex_combination_bounded [NormedAddCommGroup E] [InnerProductSpace ℝ E
   refine le_trans h_sum (le_trans (Finset.sum_le_sum fun i hi =>
     mul_le_mul_of_nonneg_left (hM i) (hw_nonneg n i)) ?_)
   simp_all [← Finset.sum_mul _ _ _, Finsupp.sum]
+
+lemma convexWeightsMul_sum_smul [Module ℝ E]
+    (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) (f : ℕ → E)
+    (ha : ∀ k ∈ a.support, 0 ≤ a k) (hb : ∀ k ∈ a.support, ∀ m, 0 ≤ b k m) :
+    a.sum (fun i wi ↦ wi • (b i).sum (fun m bm ↦ bm • f m))
+      = (convexWeightsMul a b).sum (fun m cwm ↦ cwm • f m) := by
+  simp only [Finsupp.sum, Finset.smul_sum, convexWeightsMul_eq, Finset.sum_smul]
+  rw [Finset.sum_comm, Finset.sum_congr rfl]
+  intro k hk
+  have inclusion: (b k).support ⊆ (convexWeightsMul a b).support :=
+    support_subset_convexWeightsMul_support hk ha hb
+  rw [← Finset.sum_subset inclusion]
+  · simp only [mul_smul]
+  · aesop
diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 72aa146f..1c4dc267 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -217,35 +217,14 @@ lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n,
   let cw_new := Function.update cw (k+1) cw_step
   have g_new_expression (n : ℕ) :
     g_step n = (convexWeightsConvolution cw_new (k + 1) n).sum (fun m cwm ↦ cwm • x (k+1) m) := by
-    rw [← hcombo n]
-    set cwold := convexWeightsConvolution cw k
-    have aux: (convexWeightsConvolution cw_new (k + 1) n) = (convexWeightsMul (cw_step n) cwold)
-      := by
-      unfold cw_new cwold
+    have aux : (convexWeightsConvolution cw_new (k + 1) n)
+      = (convexWeightsMul (cw_step n) (convexWeightsConvolution cw k)) := by
+      unfold cw_new
       rw [convexWeightsConvolution, Function.update_self,
           convexWeightsConvolution_update cw (show k+1 > k by grind)]
-    rw [aux]
-    unfold gtilde
-    simp only [Finsupp.sum]
-    rw [convexWeightsMul_eq (cw_step n) (convexWeightsConvolution cw k)]
-    simp_rw [Finset.sum_smul]
-    rw [Finset.sum_comm]
-    refine Finset.sum_congr rfl ?_
-    intro i hi
-    have subset: (cwold i).support ⊆ (convexWeightsMul (cw_step n) cwold).support := by
-      refine support_subset_convexWeightsMul_support hi ?_ ?_
-      · grind only
-      · unfold cwold
-        intro a ha m
-        exact convexWeightsConvolution_nonneg cw_nonneg k a m
-    rw [Finset.smul_sum]
-    simp_rw [← smul_smul]
-    apply Finset.sum_subset subset ?_
-    intro m hm1 hm2
-    have is_zero: cwold i m = 0 := by
-      grind => instantiate only [= Finsupp.mem_support_iff]
-    rw [is_zero]
-    simp
+    rw [← hcombo n, aux]
+    exact convexWeightsMul_sum_smul (cw_step n) (convexWeightsConvolution cw k) (x (k + 1))
+      (fun _ hk => hnonneg _ _) (fun i _ m => convexWeightsConvolution_nonneg cw_nonneg k i m)
   have old_indices_untouched: ∀ i ≤ k, cw_new i = cw i := by grind
   have sum_one (k' n : ℕ) : ((cw_new k' n).sum fun x wi ↦ wi) = 1 := by
     unfold cw_new

From d14c9b3f4a53d6722a1eda5d739bc5feacc000b1 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Wed, 22 Apr 2026 14:35:22 +0100
Subject: [PATCH 19/37] refactor(Komlos): fix linter errors

* add documentation
* make some declarations private
---
 .../StochasticIntegral/ConvexWeights.lean        |  6 ++++++
 BrownianMotion/StochasticIntegral/Komlos.lean    | 16 ++++++++++------
 2 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
index 257d1d3c..af82f74a 100644
--- a/BrownianMotion/StochasticIntegral/ConvexWeights.lean
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -31,6 +31,9 @@ lemma convex_weights_of_mem_convexHull_indexed {s : ι → E} {x : E}
 
 noncomputable section
 
+/-- Given convex weights `a : ℕ →₀ ℝ` and a family of convex weights `b : ℕ → ℕ →₀ ℝ`,
+`convexWeightsMul a b` is the convex combination of the `b k`, weighted by `a`. That is,
+`(convexWeightsMul a b) m = ∑ k ∈ a.support, a k * b k m`. -/
 def convexWeightsMul (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) : ℕ →₀ ℝ :=
   Finsupp.onFinset (a.support.biUnion (fun k ↦ (b k).support))
     (fun m ↦ ∑ k ∈ a.support, a k * (b k m))
@@ -72,6 +75,9 @@ lemma convexWeightsMul_sum_one (ha_nonneg : ∀ n, a n ≥ 0) (hb_nonneg : ∀ n
         (fun k _ => mul_nonneg (ha_nonneg k ) (hb_nonneg k j )) (by aesop)))
       · aesop
 
+/-- Given a doubly-indexed family of convex weights `cw : ℕ → ℕ → ℕ →₀ ℝ`,
+`convexWeightsConvolution cw k n` is the iterated convex multiplication obtained by combining
+the weights `cw 0 n, cw 1 n, …, cw k n` via `convexWeightsMul`. -/
 def convexWeightsConvolution (cw : ℕ → ℕ → ℕ →₀ ℝ) : ℕ → ℕ → ℕ →₀ ℝ
   | 0 => fun n ↦ cw 0 n
   | k + 1 => fun n ↦ convexWeightsMul (cw (k+1) n) (convexWeightsConvolution cw k)
diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 1c4dc267..6a41753e 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -123,16 +123,19 @@ lemma komlos_norm [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
 noncomputable section
 variable [NormedAddCommGroup E] [InnerProductSpace ℝ E]
 
-def gtilde (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E) (k : ℕ) (n : ℕ) : E :=
+private def gtilde (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E) (k : ℕ) (n : ℕ) : E :=
   (convexWeightsConvolution cw k n).sum (fun m cwm ↦ cwm • (x (k+1) m))
 
-lemma gtilde_update (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E) {k k' : ℕ} {f : ℕ → ℕ →₀ ℝ}
+private lemma gtilde_update (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E) {k k' : ℕ} {f : ℕ → ℕ →₀ ℝ}
     (hk' : k' > k) :
     gtilde cw x k = gtilde (Function.update cw k' f) x k := by
   funext n
   simp only [gtilde]
   rw [← convexWeightsConvolution_update cw hk']
 
+/-- `komlosFormula x cw k n` is the convex combination of the stage-`k` vectors `x k m`,
+weighted by `convexWeightsConvolution cw k n`. It is the sequence whose convergence is
+established at each stage of the Komlós construction. -/
 def komlosFormula (x : ℕ → ℕ → E) (cw : ℕ → ℕ → ℕ →₀ ℝ) (k n : ℕ) : E :=
   (convexWeightsConvolution cw k n).sum (fun m cwm ↦ cwm • x k m)
 
@@ -247,7 +250,7 @@ lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n,
       exact hnonneg _ _
     · exact cw_nonneg k' n m
 
-def komlos_stage {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (stage : ℕ) :
+private def komlos_stage {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (stage : ℕ) :
   { w : ℕ → ℕ → ℕ →₀ ℝ // (∀ k n m, 0 ≤ w k n m) ∧ ∀ k n, (w k n).sum (fun _ wi ↦ wi) = 1} :=
   match stage with
   | 0 => by
@@ -259,7 +262,7 @@ def komlos_stage {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n,
       use Classical.choose step
       exact Classical.choose_spec step |>.2.2
 
-lemma komlos_stage_lim {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
+private lemma komlos_stage_lim {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
   (∃ glim : E, Tendsto (komlosFormula x (komlos_stage hx k) k) atTop (𝓝 glim)) := by
   induction k with
   | zero => exact Classical.choose_spec (komlos_base hx) |>.1
@@ -267,7 +270,7 @@ lemma komlos_stage_lim {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, 
       Classical.choose_spec (komlos_step hx k
         (komlos_stage hx k).val (komlos_stage hx k).prop.1 (komlos_stage hx k).prop.2) |>.1
 
-lemma agreement_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
+private lemma agreement_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
   ∀ i ≤ k, (komlos_stage hx k).val i = (komlos_stage hx (k+1)).val i := by
   intro i hi
   let aux := komlos_step hx k (komlos_stage hx k).val (komlos_stage hx k).prop.1
@@ -275,7 +278,8 @@ lemma agreement_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀
   let ⟨_, aux2, _⟩ := Classical.choose_spec aux
   exact Eq.symm (aux2 i hi)
 
-lemma agreement_necessary_condition {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M)
+private lemma agreement_necessary_condition {x : ℕ → ℕ → E}
+    (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M)
   (i k : ℕ) (hi : i ≤ k) :
   (komlos_stage hx i).val i = (komlos_stage hx k).val i := by
   let n := k-i

From 2509afb076939c5dca4019654b35f58506032eda Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Fri, 24 Apr 2026 09:44:07 +0100
Subject: [PATCH 20/37] feat(Komlos): add remaining intermediate Komlos lemmas

---
 BrownianMotion/StochasticIntegral/Komlos.lean | 83 +++++++++++++++++--
 1 file changed, 75 insertions(+), 8 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 6a41753e..14ca70d0 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -136,8 +136,8 @@ private lemma gtilde_update (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → 
 /-- `komlosFormula x cw k n` is the convex combination of the stage-`k` vectors `x k m`,
 weighted by `convexWeightsConvolution cw k n`. It is the sequence whose convergence is
 established at each stage of the Komlós construction. -/
-def komlosFormula (x : ℕ → ℕ → E) (cw : ℕ → ℕ → ℕ →₀ ℝ) (k n : ℕ) : E :=
-  (convexWeightsConvolution cw k n).sum (fun m cwm ↦ cwm • x k m)
+def komlosFormula (x : ℕ → ℕ → E) (cw : ℕ → ℕ → ℕ →₀ ℝ) (k i n : ℕ) : E :=
+  (convexWeightsConvolution cw k n).sum (fun m cwm ↦ cwm • x i m)
 
 lemma komlosFormula_cong (x : ℕ → ℕ → E) {cw1 : ℕ → ℕ → ℕ →₀ ℝ} {cw2 : ℕ → ℕ → ℕ →₀ ℝ} {k : ℕ}
   (h : ∀ k' ≤ k, cw1 k' = cw2 k') :
@@ -174,7 +174,7 @@ variable [CompleteSpace E]
 
 lemma komlos_base {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
   ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ),
-    (∃ glim : E, Tendsto (komlosFormula x cw 0) atTop (𝓝 glim))
+    (∃ glim : E, Tendsto (komlosFormula x cw 0 0) atTop (𝓝 glim))
     ∧ (∀ k n m, 0 ≤ cw k n m) ∧ (∀ k n, (cw k n).sum (fun _ wi ↦ wi) = 1) := by
     obtain ⟨g, h_convex, h_lim⟩ := komlos_norm (hx 0)
     let cw (n : ℕ) := Classical.choose (convex_weights_of_mem_convexHull_reindexed h_convex n)
@@ -193,7 +193,7 @@ lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n,
   (cw : ℕ → ℕ → ℕ →₀ ℝ) (cw_nonneg : ∀ k n m, 0 ≤ cw k n m)
   (cw_sum_one : ∀ k n, (cw k n).sum (fun _ wi ↦ wi) = 1) :
   ∃ (cw_new : ℕ → ℕ → ℕ →₀ ℝ),
-    (∃ glim : E, Tendsto (komlosFormula x cw_new (k+1)) atTop (𝓝 glim))
+    (∃ glim : E, Tendsto (komlosFormula x cw_new (k+1) (k+1)) atTop (𝓝 glim))
     ∧ (∀ i ≤ k, cw_new i = cw i)
     ∧ (∀ k n m, 0 ≤ cw_new k n m)
     ∧ (∀ k n, (cw_new k n).sum (fun _ wi ↦ wi) = 1) := by
@@ -263,7 +263,7 @@ private def komlos_stage {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ,
       exact Classical.choose_spec step |>.2.2
 
 private lemma komlos_stage_lim {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
-  (∃ glim : E, Tendsto (komlosFormula x (komlos_stage hx k) k) atTop (𝓝 glim)) := by
+  (∃ glim : E, Tendsto (komlosFormula x (komlos_stage hx k) k k) atTop (𝓝 glim)) := by
   induction k with
   | zero => exact Classical.choose_spec (komlos_base hx) |>.1
   | succ k _ => exact
@@ -297,10 +297,10 @@ private lemma agreement_necessary_condition {x : ℕ → ℕ → E}
 lemma komlos_convex_weights
     {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
     ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ), ∀ k : ℕ,
-    ∃ glim : E, Tendsto (komlosFormula x cw k) atTop (𝓝 glim) := by
+    ∃ glim : E, Tendsto (komlosFormula x cw k k) atTop (𝓝 glim) := by
   have hcwStage2 (k : ℕ) :
-    ∃ glim : E, Tendsto (komlosFormula x (komlos_stage hx k).val k) atTop (𝓝 glim) := by
-    apply komlos_stage_lim
+    ∃ glim : E, Tendsto (komlosFormula x (komlos_stage hx k).val k k) atTop (𝓝 glim) := by
+    simpa using (komlos_stage_lim (x := x) hx k)
   let cw (k : ℕ) : ℕ → ℕ →₀ ℝ := (komlos_stage hx k).val k
   have agreement (k i : ℕ) (hi : i ≤ k) :
     cw i = (komlos_stage hx k).val i := by
@@ -315,6 +315,73 @@ lemma komlos_convex_weights
   simp_rw [transfer k]
   exact hcwStage2 k
 
+
+def convexTail (x : ℕ → E) : Set (ℕ → E) :=
+  { y | ∀ n, y n ∈ convexHull ℝ (Set.range (fun m ↦ x (n + m))) }
+
+omit [CompleteSpace E] in
+lemma TendstoUniformly_convexTail {x : ℕ → E} {xlim : E} (hx : Tendsto x atTop (𝓝 xlim)) :
+  TendstoUniformly (fun (n : ℕ) (y : convexTail x) ↦ (y.val) n) (fun _ ↦ xlim) atTop := by
+  -- GPT 5.2 proof:
+  -- Unfolding `TendstoUniformly` gives an entourage `u` and we must show that eventually,
+  -- `(xlim, y n) ∈ u` for all `y : convexTail x`.
+  intro u hu
+  rcases Metric.mem_uniformity_dist.1 hu with ⟨ε, εpos, hεu⟩
+  have hxε : ∀ᶠ n in atTop, dist (x n) xlim < ε := by
+    have hx' : ∀ᶠ n in atTop, x n ∈ Metric.ball xlim ε :=
+      hx (Metric.ball_mem_nhds _ εpos)
+    simpa [Metric.mem_ball] using hx'
+  rcases Filter.eventually_atTop.1 hxε with ⟨N, hN⟩
+  refine Filter.eventually_atTop.2 ⟨N, ?_⟩
+  intro n hn y
+  apply hεu
+  -- Reduce to a ball estimate, then use convexity of balls.
+  have htail : Set.range (fun m ↦ x (n + m)) ⊆ Metric.ball xlim ε := by
+    rintro _ ⟨m, rfl⟩
+    have : dist (x (n + m)) xlim < ε :=
+      hN (n + m) (le_trans hn (Nat.le_add_right n m))
+    simpa [Metric.mem_ball] using this
+  have hconv : convexHull ℝ (Set.range (fun m ↦ x (n + m))) ⊆ Metric.ball xlim ε := by
+    refine convexHull_min htail (convex_ball xlim ε)
+  have hy : y.1 n ∈ convexHull ℝ (Set.range (fun m ↦ x (n + m))) := y.2 n
+  have hyball : y.1 n ∈ Metric.ball xlim ε := hconv hy
+  have : dist xlim (y.1 n) < ε := by
+    have : dist (y.1 n) xlim < ε := by
+      simpa [Metric.mem_ball] using hyball
+    simpa [dist_comm] using this
+  simpa using this
+
+omit [CompleteSpace E] in
+lemma Tendsto_convexTail {x : ℕ → E} {xlim : E} (hx : Tendsto x atTop (𝓝 xlim)) :
+  ∀ y ∈ convexTail x, Tendsto y atTop (𝓝 xlim) := by
+  intro y hy
+  exact TendstoUniformly.tendsto_at (TendstoUniformly_convexTail hx) ⟨y, hy⟩
+
+-- 12.5
+lemma komlos_uniform_convergence
+    {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M)
+    (cw : ℕ → ℕ → ℕ →₀ ℝ) (lim : ℕ → E)
+    (hcw: ∀ k : ℕ, Tendsto (komlosFormula x cw k k) atTop (𝓝 (lim k))) :
+    ∀ i, TendstoUniformly (fun k ↦ komlosFormula x cw k i) lim atTop
+    -- maybe too strong, the blueprint statement limits to k ≥ i
+     := by
+    intro i
+    sorry
+
+-- 12.6
+lemma komlos_convex_weights_consolidated
+    {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
+    ∃ (η : ℕ → ℕ →₀ ℝ), (∀ n, ∀ m < n, η n m = 0) ∧ ∀ i : ℕ,
+    ∃ glim : E, Tendsto (fun n ↦ (η n).sum (fun m ηm ↦ ηm • x i m)) atTop (𝓝 glim) := by sorry
+
+-- 12.7
+lemma komlos_convergence_L2
+    (f : ℕ → Ω → E) {P : Measure Ω} :
+    let f' : ℕ → ℕ → Ω → E := fun i n ↦ Set.indicator {ω : Ω | ‖f n ω‖ ≤ i} (f n);
+    ∃ cw : ℕ → ℕ →₀ ℝ, ∀ i : ℕ, ∃ lim : Ω → E,
+    Tendsto (fun n ↦ eLpNorm (fun ω ↦ ((cw n).sum (fun i wi ↦ wi • f' i n)) ω - lim ω) 2 P)
+      atTop (𝓝 0) := by sorry
+
 theorem komlos_L1 [MeasurableSpace E] [BorelSpace E] {f : ℕ → Ω → E} {P : Measure Ω}
     (hf : UniformIntegrable f 1 P) :
     ∃ (g : ℕ → Ω → E) (glim : Ω → E), (∀ n, g n ∈ convexHull ℝ (Set.range fun m ↦ f (n + m))) ∧

From af1b500e0b3921b50e73f5217b2bb31223671ebd Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Fri, 24 Apr 2026 12:24:18 +0100
Subject: [PATCH 21/37] refactor: use StdSimplex for representing convex
 weights

Co-authored-by: Copilot <copilot@github.com>
---
 .../StochasticIntegral/ConvexWeights.lean     | 230 +++++++++---------
 BrownianMotion/StochasticIntegral/Komlos.lean | 194 ++++++---------
 2 files changed, 196 insertions(+), 228 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
index af82f74a..7fb52d01 100644
--- a/BrownianMotion/StochasticIntegral/ConvexWeights.lean
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -1,6 +1,7 @@
 module
 
 public import Mathlib.Analysis.InnerProductSpace.Defs
+public import Mathlib.LinearAlgebra.ConvexSpace
 
 /-
 # Lemmas on Convex Weights
@@ -29,139 +30,138 @@ lemma convex_weights_of_mem_convexHull_indexed {s : ι → E} {x : E}
     · simp [Finsupp.smul_sum, Finsupp.sum_add_index', Finsupp.sum_smul_index, smul_smul, add_smul];
   · exact hx
 
+lemma stdSimplex_of_mem_convexHull_indexed {s : ι → E} {x : E}
+  (hx : x ∈ convexHull R (Set.range s)) :
+    ∃ (w : StdSimplex R ι), x = w.weights.sum (fun i wi ↦ wi • s i) := by
+  obtain ⟨w, hw_nonneg, hw_sum, hw_eq⟩ := convex_weights_of_mem_convexHull_indexed hx
+  refine ⟨⟨w, Finsupp.le_def.mpr fun i => by simpa using hw_nonneg i, hw_sum⟩, hw_eq.symm⟩
+
 noncomputable section
 
 /-- Given convex weights `a : ℕ →₀ ℝ` and a family of convex weights `b : ℕ → ℕ →₀ ℝ`,
 `convexWeightsMul a b` is the convex combination of the `b k`, weighted by `a`. That is,
 `(convexWeightsMul a b) m = ∑ k ∈ a.support, a k * b k m`. -/
-def convexWeightsMul (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) : ℕ →₀ ℝ :=
-  Finsupp.onFinset (a.support.biUnion (fun k ↦ (b k).support))
-    (fun m ↦ ∑ k ∈ a.support, a k * (b k m))
-    (fun m hm ↦ by
-      simp only [Finset.mem_biUnion, Finsupp.mem_support_iff]
-      by_contra h
-      push Not at h
-      apply hm
-      apply Finset.sum_eq_zero
-      intro k hk
-      rcases eq_or_ne (a k) 0 with ha | ha
-      · simp [ha]
-      · simp [h k (Finsupp.mem_support_iff.mp hk)])
-
-lemma convexWeightsMul_eq (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) :
-  convexWeightsMul a b = fun m ↦ ∑ k ∈ a.support, a k * (b k m) := rfl
-
-variable {a : ℕ →₀ ℝ} {b : ℕ → ℕ →₀ ℝ}
-
-lemma convexWeightsMul_nonneg (ha : ∀ n, a n ≥ 0) (hb : ∀ n m, b n m ≥ 0) (m : ℕ) :
-  convexWeightsMul a b m ≥ 0 := by
-    exact Finset.sum_nonneg fun _ _ => mul_nonneg ( ha _ ) ( hb _ _ )
-
-lemma convexWeightsMul_sum_one (ha_nonneg : ∀ n, a n ≥ 0) (hb_nonneg : ∀ n m, b n m ≥ 0)
-  (ha_sum_one : a.sum (fun _ ai ↦ ai) = 1) (hb_sum_one : ∀ n, (b n).sum (fun _ bi ↦ bi) = 1) :
-  (convexWeightsMul a b).sum (fun _ mi ↦ mi) = 1 := by
-    convert ha_sum_one using 1
-    convert Finset.sum_comm using 1
-    refine Finset.sum_congr rfl fun i hi => ?_;
-    rw [← Finset.mul_sum _ _ _,
-      show ( ∑ x ∈ ( convexWeightsMul a b ).support, ( b i ) x ) = 1 from ?_ ];
-    · norm_num;
-    · rw [← hb_sum_one i, Finsupp.sum_of_support_subset];
-      · intro j hj
-        simp_all only [ge_iff_le, Finsupp.mem_support_iff, ne_eq, convexWeightsMul,
-        Finsupp.onFinset_apply]
-        exact ne_of_gt (lt_of_lt_of_le (mul_pos (lt_of_le_of_ne (ha_nonneg i ) (Ne.symm hi ) )
-        (lt_of_le_of_ne (hb_nonneg i j ) (Ne.symm hj ) ) ) (Finset.single_le_sum
-        (fun k _ => mul_nonneg (ha_nonneg k ) (hb_nonneg k j )) (by aesop)))
-      · aesop
+def convexWeightsMul (a : StdSimplex ℝ ℕ) (b : ℕ → StdSimplex ℝ ℕ) : StdSimplex ℝ ℕ :=
+  (a.map b).join
+
+variable (a : StdSimplex ℝ ℕ) (b : ℕ → StdSimplex ℝ ℕ)
+
+lemma convexWeightsMul_eq :
+  (convexWeightsMul a b).toFun = (fun m ↦ ∑ k ∈ a.support, a.weights k * (b k).weights m)
+  := by
+  ext m
+  rw [convexWeightsMul, StdSimplex.join, StdSimplex.map]
+  change ((Finsupp.mapDomain b a.weights).sum (fun d r => r • d.weights)) m = _
+  simp only [Finsupp.sum_apply, Finsupp.coe_smul, Pi.smul_apply, smul_eq_mul]
+  rw [Finsupp.sum_mapDomain_index (fun _ => by simp) (fun _ _ _ => by simp [add_mul])]
+  simp [Finsupp.sum]
+
+lemma convexWeightsMul_support_subset :
+    (convexWeightsMul a b).support ⊆ a.support.biUnion (fun k ↦ (b k).support) :=
+  by
+  classical
+  intro m hm
+  have hm_ne : (convexWeightsMul a b).weights m ≠ 0 := by
+    simpa [Finsupp.mem_support_iff] using hm
+  have hm_eq : (convexWeightsMul a b).weights m
+      = ∑ k ∈ a.support, a.weights k * (b k).weights m := by
+    simpa using congrArg (fun f => f m) (convexWeightsMul_eq a b)
+  have hm_ne' : (∑ k ∈ a.support, a.weights k * (b k).weights m) ≠ 0 := by
+    simpa [hm_eq] using hm_ne
+  rcases Finset.exists_ne_zero_of_sum_ne_zero hm_ne' with ⟨k, hk, hkne⟩
+  have hbkm_ne : (b k).weights m ≠ 0 := by
+    intro hb0
+    apply hkne
+    simp [hb0]
+  refine Finset.mem_biUnion.2 ?_
+  refine ⟨k, hk, ?_⟩
+  simpa [Finsupp.mem_support_iff] using hbkm_ne
+
+lemma support_subset_convexWeightsMul_support {a : StdSimplex ℝ ℕ} (b : ℕ → StdSimplex ℝ ℕ)
+    {i : ℕ} (hi : i ∈ a.support) :
+    (b i).support ⊆ (convexWeightsMul a b).support := by
+  intro m hm
+  have hbim_ne : (b i).weights m ≠ 0 := by
+    simpa [Finsupp.mem_support_iff] using hm
+  have hai_ne : a.weights i ≠ 0 := by
+    simpa [Finsupp.mem_support_iff] using hi
+  have hpos_term : 0 < a.weights i * (b i).weights m := by
+    have hai_pos : 0 < a.weights i := (a.nonneg i).lt_of_ne' hai_ne
+    have hbim_pos : 0 < (b i).weights m := ((b i).nonneg m).lt_of_ne' hbim_ne
+    exact mul_pos hai_pos hbim_pos
+  have hnonneg : ∀ k ∈ a.support, 0 ≤ a.weights k * (b k).weights m := by
+    intro k hk
+    exact mul_nonneg (a.nonneg k) ((b k).nonneg m)
+  have hle : a.weights i * (b i).weights m ≤ ∑ k ∈ a.support, a.weights k * (b k).weights m := by
+    exact Finset.single_le_sum hnonneg hi
+  have hsum_pos : 0 < ∑ k ∈ a.support, a.weights k * (b k).weights m :=
+    lt_of_lt_of_le hpos_term hle
+  have hsum_ne : (∑ k ∈ a.support, a.weights k * (b k).weights m) ≠ 0 := ne_of_gt hsum_pos
+  have hm_eq : (convexWeightsMul a b).weights m
+      = ∑ k ∈ a.support, a.weights k * (b k).weights m := by
+    simpa using congrArg (fun f => f m) (convexWeightsMul_eq a b)
+  have : (convexWeightsMul a b).weights m ≠ 0 := by
+    simpa [hm_eq] using hsum_ne
+  simpa [Finsupp.mem_support_iff] using this
+
+lemma convexWeightsMul_sum_smul [Module ℝ E] (f : ℕ → E) :
+    a.sum (fun i wi ↦ wi • (b i).sum (fun m bm ↦ bm • f m))
+    = (convexWeightsMul a b).sum (fun m cwm ↦ cwm • f m) := by
+  simp only [convexWeightsMul, StdSimplex.join, StdSimplex.map]
+  rw [Finsupp.sum_sum_index (fun _ => by simp) (fun _ _ _ => by simp [add_smul])]
+  rw [Finsupp.sum_mapDomain_index (fun _ => by simp)
+    (fun d r₁ r₂ => by simp [add_smul, Finsupp.sum_add_index, add_smul])]
+  simp only [Finsupp.sum]
+  refine Finset.sum_congr rfl ?_
+  intro i hi
+  have hai_ne : a.weights i ≠ 0 := by
+    simpa [Finsupp.mem_support_iff] using hi
+  have hsupp : (a.weights i • (b i).weights).support = (b i).weights.support := by
+    simpa using (Finsupp.support_smul_eq (α := ℕ) (M := ℝ) (b := a.weights i) hai_ne
+      (g := (b i).weights))
+  simp [hsupp, Finset.smul_sum, Finsupp.smul_apply, smul_smul]
 
 /-- Given a doubly-indexed family of convex weights `cw : ℕ → ℕ → ℕ →₀ ℝ`,
 `convexWeightsConvolution cw k n` is the iterated convex multiplication obtained by combining
 the weights `cw 0 n, cw 1 n, …, cw k n` via `convexWeightsMul`. -/
-def convexWeightsConvolution (cw : ℕ → ℕ → ℕ →₀ ℝ) : ℕ → ℕ → ℕ →₀ ℝ
+def convexWeightsConvolution (cw : ℕ → ℕ → StdSimplex ℝ ℕ) : ℕ → ℕ → StdSimplex ℝ ℕ
   | 0 => fun n ↦ cw 0 n
-  | k + 1 => fun n ↦ convexWeightsMul (cw (k+1) n) (convexWeightsConvolution cw k)
+  | k + 1 => fun n ↦ convexWeightsMul (cw (k + 1) n) (convexWeightsConvolution cw k)
 
-lemma convexWeightsConvolution_cong {cw1 cw2 : ℕ → ℕ → ℕ →₀ ℝ} {k : ℕ}
-    (h : ∀ i ≤ k, cw1 i = cw2 i) :
+lemma convexWeightsConvolution_cong
+    {cw1 cw2 : ℕ → ℕ → StdSimplex ℝ ℕ} {k : ℕ} (h : ∀ i ≤ k, cw1 i = cw2 i) :
     convexWeightsConvolution cw1 k = convexWeightsConvolution cw2 k := by
   induction k with
-  | zero => simp_all only [convexWeightsConvolution, nonpos_iff_eq_zero, forall_eq]
-  | succ n hn =>
-    have : convexWeightsConvolution cw1 n = convexWeightsConvolution cw2 n :=
-      hn (fun i hi => h i (Nat.le_succ_of_le hi))
-    simp only [convexWeightsConvolution, Std.le_refl, h, this]
-
-lemma convexWeightsConvolution_update (cw : ℕ → ℕ → ℕ →₀ ℝ) {k k' : ℕ} {f : ℕ → ℕ →₀ ℝ}
-    (hk' : k' > k) :
-    convexWeightsConvolution cw k = convexWeightsConvolution (Function.update cw k' f) k := by
-  rw [convexWeightsConvolution_cong]
-  grind
-
-lemma convexWeightsMul_support_subset (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) :
-    (convexWeightsMul a b).support ⊆ a.support.biUnion (fun k ↦ (b k).support) :=
-  Finsupp.support_onFinset_subset
-
-lemma support_subset_convexWeightsMul_support {a : ℕ →₀ ℝ} {b : ℕ → ℕ →₀ ℝ} {i : ℕ}
-    (hi : i ∈ a.support) (ha : ∀ k ∈ a.support, 0 ≤ a k) (hb : ∀ k ∈ a.support, ∀ m, 0 ≤ b k m) :
-    (b i).support ⊆ (convexWeightsMul a b).support := by
-  intro j hj
-  simp only [convexWeightsMul, Finsupp.mem_support_onFinset]
-  apply ne_of_gt
-  apply Finset.sum_pos'
-  · intro k hk
-    exact mul_nonneg (ha k hk) (hb k hk j)
-  · refine ⟨i, hi, mul_pos ?_ ?_⟩
-    · exact lt_of_le_of_ne (ha i hi) (Ne.symm (Finsupp.mem_support_iff.mp hi))
-    · exact lt_of_le_of_ne (hb i hi j) (Ne.symm (Finsupp.mem_support_iff.mp hj))
-
-lemma convexWeightsConvolution_nonneg {cw : ℕ → ℕ → ℕ →₀ ℝ}
-  (h : ∀ k n m, 0 ≤ cw k n m) (k n m : ℕ) :
-  0 ≤ convexWeightsConvolution cw k n m := by
-    unfold convexWeightsConvolution
-    induction k <;> simp only [h]
-    apply_rules [convexWeightsMul_nonneg]
-    rename_i k hk
-    refine Nat.recOn k ?_ ?_ <;> simp only [Nat.zero_eq, ge_iff_le]
-    · exact fun n m ↦ le_of_eq_of_le rfl (h 0 n m)
-    · intro n hn n' m
-      exact convexWeightsMul_nonneg (fun k => h _ _ _ ) (fun k m => hn _ _) _
-
-lemma convexWeightsConvolution_sum_one {cw : ℕ → ℕ → ℕ →₀ ℝ} (h_nonneg : ∀ k n m, 0 ≤ cw k n m)
-  (h_sum_one : ∀ k n, (cw k n).sum (fun _ wi ↦ wi) = 1) (k : ℕ) :
-  ∀ n, (convexWeightsConvolution cw k n).sum (fun _ wi ↦ wi) = 1 := by
-    refine Nat.recOn k ?_ ?_ <;> simp_all only [convexWeightsConvolution, implies_true]
-    intro n hn n_1
-    exact convexWeightsMul_sum_one (fun k => h_nonneg _ _ _)
-      (fun k m => convexWeightsConvolution_nonneg (fun k n m => h_nonneg k n m) _ _ _)
-      (h_sum_one _ _) (fun k => hn k)
+  | zero =>
+    funext n
+    have h0 : cw1 0 = cw2 0 := h 0 (by simp)
+    simp [convexWeightsConvolution, h0]
+  | succ k ih =>
+    have hk : cw1 (k + 1) = cw2 (k + 1) := h (k + 1) (Nat.le_refl _)
+    have h' : ∀ i ≤ k, cw1 i = cw2 i := fun i hi => h i (Nat.le_succ_of_le hi)
+    have ih' :
+        convexWeightsConvolution cw1 k = convexWeightsConvolution cw2 k := ih h'
+    funext n
+    simp [convexWeightsConvolution, hk, ih']
 
 omit [AddCommGroup E] in
 lemma convex_combination_bounded [NormedAddCommGroup E] [InnerProductSpace ℝ E]
-  {x : ℕ → E} {w : ℕ → ℕ →₀ ℝ} (hw : ∀ n, (w n).sum (fun _ wi ↦ wi) = 1)
-  (hw_nonneg : ∀ n m, 0 ≤ (w n) m)
-  (hx : ∃ M : ℝ, ∀ n, ‖x n‖ ≤ M) :
-  ∃ M, ∀ n, ‖(w n).sum (fun i wi ↦ wi • x i)‖ ≤ M := by
+    {x : ℕ → E} {w : ℕ → StdSimplex ℝ ℕ}
+    (hx : ∃ M : ℝ, ∀ n, ‖x n‖ ≤ M) :
+    ∃ M, ∀ n, ‖(w n).sum (fun i wi ↦ wi • x i)‖ ≤ M := by
   obtain ⟨M, hM⟩ := hx
   use M
   intro n
-  have h_sum : ‖(w n).sum (fun i wi => wi • x i)‖ ≤ ∑ i ∈ (w n).support, (w n i) * ‖x i‖ := by
+  have h_sum : ‖(w n).sum (fun i wi => wi • x i)‖ ≤ ∑ i ∈ (w n).support, ((w n).weights i) * ‖x i‖
+    := by
     convert norm_sum_le _ _ using 2
-    simp [norm_smul, abs_of_nonneg (hw_nonneg _ _)]
+    simp [norm_smul, abs_of_nonneg ((w _).nonneg _)]
   refine le_trans h_sum (le_trans (Finset.sum_le_sum fun i hi =>
-    mul_le_mul_of_nonneg_left (hM i) (hw_nonneg n i)) ?_)
-  simp_all [← Finset.sum_mul _ _ _, Finsupp.sum]
-
-lemma convexWeightsMul_sum_smul [Module ℝ E]
-    (a : ℕ →₀ ℝ) (b : ℕ → ℕ →₀ ℝ) (f : ℕ → E)
-    (ha : ∀ k ∈ a.support, 0 ≤ a k) (hb : ∀ k ∈ a.support, ∀ m, 0 ≤ b k m) :
-    a.sum (fun i wi ↦ wi • (b i).sum (fun m bm ↦ bm • f m))
-      = (convexWeightsMul a b).sum (fun m cwm ↦ cwm • f m) := by
-  simp only [Finsupp.sum, Finset.smul_sum, convexWeightsMul_eq, Finset.sum_smul]
-  rw [Finset.sum_comm, Finset.sum_congr rfl]
-  intro k hk
-  have inclusion: (b k).support ⊆ (convexWeightsMul a b).support :=
-    support_subset_convexWeightsMul_support hk ha hb
-  rw [← Finset.sum_subset inclusion]
-  · simp only [mul_smul]
-  · aesop
+    mul_le_mul_of_nonneg_left (hM i) ((w n).nonneg i)) ?_)
+  simp_all only [Finsupp.sum, ← Finset.sum_mul _ _ _]
+  have bound : (∑ i ∈ (w n).support, (w n).weights i) ≤ 1 := by
+    have : (∑ i ∈ (w n).support, (w n).weights i) = (1 : ℝ) := by
+      simpa [Finsupp.sum] using (w n).total
+    exact this.le
+  refine mul_le_of_le_one_left ?_ bound
+  exact le_trans (norm_nonneg (x 0)) (hM 0)
diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 14ca70d0..8d0792b9 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -123,38 +123,46 @@ lemma komlos_norm [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
 noncomputable section
 variable [NormedAddCommGroup E] [InnerProductSpace ℝ E]
 
-private def gtilde (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E) (k : ℕ) (n : ℕ) : E :=
+private def gtilde (cw : ℕ → ℕ → StdSimplex ℝ ℕ) (x : ℕ → ℕ → E) (k : ℕ) (n : ℕ) : E :=
   (convexWeightsConvolution cw k n).sum (fun m cwm ↦ cwm • (x (k+1) m))
 
-private lemma gtilde_update (cw : ℕ → ℕ → ℕ →₀ ℝ) (x : ℕ → ℕ → E) {k k' : ℕ} {f : ℕ → ℕ →₀ ℝ}
-    (hk' : k' > k) :
+private lemma gtilde_update (cw : ℕ → ℕ → StdSimplex ℝ ℕ) (x : ℕ → ℕ → E) {k k' : ℕ}
+    {f : ℕ → StdSimplex ℝ ℕ} (hk' : k' > k) :
     gtilde cw x k = gtilde (Function.update cw k' f) x k := by
   funext n
   simp only [gtilde]
-  rw [← convexWeightsConvolution_update cw hk']
+  rw [convexWeightsConvolution_cong]
+  grind
 
 /-- `komlosFormula x cw k n` is the convex combination of the stage-`k` vectors `x k m`,
-weighted by `convexWeightsConvolution cw k n`. It is the sequence whose convergence is
+weighted by `convexWeightsConvolutionSimplex cw k n`. It is the sequence whose convergence is
 established at each stage of the Komlós construction. -/
-def komlosFormula (x : ℕ → ℕ → E) (cw : ℕ → ℕ → ℕ →₀ ℝ) (k i n : ℕ) : E :=
+def komlosFormula (x : ℕ → ℕ → E) (cw : ℕ → ℕ → StdSimplex ℝ ℕ) (k i n : ℕ) : E :=
   (convexWeightsConvolution cw k n).sum (fun m cwm ↦ cwm • x i m)
 
-lemma komlosFormula_cong (x : ℕ → ℕ → E) {cw1 : ℕ → ℕ → ℕ →₀ ℝ} {cw2 : ℕ → ℕ → ℕ →₀ ℝ} {k : ℕ}
-  (h : ∀ k' ≤ k, cw1 k' = cw2 k') :
+lemma komlosFormula_cong (x : ℕ → ℕ → E) {cw1 : ℕ → ℕ → StdSimplex ℝ ℕ}
+  {cw2 : ℕ → ℕ → StdSimplex ℝ ℕ} {k : ℕ} (h : ∀ k' ≤ k, cw1 k' = cw2 k') :
   komlosFormula x cw1 k = komlosFormula x cw2 k := by
   unfold komlosFormula; rw [convexWeightsConvolution_cong]
   exact h
 
-lemma convex_weights_of_mem_convexHull_reindexed {x g : ℕ → E}
-    (h_convex : ∀ n, g n ∈ convexHull ℝ (Set.range fun m ↦ x (n + m))) :
-    ∀ n, ∃ w : ℕ →₀ ℝ, (∀ i, 0 ≤ w i) ∧ (∀ m < n, w m = 0)
-      ∧ w.sum (fun _ wi ↦ wi) = 1
-      ∧ w.sum (fun i wi ↦ wi • x i) = g n := by
+def convexTail (x : ℕ → E) : Set (ℕ → E) :=
+  { y | ∀ n, y n ∈ convexHull ℝ (Set.range (fun m ↦ x (n + m))) }
+
+lemma convex_weights_of_mem_convexHull_reindexed {x g : ℕ → E} (hg : g ∈ convexTail x) :
+  ∀ n, ∃ w : StdSimplex ℝ ℕ, g n = w.sum (fun i wi ↦ wi • x i) ∧ ∀ m < n, w.weights m = 0 := by
   intro n
-  obtain ⟨w, hw_nonneg, hw_sum, hw_combo⟩ := convex_weights_of_mem_convexHull_indexed (h_convex n)
-  let w' := Finsupp.embDomain ⟨fun i ↦ n + i, add_right_injective n⟩ w
-  have nonneg (i : ℕ) : 0 ≤ w' i := by grind
-  have zero_lt (m : ℕ) (hm : m < n) : w' m = 0 := by
+  obtain ⟨w₀, hw₀⟩ := stdSimplex_of_mem_convexHull_indexed (hg n)
+  let weights := Finsupp.embDomain ⟨fun i ↦ n + i, add_right_injective n⟩ w₀.weights
+  have nonneg (i : ℕ) : 0 ≤ weights i := by
+    unfold weights
+    simp only [Finsupp.embDomain_apply, Function.Embedding.coeFn_mk]
+    split_ifs
+    · exact (w₀.nonneg _)
+    · simp
+  let w : StdSimplex ℝ ℕ := ⟨weights, nonneg, by grind [Finsupp.sum_embDomain]⟩
+  use w
+  have zero_lt (m : ℕ) (hm : m < n) : w.weights m = 0 := by
     rw [Finsupp.embDomain_apply]
     split_ifs with h
     · exfalso
@@ -164,126 +172,90 @@ lemma convex_weights_of_mem_convexHull_reindexed {x g : ℕ → E}
         exact Nat.le_add_right n i
       exact (Nat.not_le_of_lt hm hnm).elim
     · rfl
-  have sum_one : w'.sum (fun _ wi ↦ wi) = 1 := by grind [Finsupp.sum_embDomain]
-  have sum_eq : w'.sum (fun i wi ↦ wi • x i) = g n := by
-    rw [Finsupp.sum_embDomain]
-    simp [hw_combo]
-  exact ⟨w', nonneg, zero_lt, sum_one, sum_eq⟩
+  refine ⟨?_, zero_lt⟩
+  unfold w
+  rw [Finsupp.sum_embDomain]
+  simpa
 
 variable [CompleteSpace E]
 
 lemma komlos_base {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
-  ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ),
-    (∃ glim : E, Tendsto (komlosFormula x cw 0 0) atTop (𝓝 glim))
-    ∧ (∀ k n m, 0 ≤ cw k n m) ∧ (∀ k n, (cw k n).sum (fun _ wi ↦ wi) = 1) := by
-    obtain ⟨g, h_convex, h_lim⟩ := komlos_norm (hx 0)
-    let cw (n : ℕ) := Classical.choose (convex_weights_of_mem_convexHull_reindexed h_convex n)
-    use (fun k ↦ cw)
-    refine ⟨?_, ?_, ?_⟩
-    · have hg (n : ℕ) : (cw n).sum (fun m cwm ↦ cwm • x 0 m) = g n := by
-        exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed h_convex n)).2.2.2
-      unfold komlosFormula
-      simp only [convexWeightsConvolution, hg, h_lim]
-    · intro k n
-      exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed h_convex n)).1
-    · intro k n
-      exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed h_convex n)).2.2.1
+    ∃ (cw : ℕ → ℕ → StdSimplex ℝ ℕ), ∃ glim : E,
+    Tendsto (komlosFormula x cw 0 0) atTop (𝓝 glim) := by
+  obtain ⟨g, h_convex, lim, hlim⟩ := komlos_norm (hx 0)
+  let cw (n : ℕ) := Classical.choose (convex_weights_of_mem_convexHull_reindexed h_convex n)
+  use (fun k ↦ cw)
+  have hg (n : ℕ) : g n = (cw n).weights.sum (fun m cwm ↦ cwm • x 0 m) := by
+    exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed h_convex n)).1
+  unfold komlosFormula
+  use lim
+  apply Tendsto.congr hg
+  exact hlim
 
 lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ)
-  (cw : ℕ → ℕ → ℕ →₀ ℝ) (cw_nonneg : ∀ k n m, 0 ≤ cw k n m)
-  (cw_sum_one : ∀ k n, (cw k n).sum (fun _ wi ↦ wi) = 1) :
-  ∃ (cw_new : ℕ → ℕ → ℕ →₀ ℝ),
+  (cw : ℕ → ℕ → StdSimplex ℝ ℕ) :
+  ∃ (cw_new : ℕ → ℕ → StdSimplex ℝ ℕ),
     (∃ glim : E, Tendsto (komlosFormula x cw_new (k+1) (k+1)) atTop (𝓝 glim))
-    ∧ (∀ i ≤ k, cw_new i = cw i)
-    ∧ (∀ k n m, 0 ≤ cw_new k n m)
-    ∧ (∀ k n, (cw_new k n).sum (fun _ wi ↦ wi) = 1) := by
-  have gtilde_bound : ∃ M, ∀ n, ‖gtilde cw x k n‖ ≤ M := convex_combination_bounded
-      (convexWeightsConvolution_sum_one cw_nonneg cw_sum_one k)
-      (convexWeightsConvolution_nonneg cw_nonneg k) (hx (k+1))
+    ∧ (∀ i ≤ k, cw_new i = cw i) := by
+  have gtilde_bound : ∃ M, ∀ n, ‖gtilde cw x k n‖ ≤ M :=
+    convex_combination_bounded (hx (k+1))
   obtain ⟨g_step, gstep_conv, gstep_lim⟩ := komlos_norm (gtilde_bound)
-  have cw_step_exists : ∃ w : ℕ → ℕ →₀ ℝ,
-    (∀ n m, 0 ≤ w n m) ∧ (∀ n, ∀ m < n, w n m = 0)
-    ∧ (∀ n, (w n).sum (fun _ wi ↦ wi) = 1)
-    ∧ ∀ n, (w n).sum (fun i wi ↦ wi • gtilde cw x k i) = g_step n := by
+  have cw_step_exists : ∃ w : ℕ → StdSimplex ℝ ℕ,
+    (∀ n, ∀ m < n, (w n).weights m = 0)
+    ∧ ∀ n, g_step n = (w n).sum (fun i wi ↦ wi • gtilde cw x k i) := by
     refine ⟨fun n ↦ Classical.choose (convex_weights_of_mem_convexHull_reindexed gstep_conv n), ?_⟩
-    refine ⟨?_, ?_, ?_, ?_⟩
-    · intro n m
-      exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed gstep_conv n)).1 m
-    · intro n m hm
-      exact (Classical.choose_spec
-        (convex_weights_of_mem_convexHull_reindexed gstep_conv n)).2.1 m hm
-    · intro n
-      exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed gstep_conv n)).2.2.1
-    · intro n
-      exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed gstep_conv n)).2.2.2
-  obtain ⟨cw_step, ⟨hnonneg, hzero, hsum, hcombo⟩⟩ := cw_step_exists
+    exact And.intro
+      (fun n ↦ (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed gstep_conv n)).2)
+      (fun n ↦ (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed gstep_conv n)).1)
+  obtain ⟨cw_step, ⟨hzero, hcombo⟩⟩ := cw_step_exists
   let cw_new := Function.update cw (k+1) cw_step
-  have g_new_expression (n : ℕ) :
-    g_step n = (convexWeightsConvolution cw_new (k + 1) n).sum (fun m cwm ↦ cwm • x (k+1) m) := by
+  have g_new_expression (n : ℕ) : g_step n =
+    (convexWeightsConvolution cw_new (k + 1) n).sum (fun m cwm ↦ cwm • x (k+1) m) := by
     have aux : (convexWeightsConvolution cw_new (k + 1) n)
       = (convexWeightsMul (cw_step n) (convexWeightsConvolution cw k)) := by
       unfold cw_new
       rw [convexWeightsConvolution, Function.update_self,
-          convexWeightsConvolution_update cw (show k+1 > k by grind)]
-    rw [← hcombo n, aux]
-    exact convexWeightsMul_sum_smul (cw_step n) (convexWeightsConvolution cw k) (x (k + 1))
-      (fun _ hk => hnonneg _ _) (fun i _ m => convexWeightsConvolution_nonneg cw_nonneg k i m)
-  have old_indices_untouched: ∀ i ≤ k, cw_new i = cw i := by grind
-  have sum_one (k' n : ℕ) : ((cw_new k' n).sum fun x wi ↦ wi) = 1 := by
-    unfold cw_new
-    by_cases hk': k+1 = k'
-    · simp_rw [hk']
-      simp only [Function.update_self]
-      exact (hsum n)
-    · rw [← cw_sum_one k' n, Function.update_of_ne]
+          convexWeightsConvolution_cong]
       grind
+    rw [hcombo n, aux, ← convexWeightsMul_sum_smul]
+    unfold gtilde; rfl
+  have old_indices_untouched: ∀ i ≤ k, cw_new i = cw i := by grind
   use cw_new
-  refine ⟨?_, old_indices_untouched, ?_, sum_one⟩
-  · obtain ⟨glim, hglim⟩ := gstep_lim
-    use glim
-    exact Tendsto.congr g_new_expression hglim
-  · unfold cw_new
-    intro k' n m
-    rw [Function.update]
-    split_ifs
-    · simp only [eq_rec_constant]
-      exact hnonneg _ _
-    · exact cw_nonneg k' n m
+  refine ⟨?_, old_indices_untouched⟩
+  obtain ⟨glim, hglim⟩ := gstep_lim
+  use glim
+  exact Tendsto.congr g_new_expression hglim
 
 private def komlos_stage {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (stage : ℕ) :
-  { w : ℕ → ℕ → ℕ →₀ ℝ // (∀ k n m, 0 ≤ w k n m) ∧ ∀ k n, (w k n).sum (fun _ wi ↦ wi) = 1} :=
+  ℕ → ℕ → StdSimplex ℝ ℕ :=
   match stage with
   | 0 => by
     use Classical.choose (komlos_base hx)
-    exact Classical.choose_spec (komlos_base hx) |>.2
   | stage+1 => by
-      let ⟨previous, hprevious⟩ := komlos_stage hx stage
-      let step := komlos_step hx stage previous hprevious.1 hprevious.2
+      let previous := komlos_stage hx stage
+      let step := komlos_step hx stage previous
       use Classical.choose step
-      exact Classical.choose_spec step |>.2.2
 
 private lemma komlos_stage_lim {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
   (∃ glim : E, Tendsto (komlosFormula x (komlos_stage hx k) k k) atTop (𝓝 glim)) := by
   induction k with
-  | zero => exact Classical.choose_spec (komlos_base hx) |>.1
+  | zero => exact Classical.choose_spec (komlos_base hx)
   | succ k _ => exact
-      Classical.choose_spec (komlos_step hx k
-        (komlos_stage hx k).val (komlos_stage hx k).prop.1 (komlos_stage hx k).prop.2) |>.1
+      Classical.choose_spec (komlos_step hx k (komlos_stage hx k)) |>.1
 
 private lemma agreement_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
-  ∀ i ≤ k, (komlos_stage hx k).val i = (komlos_stage hx (k+1)).val i := by
+  ∀ i ≤ k, (komlos_stage hx k) i = (komlos_stage hx (k+1)) i := by
   intro i hi
-  let aux := komlos_step hx k (komlos_stage hx k).val (komlos_stage hx k).prop.1
-    (komlos_stage hx k).prop.2
-  let ⟨_, aux2, _⟩ := Classical.choose_spec aux
+  let aux := komlos_step hx k (komlos_stage hx k)
+  let ⟨_, aux2⟩ := Classical.choose_spec aux
   exact Eq.symm (aux2 i hi)
 
 private lemma agreement_necessary_condition {x : ℕ → ℕ → E}
     (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M)
   (i k : ℕ) (hi : i ≤ k) :
-  (komlos_stage hx i).val i = (komlos_stage hx k).val i := by
+  (komlos_stage hx i) i = (komlos_stage hx k) i := by
   let n := k-i
-  suffices (komlos_stage hx i).val i = (komlos_stage hx (i+n)).val i from by
+  suffices (komlos_stage hx i) i = (komlos_stage hx (i+n)) i from by
     unfold n at this
     rw [show i + (k - i) = k by grind] at this
     exact this
@@ -293,21 +265,21 @@ private lemma agreement_necessary_condition {x : ℕ → ℕ → E}
   rw [← add_assoc, hn]
   apply agreement_step hx (i+n) i (by grind)
 
--- TODO: Add convex weight conditions: nonnegativity and summing up to 1
+-- TODO: Add condition cw k n m is 0 for m < n
 lemma komlos_convex_weights
     {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
-    ∃ (cw : ℕ → ℕ → ℕ →₀ ℝ), ∀ k : ℕ,
+    ∃ (cw : ℕ → ℕ → StdSimplex ℝ ℕ), ∀ k : ℕ,
     ∃ glim : E, Tendsto (komlosFormula x cw k k) atTop (𝓝 glim) := by
   have hcwStage2 (k : ℕ) :
-    ∃ glim : E, Tendsto (komlosFormula x (komlos_stage hx k).val k k) atTop (𝓝 glim) := by
+    ∃ glim : E, Tendsto (komlosFormula x (komlos_stage hx k) k k) atTop (𝓝 glim) := by
     simpa using (komlos_stage_lim (x := x) hx k)
-  let cw (k : ℕ) : ℕ → ℕ →₀ ℝ := (komlos_stage hx k).val k
+  let cw (k : ℕ) : ℕ → StdSimplex ℝ ℕ := (komlos_stage hx k) k
   have agreement (k i : ℕ) (hi : i ≤ k) :
-    cw i = (komlos_stage hx k).val i := by
+    cw i = (komlos_stage hx k) i := by
     unfold cw
     apply agreement_necessary_condition hx
     exact hi
-  have transfer (k : ℕ) : komlosFormula x cw k = komlosFormula x (komlos_stage hx k).val k := by
+  have transfer (k : ℕ) : komlosFormula x cw k = komlosFormula x (komlos_stage hx k) k := by
     apply komlosFormula_cong x
     exact agreement k
   use cw
@@ -315,10 +287,6 @@ lemma komlos_convex_weights
   simp_rw [transfer k]
   exact hcwStage2 k
 
-
-def convexTail (x : ℕ → E) : Set (ℕ → E) :=
-  { y | ∀ n, y n ∈ convexHull ℝ (Set.range (fun m ↦ x (n + m))) }
-
 omit [CompleteSpace E] in
 lemma TendstoUniformly_convexTail {x : ℕ → E} {xlim : E} (hx : Tendsto x atTop (𝓝 xlim)) :
   TendstoUniformly (fun (n : ℕ) (y : convexTail x) ↦ (y.val) n) (fun _ ↦ xlim) atTop := by
@@ -360,7 +328,7 @@ lemma Tendsto_convexTail {x : ℕ → E} {xlim : E} (hx : Tendsto x atTop (𝓝
 -- 12.5
 lemma komlos_uniform_convergence
     {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M)
-    (cw : ℕ → ℕ → ℕ →₀ ℝ) (lim : ℕ → E)
+    (cw : ℕ → ℕ → StdSimplex ℝ ℕ) (lim : ℕ → E)
     (hcw: ∀ k : ℕ, Tendsto (komlosFormula x cw k k) atTop (𝓝 (lim k))) :
     ∀ i, TendstoUniformly (fun k ↦ komlosFormula x cw k i) lim atTop
     -- maybe too strong, the blueprint statement limits to k ≥ i
@@ -371,14 +339,14 @@ lemma komlos_uniform_convergence
 -- 12.6
 lemma komlos_convex_weights_consolidated
     {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
-    ∃ (η : ℕ → ℕ →₀ ℝ), (∀ n, ∀ m < n, η n m = 0) ∧ ∀ i : ℕ,
+    ∃ (η : ℕ → StdSimplex ℝ ℕ), (∀ n, ∀ m < n, (η n).weights m = 0) ∧ ∀ i : ℕ,
     ∃ glim : E, Tendsto (fun n ↦ (η n).sum (fun m ηm ↦ ηm • x i m)) atTop (𝓝 glim) := by sorry
 
 -- 12.7
 lemma komlos_convergence_L2
     (f : ℕ → Ω → E) {P : Measure Ω} :
     let f' : ℕ → ℕ → Ω → E := fun i n ↦ Set.indicator {ω : Ω | ‖f n ω‖ ≤ i} (f n);
-    ∃ cw : ℕ → ℕ →₀ ℝ, ∀ i : ℕ, ∃ lim : Ω → E,
+    ∃ cw : ℕ → StdSimplex ℝ ℕ, ∀ i : ℕ, ∃ lim : Ω → E,
     Tendsto (fun n ↦ eLpNorm (fun ω ↦ ((cw n).sum (fun i wi ↦ wi • f' i n)) ω - lim ω) 2 P)
       atTop (𝓝 0) := by sorry
 

From 4585b0e5db3494f630bb79524f505d75db6884b5 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Fri, 24 Apr 2026 13:00:40 +0100
Subject: [PATCH 22/37] feat(Komlos): prove first weights are zero

---
 BrownianMotion/StochasticIntegral/Komlos.lean | 70 ++++++++++++-------
 1 file changed, 45 insertions(+), 25 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 8d0792b9..585e7a24 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -180,23 +180,26 @@ lemma convex_weights_of_mem_convexHull_reindexed {x g : ℕ → E} (hg : g ∈ c
 variable [CompleteSpace E]
 
 lemma komlos_base {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
-    ∃ (cw : ℕ → ℕ → StdSimplex ℝ ℕ), ∃ glim : E,
-    Tendsto (komlosFormula x cw 0 0) atTop (𝓝 glim) := by
+    ∃ (cw : ℕ → ℕ → StdSimplex ℝ ℕ), (∃ glim : E,
+    Tendsto (komlosFormula x cw 0 0) atTop (𝓝 glim)) ∧ ∀ n, ∀ m < n, (cw 0 n).toFun m = 0 := by
   obtain ⟨g, h_convex, lim, hlim⟩ := komlos_norm (hx 0)
   let cw (n : ℕ) := Classical.choose (convex_weights_of_mem_convexHull_reindexed h_convex n)
   use (fun k ↦ cw)
   have hg (n : ℕ) : g n = (cw n).weights.sum (fun m cwm ↦ cwm • x 0 m) := by
     exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed h_convex n)).1
   unfold komlosFormula
-  use lim
-  apply Tendsto.congr hg
-  exact hlim
+  constructor
+  · use lim
+    apply Tendsto.congr hg
+    exact hlim
+  · intro n
+    exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed h_convex n)).2
 
 lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ)
   (cw : ℕ → ℕ → StdSimplex ℝ ℕ) :
   ∃ (cw_new : ℕ → ℕ → StdSimplex ℝ ℕ),
     (∃ glim : E, Tendsto (komlosFormula x cw_new (k+1) (k+1)) atTop (𝓝 glim))
-    ∧ (∀ i ≤ k, cw_new i = cw i) := by
+    ∧ (∀ i ≤ k, cw_new i = cw i) ∧ (∀ n, ∀ m < n, (cw_new (k+1) n).toFun m = 0) := by
   have gtilde_bound : ∃ M, ∀ n, ‖gtilde cw x k n‖ ≤ M :=
     convex_combination_bounded (hx (k+1))
   obtain ⟨g_step, gstep_conv, gstep_lim⟩ := komlos_norm (gtilde_bound)
@@ -221,41 +224,55 @@ lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n,
     unfold gtilde; rfl
   have old_indices_untouched: ∀ i ≤ k, cw_new i = cw i := by grind
   use cw_new
-  refine ⟨?_, old_indices_untouched⟩
-  obtain ⟨glim, hglim⟩ := gstep_lim
-  use glim
-  exact Tendsto.congr g_new_expression hglim
+  refine ⟨?_, old_indices_untouched, ?_⟩
+  · obtain ⟨glim, hglim⟩ := gstep_lim
+    use glim
+    exact Tendsto.congr g_new_expression hglim
+  · unfold cw_new
+    simp only [Function.update_self]
+    refine hzero
 
 private def komlos_stage {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (stage : ℕ) :
-  ℕ → ℕ → StdSimplex ℝ ℕ :=
+  { w : ℕ → ℕ → StdSimplex ℝ ℕ // ∀ k ≤ stage, ∀ n, ∀ m < n, (w k n).toFun m = 0 } :=
   match stage with
   | 0 => by
     use Classical.choose (komlos_base hx)
+    intro k hk
+    rw [show k=0 by grind]
+    exact (Classical.choose_spec (komlos_base hx)).2
   | stage+1 => by
-      let previous := komlos_stage hx stage
+      let ⟨previous, hprevious⟩ := komlos_stage hx stage
       let step := komlos_step hx stage previous
       use Classical.choose step
+      intro k _
+      let ⟨_, transfer, zero⟩ := Classical.choose_spec step
+      by_cases hk: k=stage+1
+      · rw [hk]
+        exact zero
+      · replace hk : k ≤ stage := by grind
+        rw [transfer k hk]
+        exact hprevious k hk
 
 private lemma komlos_stage_lim {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
   (∃ glim : E, Tendsto (komlosFormula x (komlos_stage hx k) k k) atTop (𝓝 glim)) := by
   induction k with
-  | zero => exact Classical.choose_spec (komlos_base hx)
+  | zero => exact (Classical.choose_spec (komlos_base hx)).1
   | succ k _ => exact
       Classical.choose_spec (komlos_step hx k (komlos_stage hx k)) |>.1
 
 private lemma agreement_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
-  ∀ i ≤ k, (komlos_stage hx k) i = (komlos_stage hx (k+1)) i := by
+  ∀ i ≤ k, (komlos_stage hx k).val i = (komlos_stage hx (k+1)).val i := by
   intro i hi
   let aux := komlos_step hx k (komlos_stage hx k)
-  let ⟨_, aux2⟩ := Classical.choose_spec aux
+  let ⟨_, aux2, _⟩ := Classical.choose_spec aux
   exact Eq.symm (aux2 i hi)
 
 private lemma agreement_necessary_condition {x : ℕ → ℕ → E}
     (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M)
   (i k : ℕ) (hi : i ≤ k) :
-  (komlos_stage hx i) i = (komlos_stage hx k) i := by
+  (komlos_stage hx i).val i = (komlos_stage hx k).val i := by
   let n := k-i
-  suffices (komlos_stage hx i) i = (komlos_stage hx (i+n)) i from by
+  suffices (komlos_stage hx i).val i = (komlos_stage hx (i+n)).val i from by
     unfold n at this
     rw [show i + (k - i) = k by grind] at this
     exact this
@@ -265,17 +282,17 @@ private lemma agreement_necessary_condition {x : ℕ → ℕ → E}
   rw [← add_assoc, hn]
   apply agreement_step hx (i+n) i (by grind)
 
--- TODO: Add condition cw k n m is 0 for m < n
 lemma komlos_convex_weights
     {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
-    ∃ (cw : ℕ → ℕ → StdSimplex ℝ ℕ), ∀ k : ℕ,
-    ∃ glim : E, Tendsto (komlosFormula x cw k k) atTop (𝓝 glim) := by
+    ∃ (cw : ℕ → ℕ → StdSimplex ℝ ℕ),
+    (∀ k : ℕ, ∃ glim : E, Tendsto (komlosFormula x cw k k) atTop (𝓝 glim))
+    ∧ (∀ k n, ∀ m < n, (cw k n).toFun m = 0) := by
   have hcwStage2 (k : ℕ) :
     ∃ glim : E, Tendsto (komlosFormula x (komlos_stage hx k) k k) atTop (𝓝 glim) := by
     simpa using (komlos_stage_lim (x := x) hx k)
-  let cw (k : ℕ) : ℕ → StdSimplex ℝ ℕ := (komlos_stage hx k) k
+  let cw (k : ℕ) : ℕ → StdSimplex ℝ ℕ := (komlos_stage hx k).val k
   have agreement (k i : ℕ) (hi : i ≤ k) :
-    cw i = (komlos_stage hx k) i := by
+    cw i = (komlos_stage hx k).val i := by
     unfold cw
     apply agreement_necessary_condition hx
     exact hi
@@ -283,9 +300,12 @@ lemma komlos_convex_weights
     apply komlosFormula_cong x
     exact agreement k
   use cw
-  intro k
-  simp_rw [transfer k]
-  exact hcwStage2 k
+  constructor
+  · intro k
+    simp_rw [transfer k]
+    exact hcwStage2 k
+  · intro k
+    exact (komlos_stage hx k).prop k (le_refl k)
 
 omit [CompleteSpace E] in
 lemma TendstoUniformly_convexTail {x : ℕ → E} {xlim : E} (hx : Tendsto x atTop (𝓝 xlim)) :

From f37c90fd498b9ab359ab3f9038b1cba967c45d2f Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Fri, 24 Apr 2026 13:49:24 +0100
Subject: [PATCH 23/37] refactor(Komlos): move global gtilde inside proof

---
 BrownianMotion/StochasticIntegral/Komlos.lean | 17 +++--------------
 1 file changed, 3 insertions(+), 14 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 585e7a24..4432dc65 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -123,17 +123,6 @@ lemma komlos_norm [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
 noncomputable section
 variable [NormedAddCommGroup E] [InnerProductSpace ℝ E]
 
-private def gtilde (cw : ℕ → ℕ → StdSimplex ℝ ℕ) (x : ℕ → ℕ → E) (k : ℕ) (n : ℕ) : E :=
-  (convexWeightsConvolution cw k n).sum (fun m cwm ↦ cwm • (x (k+1) m))
-
-private lemma gtilde_update (cw : ℕ → ℕ → StdSimplex ℝ ℕ) (x : ℕ → ℕ → E) {k k' : ℕ}
-    {f : ℕ → StdSimplex ℝ ℕ} (hk' : k' > k) :
-    gtilde cw x k = gtilde (Function.update cw k' f) x k := by
-  funext n
-  simp only [gtilde]
-  rw [convexWeightsConvolution_cong]
-  grind
-
 /-- `komlosFormula x cw k n` is the convex combination of the stage-`k` vectors `x k m`,
 weighted by `convexWeightsConvolutionSimplex cw k n`. It is the sequence whose convergence is
 established at each stage of the Komlós construction. -/
@@ -200,12 +189,13 @@ lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n,
   ∃ (cw_new : ℕ → ℕ → StdSimplex ℝ ℕ),
     (∃ glim : E, Tendsto (komlosFormula x cw_new (k+1) (k+1)) atTop (𝓝 glim))
     ∧ (∀ i ≤ k, cw_new i = cw i) ∧ (∀ n, ∀ m < n, (cw_new (k+1) n).toFun m = 0) := by
-  have gtilde_bound : ∃ M, ∀ n, ‖gtilde cw x k n‖ ≤ M :=
+  let gtilde' := fun n ↦ (convexWeightsConvolution cw k n).sum (fun m cwm ↦ cwm • (x (k+1) m))
+  have gtilde_bound : ∃ M, ∀ n, ‖gtilde' n‖ ≤ M :=
     convex_combination_bounded (hx (k+1))
   obtain ⟨g_step, gstep_conv, gstep_lim⟩ := komlos_norm (gtilde_bound)
   have cw_step_exists : ∃ w : ℕ → StdSimplex ℝ ℕ,
     (∀ n, ∀ m < n, (w n).weights m = 0)
-    ∧ ∀ n, g_step n = (w n).sum (fun i wi ↦ wi • gtilde cw x k i) := by
+    ∧ ∀ n, g_step n = (w n).sum (fun i wi ↦ wi • gtilde' i) := by
     refine ⟨fun n ↦ Classical.choose (convex_weights_of_mem_convexHull_reindexed gstep_conv n), ?_⟩
     exact And.intro
       (fun n ↦ (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed gstep_conv n)).2)
@@ -221,7 +211,6 @@ lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n,
           convexWeightsConvolution_cong]
       grind
     rw [hcombo n, aux, ← convexWeightsMul_sum_smul]
-    unfold gtilde; rfl
   have old_indices_untouched: ∀ i ≤ k, cw_new i = cw i := by grind
   use cw_new
   refine ⟨?_, old_indices_untouched, ?_⟩

From 880f0444e578f95ccb76ea3e2b4124bd72c39f6a Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Fri, 24 Apr 2026 14:11:06 +0100
Subject: [PATCH 24/37] fix(Komlos): add missing declnames in blueprint

---
 BrownianMotion/StochasticIntegral/Komlos.lean |  5 +----
 blueprint/lean_decls                          |  6 +++++-
 blueprint/src/chapters/doob_meyer.tex         | 17 +++++++++--------
 3 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 4432dc65..8d9ac9af 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -334,7 +334,6 @@ lemma Tendsto_convexTail {x : ℕ → E} {xlim : E} (hx : Tendsto x atTop (𝓝
   intro y hy
   exact TendstoUniformly.tendsto_at (TendstoUniformly_convexTail hx) ⟨y, hy⟩
 
--- 12.5
 lemma komlos_uniform_convergence
     {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M)
     (cw : ℕ → ℕ → StdSimplex ℝ ℕ) (lim : ℕ → E)
@@ -345,13 +344,11 @@ lemma komlos_uniform_convergence
     intro i
     sorry
 
--- 12.6
-lemma komlos_convex_weights_consolidated
+lemma komlos_convex_weights_diagonal
     {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
     ∃ (η : ℕ → StdSimplex ℝ ℕ), (∀ n, ∀ m < n, (η n).weights m = 0) ∧ ∀ i : ℕ,
     ∃ glim : E, Tendsto (fun n ↦ (η n).sum (fun m ηm ↦ ηm • x i m)) atTop (𝓝 glim) := by sorry
 
--- 12.7
 lemma komlos_convergence_L2
     (f : ℕ → Ω → E) {P : Measure Ω} :
     let f' : ℕ → ℕ → Ω → E := fun i n ↦ Set.indicator {ω : Ω | ‖f n ω‖ ≤ i} (f n);
diff --git a/blueprint/lean_decls b/blueprint/lean_decls
index 764db2d4..9d804515 100644
--- a/blueprint/lean_decls
+++ b/blueprint/lean_decls
@@ -396,8 +396,12 @@ ProbabilityTheory.SimpleProcess.integral_top
 tendsto_of_no_upcrossings
 komlos_convex
 komlos_norm
+TendstoUniformly_convexTail
 convexWeightsMul
 komlos_convex_weights
+komlos_uniform_convergence
+komlos_convex_weights_diagonal
+komlos_convergence_L2
 komlos_L1
 komlos_ennreal
 MeasureTheory.predictablePart
@@ -433,4 +437,4 @@ ProbabilityTheory.IsSquareIntegrable.tendsto_eLpNorm_two_limitProcess
 ProbabilityTheory.IsLocalMartingale.isLocalSubmartingale_sq_norm
 ProbabilityTheory.quadraticVariation
 MeasureTheory.Filtration.predictable_le_prod
-ProbabilityTheory.L2Predictable
+ProbabilityTheory.L2Predictable
\ No newline at end of file
diff --git a/blueprint/src/chapters/doob_meyer.tex b/blueprint/src/chapters/doob_meyer.tex
index b52765f0..1235dd5e 100644
--- a/blueprint/src/chapters/doob_meyer.tex
+++ b/blueprint/src/chapters/doob_meyer.tex
@@ -69,17 +69,13 @@ \section{Komlòs Lemma}
 \end{proof}
 
 
-\begin{lemma}\label{lem:convex_of_converg_seq_is_converg}
+\begin{lemma}\label{lem:convex_of_converg_seq_is_converg}\lean{TendstoUniformly_convexTail}\leanok
   Let $(x_n)_{n \in \mathbb{N}}$ be a sequence in a real vector space converging to $x$.
   Let $\mathcal{C}((x_n))$ be the set of sequences $(y_n)_{n \in \mathbb{N}}$ such that for all $n$, $y_n \in convex(x_n, x_{n+1}, \ldots)$.
-  Then we have
-  \begin{enumerate}
-    \item uniform convergence over $\mathcal{C}((x_n))$: for all $\varepsilon > 0$, there exists $\bar{n}$ such that for all $n \ge \bar{n}$, for all $(y_n)_{n \in \mathbb{N}} \in \mathcal{C}((x_n))$, $\Vert y_n - x \Vert \le \varepsilon$;
-    \item pointwise convergence: for all $(y_n)_{n \in \mathbb{N}} \in \mathcal{C}((x_n))$, $(y_n)_{n \in \mathbb{N}}$ converges to $x$.
-  \end{enumerate}
+  Then we have uniform convergence over $\mathcal{C}((x_n))$: for all $\varepsilon > 0$, there exists $\bar{n}$ such that for all $n \ge \bar{n}$, for all $(y_n)_{n \in \mathbb{N}} \in \mathcal{C}((x_n))$, $\Vert y_n - x \Vert \le \varepsilon$;
 \end{lemma}
 
-\begin{proof}
+\begin{proof} \leanok
 The second point is a direct consequence of the first one, so we only prove the first one.
 Let $\varepsilon>0$.
 By convergence of $x_n$, there exists $\bar{n}$ such that for all $n \ge \bar{n}$, $\Vert x_n-x \Vert \le \varepsilon$.
@@ -135,9 +131,10 @@ \section{Komlòs Lemma}
 \end{proof}
 
 
-
 \begin{lemma}\label{lem:komlos_convex_weights_tendsto}
+  \lean{komlos_uniform_convergence}
   \uses{lem:komlos_convex_weights}
+  \leanok
 Let $E$ be a Hilbert space and for $i \in \mathbb{N}$, let $(x_n^{(i)})_{n \in \mathbb{N}}$ be a bounded sequence in $E$.
 Let $(\lambda^{k,n}_\cdot)_{k, n \in \mathbb{N}}$ be convex weights satisfying the conclusion of Lemma~\ref{lem:komlos_convex_weights}, and let $(g^i)_{i\in \mathbb{N}}$ be the sequence of limits of the sums.
 
@@ -153,6 +150,8 @@ \section{Komlòs Lemma}
 
 
 \begin{lemma}\label{lem:komlos_convex_weights_diagonal}
+  \lean{komlos_convex_weights_diagonal}
+  \leanok
 Let $E$ be a Hilbert space and for $i \in \mathbb{N}$, let $(x_n^{(i)})_{n \in \mathbb{N}}$ be a bounded sequence in $E$.
 Then there exists a sequence of convex weights $(\eta^n_\cdot)_{n \in \mathbb{N}}$ with $\eta^n_m = 0$ for $m < n$ such that for all $i \in \mathbb{N}$, the sequence $\left(\sum_{m \ge n} \eta^n_m x_m^{(i)}\right)_{n \in \mathbb{N}}$ converges.
 \end{lemma}
@@ -176,6 +175,8 @@ \section{Komlòs Lemma}
 
 
 \begin{lemma}\label{lem:komlos_convex_aux}
+  \lean{komlos_convergence_L2}
+  \leanok
 Let $E$ be a Hilbert space and let $(f_n)_{n \in \mathbb{N}}$ be a sequence in $\Omega \to E$.
 For $i \in \mathbb{N}$, set $f_n^{(i)} = f_n \mathbb{1}_{(\Vert f_n \Vert \le i)}$, such that $f_n^{(i)} \in L^2(E)$.
 Then there exists a sequence of convex weights $\lambda_n^{n}, \ldots, \lambda_{N_n}^{n}$ such that the functions

From da1f34d47517bbcf1018ad1e66664d14720ac5f4 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Fri, 24 Apr 2026 15:58:41 +0100
Subject: [PATCH 25/37] fix(Komlos): fix linter message

---
 BrownianMotion/StochasticIntegral/Komlos.lean | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 8d9ac9af..ce526e07 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -135,6 +135,10 @@ lemma komlosFormula_cong (x : ℕ → ℕ → E) {cw1 : ℕ → ℕ → StdSimpl
   unfold komlosFormula; rw [convexWeightsConvolution_cong]
   exact h
 
+/--
+We define the `convexTail` of a sequence `x` to be the set of sequences `y` with the property that
+every `y n` can be written as a convex combination of elements `x k` with `k ≥ n`.
+-/
 def convexTail (x : ℕ → E) : Set (ℕ → E) :=
   { y | ∀ n, y n ∈ convexHull ℝ (Set.range (fun m ↦ x (n + m))) }
 

From d653b443790e89e35bacdc1496bdcb42c66cab45 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Mon, 27 Apr 2026 11:59:45 +0100
Subject: [PATCH 26/37] refactor(ConvexWeights): lemmas on convex weights

---
 .../StochasticIntegral/ConvexWeights.lean     | 83 +++++++++----------
 BrownianMotion/StochasticIntegral/Komlos.lean |  2 +-
 2 files changed, 40 insertions(+), 45 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
index 7fb52d01..3d9c5df3 100644
--- a/BrownianMotion/StochasticIntegral/ConvexWeights.lean
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -7,44 +7,40 @@ public import Mathlib.LinearAlgebra.ConvexSpace
 # Lemmas on Convex Weights
 -/
 
-@[expose] public section
+@[expose] public noncomputable section
 
-variable {R E : Type*} [Field R] [AddCommGroup E] [Module R E]
-  [LinearOrder R] [IsStrictOrderedRing R] {ι : Type*}
+variable {ι ι' E R : Type*} [AddCommGroup E] [Field R] [LinearOrder R] [IsStrictOrderedRing R]
 
-lemma convex_weights_of_mem_convexHull_indexed {s : ι → E} {x : E}
-  (hx : x ∈ convexHull R (Set.range s)) :
-    ∃ (w : ι →₀ R), (∀ i, 0 ≤ w i) ∧ w.sum (fun _ wi ↦ wi) = 1
-      ∧ w.sum (fun i wi ↦ wi • s i) = x := by
-  rw [ mem_convexHull_iff ] at hx
-  specialize hx ( { y | ∃ w : ι →₀ R, ( ∀ i, 0 ≤ w i ) ∧ w.sum (fun _ wi => wi) = 1
-    ∧ w.sum (fun i wi => wi • s i) = y } ) ?_ ?_ <;> norm_num at *;
-  · rintro _ ⟨ i, rfl ⟩
-    exact ⟨Finsupp.single i 1, fun j => by by_cases h : j = i <;> aesop,
-      by simp, by simp⟩ ;
-  · rintro x ⟨w₁, hw₁, hw₁', rfl⟩ y ⟨w₂, hw₂, hw₂', rfl⟩ a b ha hb hab;
-    refine ⟨a • w₁ + b • w₂, ?_, ?_, ?_⟩
-    · exact fun i => add_nonneg (mul_nonneg ha ( hw₁ i )) (mul_nonneg hb ( hw₂ i ));
-    · simp_all [Finsupp.sum_add_index', Finsupp.sum_smul_index];
-      simp_all [← Finset.mul_sum _ _ _, Finsupp.sum]
-    · simp [Finsupp.smul_sum, Finsupp.sum_add_index', Finsupp.sum_smul_index, smul_smul, add_smul];
-  · exact hx
-
-lemma stdSimplex_of_mem_convexHull_indexed {s : ι → E} {x : E}
-  (hx : x ∈ convexHull R (Set.range s)) :
-    ∃ (w : StdSimplex R ι), x = w.weights.sum (fun i wi ↦ wi • s i) := by
-  obtain ⟨w, hw_nonneg, hw_sum, hw_eq⟩ := convex_weights_of_mem_convexHull_indexed hx
-  refine ⟨⟨w, Finsupp.le_def.mpr fun i => by simpa using hw_nonneg i, hw_sum⟩, hw_eq.symm⟩
-
-noncomputable section
-
-/-- Given convex weights `a : ℕ →₀ ℝ` and a family of convex weights `b : ℕ → ℕ →₀ ℝ`,
-`convexWeightsMul a b` is the convex combination of the `b k`, weighted by `a`. That is,
-`(convexWeightsMul a b) m = ∑ k ∈ a.support, a k * b k m`. -/
-def convexWeightsMul (a : StdSimplex ℝ ℕ) (b : ℕ → StdSimplex ℝ ℕ) : StdSimplex ℝ ℕ :=
+lemma stdSimplex_of_mem_convexHull [Module R E] {s : ι → E} {x : E}
+    (hx : x ∈ convexHull R (Set.range s)) :
+    ∃ (w : StdSimplex R ι), x = w.sum (fun i wi ↦ wi • s i) := by
+  classical
+  rw [mem_convexHull_iff] at hx
+  specialize hx {y | ∃ w : StdSimplex R ι, y = w.sum (fun i wi => wi • s i)} ?_ ?_
+  · rintro _ ⟨i, rfl⟩
+    use StdSimplex.single i
+    simp
+  · rintro x ⟨w₁, hw₁⟩ y ⟨w₂, hw₂⟩ a b ha hb hab
+    use (StdSimplex.duple w₁ w₂ ha hb hab).join
+    simp only [StdSimplex.join, StdSimplex.duple]
+    repeat rw [Finsupp.sum_add_index (by simp) (fun _ _ _ _ ↦ Module.add_smul _ _ _)]
+    have aux (c : R) (w : StdSimplex R ι) : c • (w.sum fun i wi ↦ wi • s i)
+      = ((Finsupp.single w c).sum fun d r ↦ r • d.weights).sum fun i wi ↦ wi • s i := by
+      simp only [zero_smul, Finsupp.sum_single_index]
+      rw [Finsupp.sum_smul_index (by simp only [zero_smul, implies_true])]
+      simp_rw [mul_smul, ← Finsupp.smul_sum]
+    simp [aux, hw₁, hw₂]
+  exact hx
+
+/-- Given convex weights `a : StdSimplex R ι` and a family of convex weights
+`b : ι → StdSimplex R ι'`, `convexWeightsMul a b` is the convex combination of the `b k`, weighted
+by `a`. We show that, `(convexWeightsMul a b) m = ∑ k ∈ a.support, a k * b k m` in
+`convexWeightsMul_eq` and define it here more abstractly using `StdSimplex.map` and
+`StdSimplex.join`. -/
+def convexWeightsMul (a : StdSimplex R ι) (b : ι → StdSimplex R ι') : StdSimplex R ι' :=
   (a.map b).join
 
-variable (a : StdSimplex ℝ ℕ) (b : ℕ → StdSimplex ℝ ℕ)
+variable (a : StdSimplex R ι) (b : ι → StdSimplex R ι')
 
 lemma convexWeightsMul_eq :
   (convexWeightsMul a b).toFun = (fun m ↦ ∑ k ∈ a.support, a.weights k * (b k).weights m)
@@ -56,10 +52,9 @@ lemma convexWeightsMul_eq :
   rw [Finsupp.sum_mapDomain_index (fun _ => by simp) (fun _ _ _ => by simp [add_mul])]
   simp [Finsupp.sum]
 
-lemma convexWeightsMul_support_subset :
+lemma convexWeightsMul_support_subset [DecidableEq ι'] :
     (convexWeightsMul a b).support ⊆ a.support.biUnion (fun k ↦ (b k).support) :=
   by
-  classical
   intro m hm
   have hm_ne : (convexWeightsMul a b).weights m ≠ 0 := by
     simpa [Finsupp.mem_support_iff] using hm
@@ -77,8 +72,8 @@ lemma convexWeightsMul_support_subset :
   refine ⟨k, hk, ?_⟩
   simpa [Finsupp.mem_support_iff] using hbkm_ne
 
-lemma support_subset_convexWeightsMul_support {a : StdSimplex ℝ ℕ} (b : ℕ → StdSimplex ℝ ℕ)
-    {i : ℕ} (hi : i ∈ a.support) :
+lemma support_subset_convexWeightsMul_support {a : StdSimplex R ι} (b : ι → StdSimplex R ι')
+    {i : ι} (hi : i ∈ a.support) :
     (b i).support ⊆ (convexWeightsMul a b).support := by
   intro m hm
   have hbim_ne : (b i).weights m ≠ 0 := by
@@ -104,9 +99,10 @@ lemma support_subset_convexWeightsMul_support {a : StdSimplex ℝ ℕ} (b : ℕ
     simpa [hm_eq] using hsum_ne
   simpa [Finsupp.mem_support_iff] using this
 
-lemma convexWeightsMul_sum_smul [Module ℝ E] (f : ℕ → E) :
+lemma convexWeightsMul_sum_smul (f : ι' → E) [Module R E] :
     a.sum (fun i wi ↦ wi • (b i).sum (fun m bm ↦ bm • f m))
     = (convexWeightsMul a b).sum (fun m cwm ↦ cwm • f m) := by
+  classical
   simp only [convexWeightsMul, StdSimplex.join, StdSimplex.map]
   rw [Finsupp.sum_sum_index (fun _ => by simp) (fun _ _ _ => by simp [add_smul])]
   rw [Finsupp.sum_mapDomain_index (fun _ => by simp)
@@ -117,19 +113,18 @@ lemma convexWeightsMul_sum_smul [Module ℝ E] (f : ℕ → E) :
   have hai_ne : a.weights i ≠ 0 := by
     simpa [Finsupp.mem_support_iff] using hi
   have hsupp : (a.weights i • (b i).weights).support = (b i).weights.support := by
-    simpa using (Finsupp.support_smul_eq (α := ℕ) (M := ℝ) (b := a.weights i) hai_ne
-      (g := (b i).weights))
+    simpa using Finsupp.support_smul_eq hai_ne
   simp [hsupp, Finset.smul_sum, Finsupp.smul_apply, smul_smul]
 
-/-- Given a doubly-indexed family of convex weights `cw : ℕ → ℕ → ℕ →₀ ℝ`,
+/-- Given a doubly-indexed family of convex weights `cw : ℕ → ℕ → StdSimplex R ℕ`,
 `convexWeightsConvolution cw k n` is the iterated convex multiplication obtained by combining
 the weights `cw 0 n, cw 1 n, …, cw k n` via `convexWeightsMul`. -/
-def convexWeightsConvolution (cw : ℕ → ℕ → StdSimplex ℝ ℕ) : ℕ → ℕ → StdSimplex ℝ ℕ
+def convexWeightsConvolution (cw : ℕ → ℕ → StdSimplex R ℕ) : ℕ → ℕ → StdSimplex R ℕ
   | 0 => fun n ↦ cw 0 n
   | k + 1 => fun n ↦ convexWeightsMul (cw (k + 1) n) (convexWeightsConvolution cw k)
 
 lemma convexWeightsConvolution_cong
-    {cw1 cw2 : ℕ → ℕ → StdSimplex ℝ ℕ} {k : ℕ} (h : ∀ i ≤ k, cw1 i = cw2 i) :
+    {cw1 cw2 : ℕ → ℕ → StdSimplex R ℕ} {k : ℕ} (h : ∀ i ≤ k, cw1 i = cw2 i) :
     convexWeightsConvolution cw1 k = convexWeightsConvolution cw2 k := by
   induction k with
   | zero =>
diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index ce526e07..42bb949e 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -145,7 +145,7 @@ def convexTail (x : ℕ → E) : Set (ℕ → E) :=
 lemma convex_weights_of_mem_convexHull_reindexed {x g : ℕ → E} (hg : g ∈ convexTail x) :
   ∀ n, ∃ w : StdSimplex ℝ ℕ, g n = w.sum (fun i wi ↦ wi • x i) ∧ ∀ m < n, w.weights m = 0 := by
   intro n
-  obtain ⟨w₀, hw₀⟩ := stdSimplex_of_mem_convexHull_indexed (hg n)
+  obtain ⟨w₀, hw₀⟩ := stdSimplex_of_mem_convexHull (hg n)
   let weights := Finsupp.embDomain ⟨fun i ↦ n + i, add_right_injective n⟩ w₀.weights
   have nonneg (i : ℕ) : 0 ≤ weights i := by
     unfold weights

From 0910d270dc98a142eaefc1499c81ffaa05ce3511 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Mon, 27 Apr 2026 13:04:47 +0100
Subject: [PATCH 27/37] refactor: further cleanup of proofs

---
 .../StochasticIntegral/ConvexWeights.lean     |  47 ++------
 BrownianMotion/StochasticIntegral/Komlos.lean | 109 +++++++-----------
 2 files changed, 52 insertions(+), 104 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
index 3d9c5df3..d51f481b 100644
--- a/BrownianMotion/StochasticIntegral/ConvexWeights.lean
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -43,8 +43,7 @@ def convexWeightsMul (a : StdSimplex R ι) (b : ι → StdSimplex R ι') : StdSi
 variable (a : StdSimplex R ι) (b : ι → StdSimplex R ι')
 
 lemma convexWeightsMul_eq :
-  (convexWeightsMul a b).toFun = (fun m ↦ ∑ k ∈ a.support, a.weights k * (b k).weights m)
-  := by
+  (convexWeightsMul a b).weights = (fun m ↦ ∑ k ∈ a.support, a.weights k * (b k).weights m) := by
   ext m
   rw [convexWeightsMul, StdSimplex.join, StdSimplex.map]
   change ((Finsupp.mapDomain b a.weights).sum (fun d r => r • d.weights)) m = _
@@ -52,26 +51,6 @@ lemma convexWeightsMul_eq :
   rw [Finsupp.sum_mapDomain_index (fun _ => by simp) (fun _ _ _ => by simp [add_mul])]
   simp [Finsupp.sum]
 
-lemma convexWeightsMul_support_subset [DecidableEq ι'] :
-    (convexWeightsMul a b).support ⊆ a.support.biUnion (fun k ↦ (b k).support) :=
-  by
-  intro m hm
-  have hm_ne : (convexWeightsMul a b).weights m ≠ 0 := by
-    simpa [Finsupp.mem_support_iff] using hm
-  have hm_eq : (convexWeightsMul a b).weights m
-      = ∑ k ∈ a.support, a.weights k * (b k).weights m := by
-    simpa using congrArg (fun f => f m) (convexWeightsMul_eq a b)
-  have hm_ne' : (∑ k ∈ a.support, a.weights k * (b k).weights m) ≠ 0 := by
-    simpa [hm_eq] using hm_ne
-  rcases Finset.exists_ne_zero_of_sum_ne_zero hm_ne' with ⟨k, hk, hkne⟩
-  have hbkm_ne : (b k).weights m ≠ 0 := by
-    intro hb0
-    apply hkne
-    simp [hb0]
-  refine Finset.mem_biUnion.2 ?_
-  refine ⟨k, hk, ?_⟩
-  simpa [Finsupp.mem_support_iff] using hbkm_ne
-
 lemma support_subset_convexWeightsMul_support {a : StdSimplex R ι} (b : ι → StdSimplex R ι')
     {i : ι} (hi : i ∈ a.support) :
     (b i).support ⊆ (convexWeightsMul a b).support := by
@@ -123,26 +102,16 @@ def convexWeightsConvolution (cw : ℕ → ℕ → StdSimplex R ℕ) : ℕ → 
   | 0 => fun n ↦ cw 0 n
   | k + 1 => fun n ↦ convexWeightsMul (cw (k + 1) n) (convexWeightsConvolution cw k)
 
-lemma convexWeightsConvolution_cong
-    {cw1 cw2 : ℕ → ℕ → StdSimplex R ℕ} {k : ℕ} (h : ∀ i ≤ k, cw1 i = cw2 i) :
+lemma convexWeightsConvolution_cong {cw1 cw2 : ℕ → ℕ → StdSimplex R ℕ} {k : ℕ}
+    (h : ∀ i ≤ k, cw1 i = cw2 i) :
     convexWeightsConvolution cw1 k = convexWeightsConvolution cw2 k := by
   induction k with
-  | zero =>
-    funext n
-    have h0 : cw1 0 = cw2 0 := h 0 (by simp)
-    simp [convexWeightsConvolution, h0]
-  | succ k ih =>
-    have hk : cw1 (k + 1) = cw2 (k + 1) := h (k + 1) (Nat.le_refl _)
-    have h' : ∀ i ≤ k, cw1 i = cw2 i := fun i hi => h i (Nat.le_succ_of_le hi)
-    have ih' :
-        convexWeightsConvolution cw1 k = convexWeightsConvolution cw2 k := ih h'
-    funext n
-    simp [convexWeightsConvolution, hk, ih']
+  | zero => simp [convexWeightsConvolution, h]
+  | succ k ih => simp [convexWeightsConvolution, h, ih (fun i hi => h i (Nat.le_succ_of_le hi))]
 
 omit [AddCommGroup E] in
-lemma convex_combination_bounded [NormedAddCommGroup E] [InnerProductSpace ℝ E]
-    {x : ℕ → E} {w : ℕ → StdSimplex ℝ ℕ}
-    (hx : ∃ M : ℝ, ∀ n, ‖x n‖ ≤ M) :
+lemma convex_combination_bounded [NormedAddCommGroup E] [InnerProductSpace ℝ E] {x : ℕ → E}
+    {w : ℕ → StdSimplex ℝ ℕ} (hx : ∃ M : ℝ, ∀ n, ‖x n‖ ≤ M) :
     ∃ M, ∀ n, ‖(w n).sum (fun i wi ↦ wi • x i)‖ ≤ M := by
   obtain ⟨M, hM⟩ := hx
   use M
@@ -153,7 +122,7 @@ lemma convex_combination_bounded [NormedAddCommGroup E] [InnerProductSpace ℝ E
     simp [norm_smul, abs_of_nonneg ((w _).nonneg _)]
   refine le_trans h_sum (le_trans (Finset.sum_le_sum fun i hi =>
     mul_le_mul_of_nonneg_left (hM i) ((w n).nonneg i)) ?_)
-  simp_all only [Finsupp.sum, ← Finset.sum_mul _ _ _]
+  rw [← Finset.sum_mul _ _ _]
   have bound : (∑ i ∈ (w n).support, (w n).weights i) ≤ 1 := by
     have : (∑ i ∈ (w n).support, (w n).weights i) = (1 : ℝ) := by
       simpa [Finsupp.sum] using (w n).total
diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 42bb949e..cc36899a 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -142,7 +142,7 @@ every `y n` can be written as a convex combination of elements `x k` with `k ≥
 def convexTail (x : ℕ → E) : Set (ℕ → E) :=
   { y | ∀ n, y n ∈ convexHull ℝ (Set.range (fun m ↦ x (n + m))) }
 
-lemma convex_weights_of_mem_convexHull_reindexed {x g : ℕ → E} (hg : g ∈ convexTail x) :
+lemma convex_weights_of_mem_convexTail_reindexed {x g : ℕ → E} (hg : g ∈ convexTail x) :
   ∀ n, ∃ w : StdSimplex ℝ ℕ, g n = w.sum (fun i wi ↦ wi • x i) ∧ ∀ m < n, w.weights m = 0 := by
   intro n
   obtain ⟨w₀, hw₀⟩ := stdSimplex_of_mem_convexHull (hg n)
@@ -153,9 +153,7 @@ lemma convex_weights_of_mem_convexHull_reindexed {x g : ℕ → E} (hg : g ∈ c
     split_ifs
     · exact (w₀.nonneg _)
     · simp
-  let w : StdSimplex ℝ ℕ := ⟨weights, nonneg, by grind [Finsupp.sum_embDomain]⟩
-  use w
-  have zero_lt (m : ℕ) (hm : m < n) : w.weights m = 0 := by
+  have zero_lt (m : ℕ) (hm : m < n) : weights m = 0 := by
     rw [Finsupp.embDomain_apply]
     split_ifs with h
     · exfalso
@@ -165,8 +163,8 @@ lemma convex_weights_of_mem_convexHull_reindexed {x g : ℕ → E} (hg : g ∈ c
         exact Nat.le_add_right n i
       exact (Nat.not_le_of_lt hm hnm).elim
     · rfl
+  use ⟨weights, nonneg, by grind [Finsupp.sum_embDomain]⟩
   refine ⟨?_, zero_lt⟩
-  unfold w
   rw [Finsupp.sum_embDomain]
   simpa
 
@@ -174,67 +172,63 @@ variable [CompleteSpace E]
 
 lemma komlos_base {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
     ∃ (cw : ℕ → ℕ → StdSimplex ℝ ℕ), (∃ glim : E,
-    Tendsto (komlosFormula x cw 0 0) atTop (𝓝 glim)) ∧ ∀ n, ∀ m < n, (cw 0 n).toFun m = 0 := by
+    Tendsto (komlosFormula x cw 0 0) atTop (𝓝 glim)) ∧ ∀ n, ∀ m < n, (cw 0 n).weights m = 0 := by
   obtain ⟨g, h_convex, lim, hlim⟩ := komlos_norm (hx 0)
-  let cw (n : ℕ) := Classical.choose (convex_weights_of_mem_convexHull_reindexed h_convex n)
+  let cw (n : ℕ) := Classical.choose (convex_weights_of_mem_convexTail_reindexed h_convex n)
   use (fun k ↦ cw)
   have hg (n : ℕ) : g n = (cw n).weights.sum (fun m cwm ↦ cwm • x 0 m) := by
-    exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed h_convex n)).1
+    exact (Classical.choose_spec (convex_weights_of_mem_convexTail_reindexed h_convex n)).1
   unfold komlosFormula
   constructor
   · use lim
     apply Tendsto.congr hg
     exact hlim
   · intro n
-    exact (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed h_convex n)).2
+    exact (Classical.choose_spec (convex_weights_of_mem_convexTail_reindexed h_convex n)).2
 
 lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ)
   (cw : ℕ → ℕ → StdSimplex ℝ ℕ) :
   ∃ (cw_new : ℕ → ℕ → StdSimplex ℝ ℕ),
     (∃ glim : E, Tendsto (komlosFormula x cw_new (k+1) (k+1)) atTop (𝓝 glim))
-    ∧ (∀ i ≤ k, cw_new i = cw i) ∧ (∀ n, ∀ m < n, (cw_new (k+1) n).toFun m = 0) := by
-  let gtilde' := fun n ↦ (convexWeightsConvolution cw k n).sum (fun m cwm ↦ cwm • (x (k+1) m))
-  have gtilde_bound : ∃ M, ∀ n, ‖gtilde' n‖ ≤ M :=
-    convex_combination_bounded (hx (k+1))
+    ∧ (∀ i ≤ k, cw_new i = cw i) ∧ (∀ n, ∀ m < n, (cw_new (k+1) n).weights m = 0) := by
+  let gtilde := fun n ↦ (convexWeightsConvolution cw k n).sum (fun m cwm ↦ cwm • (x (k+1) m))
+  have gtilde_bound : ∃ M, ∀ n, ‖gtilde n‖ ≤ M := convex_combination_bounded (hx (k+1))
   obtain ⟨g_step, gstep_conv, gstep_lim⟩ := komlos_norm (gtilde_bound)
-  have cw_step_exists : ∃ w : ℕ → StdSimplex ℝ ℕ,
-    (∀ n, ∀ m < n, (w n).weights m = 0)
-    ∧ ∀ n, g_step n = (w n).sum (fun i wi ↦ wi • gtilde' i) := by
-    refine ⟨fun n ↦ Classical.choose (convex_weights_of_mem_convexHull_reindexed gstep_conv n), ?_⟩
+  obtain ⟨cw_step, ⟨hzero, g_step_eq_gtilde⟩⟩ : ∃ w : ℕ → StdSimplex ℝ ℕ,
+    (∀ n, ∀ m < n, (w n).weights m = 0) ∧ ∀ n, g_step n = (w n).sum (fun i wi ↦ wi • gtilde i) := by
+    refine ⟨fun n ↦ Classical.choose (convex_weights_of_mem_convexTail_reindexed gstep_conv n), ?_⟩
     exact And.intro
-      (fun n ↦ (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed gstep_conv n)).2)
-      (fun n ↦ (Classical.choose_spec (convex_weights_of_mem_convexHull_reindexed gstep_conv n)).1)
-  obtain ⟨cw_step, ⟨hzero, hcombo⟩⟩ := cw_step_exists
+      (fun n ↦ (Classical.choose_spec (convex_weights_of_mem_convexTail_reindexed gstep_conv n)).2)
+      (fun n ↦ (Classical.choose_spec (convex_weights_of_mem_convexTail_reindexed gstep_conv n)).1)
   let cw_new := Function.update cw (k+1) cw_step
-  have g_new_expression (n : ℕ) : g_step n =
+  have g_step_eq (n : ℕ) : g_step n =
     (convexWeightsConvolution cw_new (k + 1) n).sum (fun m cwm ↦ cwm • x (k+1) m) := by
     have aux : (convexWeightsConvolution cw_new (k + 1) n)
       = (convexWeightsMul (cw_step n) (convexWeightsConvolution cw k)) := by
       unfold cw_new
-      rw [convexWeightsConvolution, Function.update_self,
-          convexWeightsConvolution_cong]
+      rw [convexWeightsConvolution, Function.update_self, convexWeightsConvolution_cong]
       grind
-    rw [hcombo n, aux, ← convexWeightsMul_sum_smul]
+    rw [g_step_eq_gtilde n, aux, ← convexWeightsMul_sum_smul]
   have old_indices_untouched: ∀ i ≤ k, cw_new i = cw i := by grind
   use cw_new
   refine ⟨?_, old_indices_untouched, ?_⟩
   · obtain ⟨glim, hglim⟩ := gstep_lim
     use glim
-    exact Tendsto.congr g_new_expression hglim
+    exact Tendsto.congr g_step_eq hglim
   · unfold cw_new
     simp only [Function.update_self]
     refine hzero
 
-private def komlos_stage {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (stage : ℕ) :
-  { w : ℕ → ℕ → StdSimplex ℝ ℕ // ∀ k ≤ stage, ∀ n, ∀ m < n, (w k n).toFun m = 0 } :=
+private def komlosStage {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (stage : ℕ) :
+  { w : ℕ → ℕ → StdSimplex ℝ ℕ // ∀ k ≤ stage, ∀ n, ∀ m < n, (w k n).weights m = 0 } :=
   match stage with
   | 0 => by
-    use Classical.choose (komlos_base hx)
-    intro k hk
-    rw [show k=0 by grind]
-    exact (Classical.choose_spec (komlos_base hx)).2
+      use Classical.choose (komlos_base hx)
+      intro k hk
+      rw [show k=0 by grind]
+      exact (Classical.choose_spec (komlos_base hx)).2
   | stage+1 => by
-      let ⟨previous, hprevious⟩ := komlos_stage hx stage
+      let ⟨previous, hprevious⟩ := komlosStage hx stage
       let step := komlos_step hx stage previous
       use Classical.choose step
       intro k _
@@ -246,26 +240,24 @@ private def komlos_stage {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ,
         rw [transfer k hk]
         exact hprevious k hk
 
-private lemma komlos_stage_lim {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
-  (∃ glim : E, Tendsto (komlosFormula x (komlos_stage hx k) k k) atTop (𝓝 glim)) := by
+private lemma komlosStage_lim {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
+  (∃ glim : E, Tendsto (komlosFormula x (komlosStage hx k) k k) atTop (𝓝 glim)) := by
   induction k with
   | zero => exact (Classical.choose_spec (komlos_base hx)).1
-  | succ k _ => exact
-      Classical.choose_spec (komlos_step hx k (komlos_stage hx k)) |>.1
+  | succ k _ => exact Classical.choose_spec (komlos_step hx k (komlosStage hx k)) |>.1
 
-private lemma agreement_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
-  ∀ i ≤ k, (komlos_stage hx k).val i = (komlos_stage hx (k+1)).val i := by
+private lemma komlosStage_cong_succ {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
+  ∀ i ≤ k, (komlosStage hx k).val i = (komlosStage hx (k+1)).val i := by
   intro i hi
-  let aux := komlos_step hx k (komlos_stage hx k)
+  let aux := komlos_step hx k (komlosStage hx k)
   let ⟨_, aux2, _⟩ := Classical.choose_spec aux
   exact Eq.symm (aux2 i hi)
 
-private lemma agreement_necessary_condition {x : ℕ → ℕ → E}
-    (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M)
-  (i k : ℕ) (hi : i ≤ k) :
-  (komlos_stage hx i).val i = (komlos_stage hx k).val i := by
+private lemma komlosStage_cong {x : ℕ → ℕ → E}
+    (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (i k : ℕ) (hi : i ≤ k) :
+    (komlosStage hx i).val i = (komlosStage hx k).val i := by
   let n := k-i
-  suffices (komlos_stage hx i).val i = (komlos_stage hx (i+n)).val i from by
+  suffices (komlosStage hx i).val i = (komlosStage hx (i+n)).val i from by
     unfold n at this
     rw [show i + (k - i) = k by grind] at this
     exact this
@@ -273,32 +265,19 @@ private lemma agreement_necessary_condition {x : ℕ → ℕ → E}
   | zero => rfl
   | succ n hn =>
   rw [← add_assoc, hn]
-  apply agreement_step hx (i+n) i (by grind)
+  apply komlosStage_cong_succ hx (i+n) i (by grind)
 
-lemma komlos_convex_weights
-    {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
+lemma komlos_convex_weights {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
     ∃ (cw : ℕ → ℕ → StdSimplex ℝ ℕ),
     (∀ k : ℕ, ∃ glim : E, Tendsto (komlosFormula x cw k k) atTop (𝓝 glim))
-    ∧ (∀ k n, ∀ m < n, (cw k n).toFun m = 0) := by
-  have hcwStage2 (k : ℕ) :
-    ∃ glim : E, Tendsto (komlosFormula x (komlos_stage hx k) k k) atTop (𝓝 glim) := by
-    simpa using (komlos_stage_lim (x := x) hx k)
-  let cw (k : ℕ) : ℕ → StdSimplex ℝ ℕ := (komlos_stage hx k).val k
-  have agreement (k i : ℕ) (hi : i ≤ k) :
-    cw i = (komlos_stage hx k).val i := by
-    unfold cw
-    apply agreement_necessary_condition hx
-    exact hi
-  have transfer (k : ℕ) : komlosFormula x cw k = komlosFormula x (komlos_stage hx k) k := by
-    apply komlosFormula_cong x
-    exact agreement k
+    ∧ (∀ k n, ∀ m < n, (cw k n).weights m = 0) := by
+  let cw (k : ℕ) : ℕ → StdSimplex ℝ ℕ := (komlosStage hx k).val k
+  have transfer (k : ℕ) : komlosFormula x cw k = komlosFormula x (komlosStage hx k) k :=
+    komlosFormula_cong x (fun i hi ↦ komlosStage_cong hx i k hi)
   use cw
   constructor
-  · intro k
-    simp_rw [transfer k]
-    exact hcwStage2 k
-  · intro k
-    exact (komlos_stage hx k).prop k (le_refl k)
+  · intro k; simp [transfer k, komlosStage_lim hx k]
+  · intro k; exact (komlosStage hx k).prop k (le_refl k)
 
 omit [CompleteSpace E] in
 lemma TendstoUniformly_convexTail {x : ℕ → E} {xlim : E} (hx : Tendsto x atTop (𝓝 xlim)) :

From 04fd754c44e877fa131fad574d00a4105e8d4cec Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Mon, 27 Apr 2026 16:45:14 +0100
Subject: [PATCH 28/37] refactor(Komlos): golf proof

---
 BrownianMotion/StochasticIntegral/Komlos.lean | 28 +++++--------------
 1 file changed, 7 insertions(+), 21 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index cc36899a..7d3e7d7a 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -282,34 +282,20 @@ lemma komlos_convex_weights {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : 
 omit [CompleteSpace E] in
 lemma TendstoUniformly_convexTail {x : ℕ → E} {xlim : E} (hx : Tendsto x atTop (𝓝 xlim)) :
   TendstoUniformly (fun (n : ℕ) (y : convexTail x) ↦ (y.val) n) (fun _ ↦ xlim) atTop := by
-  -- GPT 5.2 proof:
-  -- Unfolding `TendstoUniformly` gives an entourage `u` and we must show that eventually,
-  -- `(xlim, y n) ∈ u` for all `y : convexTail x`.
   intro u hu
-  rcases Metric.mem_uniformity_dist.1 hu with ⟨ε, εpos, hεu⟩
+  rcases Metric.mem_uniformity_dist.mp hu with ⟨ε, εpos, hεu⟩
   have hxε : ∀ᶠ n in atTop, dist (x n) xlim < ε := by
-    have hx' : ∀ᶠ n in atTop, x n ∈ Metric.ball xlim ε :=
-      hx (Metric.ball_mem_nhds _ εpos)
-    simpa [Metric.mem_ball] using hx'
-  rcases Filter.eventually_atTop.1 hxε with ⟨N, hN⟩
-  refine Filter.eventually_atTop.2 ⟨N, ?_⟩
+    simpa using hx (Metric.ball_mem_nhds _ εpos)
+  rcases Filter.eventually_atTop.mp hxε with ⟨N, hN⟩
+  refine Filter.eventually_atTop.mpr ⟨N, ?_⟩
   intro n hn y
   apply hεu
-  -- Reduce to a ball estimate, then use convexity of balls.
   have htail : Set.range (fun m ↦ x (n + m)) ⊆ Metric.ball xlim ε := by
     rintro _ ⟨m, rfl⟩
-    have : dist (x (n + m)) xlim < ε :=
-      hN (n + m) (le_trans hn (Nat.le_add_right n m))
-    simpa [Metric.mem_ball] using this
-  have hconv : convexHull ℝ (Set.range (fun m ↦ x (n + m))) ⊆ Metric.ball xlim ε := by
-    refine convexHull_min htail (convex_ball xlim ε)
-  have hy : y.1 n ∈ convexHull ℝ (Set.range (fun m ↦ x (n + m))) := y.2 n
-  have hyball : y.1 n ∈ Metric.ball xlim ε := hconv hy
+    simpa using hN (n + m) (le_trans hn (Nat.le_add_right n m))
   have : dist xlim (y.1 n) < ε := by
-    have : dist (y.1 n) xlim < ε := by
-      simpa [Metric.mem_ball] using hyball
-    simpa [dist_comm] using this
-  simpa using this
+    simpa [dist_comm] using (convexHull_min htail (convex_ball xlim ε)) (y.2 n)
+  simpa only [gt_iff_lt] using this
 
 omit [CompleteSpace E] in
 lemma Tendsto_convexTail {x : ℕ → E} {xlim : E} (hx : Tendsto x atTop (𝓝 xlim)) :

From de87a8e9e2565d6007b505a946f19ec6e8684208 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Tue, 28 Apr 2026 10:50:15 +0100
Subject: [PATCH 29/37] refactor: golf

---
 .../StochasticIntegral/ConvexWeights.lean     | 47 ++++++-------------
 1 file changed, 14 insertions(+), 33 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
index d51f481b..e6f4d484 100644
--- a/BrownianMotion/StochasticIntegral/ConvexWeights.lean
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -46,8 +46,7 @@ lemma convexWeightsMul_eq :
   (convexWeightsMul a b).weights = (fun m ↦ ∑ k ∈ a.support, a.weights k * (b k).weights m) := by
   ext m
   rw [convexWeightsMul, StdSimplex.join, StdSimplex.map]
-  change ((Finsupp.mapDomain b a.weights).sum (fun d r => r • d.weights)) m = _
-  simp only [Finsupp.sum_apply, Finsupp.coe_smul, Pi.smul_apply, smul_eq_mul]
+  simp only [Finsupp.sum_apply]
   rw [Finsupp.sum_mapDomain_index (fun _ => by simp) (fun _ _ _ => by simp [add_mul])]
   simp [Finsupp.sum]
 
@@ -55,44 +54,28 @@ lemma support_subset_convexWeightsMul_support {a : StdSimplex R ι} (b : ι →
     {i : ι} (hi : i ∈ a.support) :
     (b i).support ⊆ (convexWeightsMul a b).support := by
   intro m hm
-  have hbim_ne : (b i).weights m ≠ 0 := by
-    simpa [Finsupp.mem_support_iff] using hm
-  have hai_ne : a.weights i ≠ 0 := by
-    simpa [Finsupp.mem_support_iff] using hi
-  have hpos_term : 0 < a.weights i * (b i).weights m := by
-    have hai_pos : 0 < a.weights i := (a.nonneg i).lt_of_ne' hai_ne
-    have hbim_pos : 0 < (b i).weights m := ((b i).nonneg m).lt_of_ne' hbim_ne
-    exact mul_pos hai_pos hbim_pos
-  have hnonneg : ∀ k ∈ a.support, 0 ≤ a.weights k * (b k).weights m := by
-    intro k hk
+  have hpos : 0 < a.weights i * (b i).weights m :=
+    mul_pos ((a.nonneg i).lt_of_ne' (by grind)) (((b i).nonneg m).lt_of_ne' (by grind))
+  have hnonneg (k : ι) (hk : k ∈ a.support) : 0 ≤ a.weights k * (b k).weights m := by
     exact mul_nonneg (a.nonneg k) ((b k).nonneg m)
-  have hle : a.weights i * (b i).weights m ≤ ∑ k ∈ a.support, a.weights k * (b k).weights m := by
-    exact Finset.single_le_sum hnonneg hi
   have hsum_pos : 0 < ∑ k ∈ a.support, a.weights k * (b k).weights m :=
-    lt_of_lt_of_le hpos_term hle
-  have hsum_ne : (∑ k ∈ a.support, a.weights k * (b k).weights m) ≠ 0 := ne_of_gt hsum_pos
-  have hm_eq : (convexWeightsMul a b).weights m
-      = ∑ k ∈ a.support, a.weights k * (b k).weights m := by
-    simpa using congrArg (fun f => f m) (convexWeightsMul_eq a b)
-  have : (convexWeightsMul a b).weights m ≠ 0 := by
-    simpa [hm_eq] using hsum_ne
-  simpa [Finsupp.mem_support_iff] using this
+    lt_of_lt_of_le hpos (Finset.single_le_sum hnonneg hi)
+  rw [Finsupp.mem_support_iff, convexWeightsMul_eq]
+  positivity
 
 lemma convexWeightsMul_sum_smul (f : ι' → E) [Module R E] :
     a.sum (fun i wi ↦ wi • (b i).sum (fun m bm ↦ bm • f m))
     = (convexWeightsMul a b).sum (fun m cwm ↦ cwm • f m) := by
   classical
   simp only [convexWeightsMul, StdSimplex.join, StdSimplex.map]
-  rw [Finsupp.sum_sum_index (fun _ => by simp) (fun _ _ _ => by simp [add_smul])]
-  rw [Finsupp.sum_mapDomain_index (fun _ => by simp)
-    (fun d r₁ r₂ => by simp [add_smul, Finsupp.sum_add_index, add_smul])]
+  rw [Finsupp.sum_sum_index (fun _ => by simp) (fun _ _ _ => by simp [add_smul]),
+      Finsupp.sum_mapDomain_index (fun _ => by simp)
+      (fun d r₁ r₂ => by simp [add_smul, Finsupp.sum_add_index, add_smul])]
   simp only [Finsupp.sum]
   refine Finset.sum_congr rfl ?_
   intro i hi
-  have hai_ne : a.weights i ≠ 0 := by
-    simpa [Finsupp.mem_support_iff] using hi
-  have hsupp : (a.weights i • (b i).weights).support = (b i).weights.support := by
-    simpa using Finsupp.support_smul_eq hai_ne
+  have hsupp : (a.weights i • (b i).weights).support = (b i).weights.support :=
+    Finsupp.support_smul_eq (by grind)
   simp [hsupp, Finset.smul_sum, Finsupp.smul_apply, smul_smul]
 
 /-- Given a doubly-indexed family of convex weights `cw : ℕ → ℕ → StdSimplex R ℕ`,
@@ -118,14 +101,12 @@ lemma convex_combination_bounded [NormedAddCommGroup E] [InnerProductSpace ℝ E
   intro n
   have h_sum : ‖(w n).sum (fun i wi => wi • x i)‖ ≤ ∑ i ∈ (w n).support, ((w n).weights i) * ‖x i‖
     := by
-    convert norm_sum_le _ _ using 2
+    convert norm_sum_le _ _
     simp [norm_smul, abs_of_nonneg ((w _).nonneg _)]
   refine le_trans h_sum (le_trans (Finset.sum_le_sum fun i hi =>
     mul_le_mul_of_nonneg_left (hM i) ((w n).nonneg i)) ?_)
   rw [← Finset.sum_mul _ _ _]
   have bound : (∑ i ∈ (w n).support, (w n).weights i) ≤ 1 := by
-    have : (∑ i ∈ (w n).support, (w n).weights i) = (1 : ℝ) := by
-      simpa [Finsupp.sum] using (w n).total
-    exact this.le
+    rw [← (w n).total, Finsupp.sum]
   refine mul_le_of_le_one_left ?_ bound
   exact le_trans (norm_nonneg (x 0)) (hM 0)

From 756be15fcd86b3f7b6df7e9e141d3e00c4471e80 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Tue, 28 Apr 2026 10:57:50 +0100
Subject: [PATCH 30/37] refactor(Komlos): golf

---
 BrownianMotion/StochasticIntegral/Komlos.lean | 26 +++++++------------
 1 file changed, 10 insertions(+), 16 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 7d3e7d7a..840dbe7b 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -193,7 +193,7 @@ lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n,
     ∧ (∀ i ≤ k, cw_new i = cw i) ∧ (∀ n, ∀ m < n, (cw_new (k+1) n).weights m = 0) := by
   let gtilde := fun n ↦ (convexWeightsConvolution cw k n).sum (fun m cwm ↦ cwm • (x (k+1) m))
   have gtilde_bound : ∃ M, ∀ n, ‖gtilde n‖ ≤ M := convex_combination_bounded (hx (k+1))
-  obtain ⟨g_step, gstep_conv, gstep_lim⟩ := komlos_norm (gtilde_bound)
+  obtain ⟨g_step, gstep_conv, glim, hglim⟩ := komlos_norm (gtilde_bound)
   obtain ⟨cw_step, ⟨hzero, g_step_eq_gtilde⟩⟩ : ∃ w : ℕ → StdSimplex ℝ ℕ,
     (∀ n, ∀ m < n, (w n).weights m = 0) ∧ ∀ n, g_step n = (w n).sum (fun i wi ↦ wi • gtilde i) := by
     refine ⟨fun n ↦ Classical.choose (convex_weights_of_mem_convexTail_reindexed gstep_conv n), ?_⟩
@@ -209,15 +209,12 @@ lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n,
       rw [convexWeightsConvolution, Function.update_self, convexWeightsConvolution_cong]
       grind
     rw [g_step_eq_gtilde n, aux, ← convexWeightsMul_sum_smul]
-  have old_indices_untouched: ∀ i ≤ k, cw_new i = cw i := by grind
   use cw_new
-  refine ⟨?_, old_indices_untouched, ?_⟩
-  · obtain ⟨glim, hglim⟩ := gstep_lim
-    use glim
-    exact Tendsto.congr g_step_eq hglim
+  refine ⟨?_, by grind, ?_⟩
+  · use glim; exact Tendsto.congr g_step_eq hglim
   · unfold cw_new
     simp only [Function.update_self]
-    refine hzero
+    exact hzero
 
 private def komlosStage {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (stage : ℕ) :
   { w : ℕ → ℕ → StdSimplex ℝ ℕ // ∀ k ≤ stage, ∀ n, ∀ m < n, (w k n).weights m = 0 } :=
@@ -246,21 +243,18 @@ private lemma komlosStage_lim {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M :
   | zero => exact (Classical.choose_spec (komlos_base hx)).1
   | succ k _ => exact Classical.choose_spec (komlos_step hx k (komlosStage hx k)) |>.1
 
-private lemma komlosStage_cong_succ {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ) :
-  ∀ i ≤ k, (komlosStage hx k).val i = (komlosStage hx (k+1)).val i := by
+private lemma komlosStage_cong_succ {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M)
+  (k : ℕ) : ∀ i ≤ k, (komlosStage hx k).val i = (komlosStage hx (k+1)).val i := by
   intro i hi
   let aux := komlos_step hx k (komlosStage hx k)
   let ⟨_, aux2, _⟩ := Classical.choose_spec aux
   exact Eq.symm (aux2 i hi)
 
-private lemma komlosStage_cong {x : ℕ → ℕ → E}
-    (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (i k : ℕ) (hi : i ≤ k) :
-    (komlosStage hx i).val i = (komlosStage hx k).val i := by
+private lemma komlosStage_cong {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M)
+    (i k : ℕ) (hi : i ≤ k) : (komlosStage hx i).val i = (komlosStage hx k).val i := by
   let n := k-i
-  suffices (komlosStage hx i).val i = (komlosStage hx (i+n)).val i from by
-    unfold n at this
-    rw [show i + (k - i) = k by grind] at this
-    exact this
+  suffices (komlosStage hx i).val i = (komlosStage hx (i+n)).val i by
+    rwa [show k = i + (k - i) by grind]
   induction n with
   | zero => rfl
   | succ n hn =>

From 031b0b17e06db6e2d7325d7e32b5d071f0935614 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Tue, 28 Apr 2026 14:18:43 +0100
Subject: [PATCH 31/37] fix: blueprint fixes

---
 blueprint/src/chapters/doob_meyer.tex | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/blueprint/src/chapters/doob_meyer.tex b/blueprint/src/chapters/doob_meyer.tex
index 1235dd5e..2de4a656 100644
--- a/blueprint/src/chapters/doob_meyer.tex
+++ b/blueprint/src/chapters/doob_meyer.tex
@@ -76,7 +76,6 @@ \section{Komlòs Lemma}
 \end{lemma}
 
 \begin{proof} \leanok
-The second point is a direct consequence of the first one, so we only prove the first one.
 Let $\varepsilon>0$.
 By convergence of $x_n$, there exists $\bar{n}$ such that for all $n \ge \bar{n}$, $\Vert x_n-x \Vert \le \varepsilon$.
 Let $a_{n, m}$ be convex weights such that $y_n = \sum_{m = n}^{N_n} a_{n, m} x_m$.
@@ -141,7 +140,7 @@ \section{Komlòs Lemma}
 Then for every $k \ge i$, the sequence $\left(\sum_{m \ge n} \left((\lambda^{k,n}_\cdot) * \ldots * (\lambda^{1,\cdot}_\cdot)\right)_m x_m^{(i)}\right)_{n \in \mathbb{N}}$ converges to $g^i$, uniformly in $k$.
 \end{lemma}
 
-\begin{proof}
+\begin{proof} \leanok
   \uses{lem:convex_of_converg_seq_is_converg}
 Let $i \in \mathbb{N}$.
 By Lemma~\ref{lem:convex_of_converg_seq_is_converg}, there is uniform convergence over all convex combinations of the sequence $\left(\sum_{m \ge n} \left((\lambda^{i,n}_\cdot) * \ldots * (\lambda^{1,\cdot}_\cdot)\right)_m x_m^{(i)}\right)_{n \in \mathbb{N}}$ to $g^i$.

From 718051f752a60e2f2a6c87fde4fa9bfe8a77b46a Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Wed, 29 Apr 2026 10:20:26 +0100
Subject: [PATCH 32/37] refactor: rename convexWeightsMul to  StdSimplex.bind

---
 .../StochasticIntegral/ConvexWeights.lean     | 120 +++++++-----------
 BrownianMotion/StochasticIntegral/Komlos.lean |  61 +++++++--
 blueprint/src/chapters/doob_meyer.tex         |   2 +-
 3 files changed, 100 insertions(+), 83 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
index e6f4d484..b4d348f2 100644
--- a/BrownianMotion/StochasticIntegral/ConvexWeights.lean
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -4,70 +4,75 @@ public import Mathlib.Analysis.InnerProductSpace.Defs
 public import Mathlib.LinearAlgebra.ConvexSpace
 
 /-
-# Lemmas on Convex Weights
+# Lemmas on StdSimplex
 -/
 
 @[expose] public noncomputable section
 
-variable {ι ι' E R : Type*} [AddCommGroup E] [Field R] [LinearOrder R] [IsStrictOrderedRing R]
+variable {R : Type*} [PartialOrder R] [Semiring R] {M N P : Type*}
 
-lemma stdSimplex_of_mem_convexHull [Module R E] {s : ι → E} {x : E}
-    (hx : x ∈ convexHull R (Set.range s)) :
-    ∃ (w : StdSimplex R ι), x = w.sum (fun i wi ↦ wi • s i) := by
-  classical
-  rw [mem_convexHull_iff] at hx
-  specialize hx {y | ∃ w : StdSimplex R ι, y = w.sum (fun i wi => wi • s i)} ?_ ?_
-  · rintro _ ⟨i, rfl⟩
-    use StdSimplex.single i
-    simp
-  · rintro x ⟨w₁, hw₁⟩ y ⟨w₂, hw₂⟩ a b ha hb hab
-    use (StdSimplex.duple w₁ w₂ ha hb hab).join
-    simp only [StdSimplex.join, StdSimplex.duple]
-    repeat rw [Finsupp.sum_add_index (by simp) (fun _ _ _ _ ↦ Module.add_smul _ _ _)]
-    have aux (c : R) (w : StdSimplex R ι) : c • (w.sum fun i wi ↦ wi • s i)
-      = ((Finsupp.single w c).sum fun d r ↦ r • d.weights).sum fun i wi ↦ wi • s i := by
-      simp only [zero_smul, Finsupp.sum_single_index]
-      rw [Finsupp.sum_smul_index (by simp only [zero_smul, implies_true])]
-      simp_rw [mul_smul, ← Finsupp.smul_sum]
-    simp [aux, hw₁, hw₂]
-  exact hx
+namespace StdSimplex
+
+instance instFunLike : FunLike (StdSimplex R M) M R := {
+  coe s := s.weights.toFun
+  coe_injective' := fun _ _ h ↦ ext (Finsupp.ext fun i ↦ congrFun h i)
+}
+
+variable [IsStrictOrderedRing R]
 
 /-- Given convex weights `a : StdSimplex R ι` and a family of convex weights
-`b : ι → StdSimplex R ι'`, `convexWeightsMul a b` is the convex combination of the `b k`, weighted
-by `a`. We show that, `(convexWeightsMul a b) m = ∑ k ∈ a.support, a k * b k m` in
-`convexWeightsMul_eq` and define it here more abstractly using `StdSimplex.map` and
-`StdSimplex.join`. -/
-def convexWeightsMul (a : StdSimplex R ι) (b : ι → StdSimplex R ι') : StdSimplex R ι' :=
-  (a.map b).join
+`b : ι → StdSimplex R ι'`, `StdSimplex.bind a b` is the convex combination of the `b k`, weighted
+by `a`, defined as monadic bind. -/
+def bind (a : StdSimplex R M) (b : M → StdSimplex R N) : StdSimplex R N := (a.map b).join
+
+variable (a : StdSimplex R M) (b : M → StdSimplex R N)
 
-variable (a : StdSimplex R ι) (b : ι → StdSimplex R ι')
+@[simp]
+lemma bind_single (i : M) : bind (single i) b = b i := by simp [bind, join]
 
-lemma convexWeightsMul_eq :
-  (convexWeightsMul a b).weights = (fun m ↦ ∑ k ∈ a.support, a.weights k * (b k).weights m) := by
+@[simp]
+lemma bind_const (c : StdSimplex R N) : bind a (fun _ ↦ c) = c := by simp [bind, join]
+
+lemma bind_weights :
+  (bind a b).weights = (fun m ↦ ∑ k ∈ a.support, a.weights k * (b k).weights m) := by
   ext m
-  rw [convexWeightsMul, StdSimplex.join, StdSimplex.map]
+  rw [bind, join, map]
   simp only [Finsupp.sum_apply]
   rw [Finsupp.sum_mapDomain_index (fun _ => by simp) (fun _ _ _ => by simp [add_mul])]
   simp [Finsupp.sum]
 
-lemma support_subset_convexWeightsMul_support {a : StdSimplex R ι} (b : ι → StdSimplex R ι')
-    {i : ι} (hi : i ∈ a.support) :
-    (b i).support ⊆ (convexWeightsMul a b).support := by
+lemma support_subset_bind_support {a : StdSimplex R M} (b : M → StdSimplex R N)
+    {i : M} (hi : i ∈ a.support) :
+    (b i).support ⊆ (bind a b).support := by
   intro m hm
   have hpos : 0 < a.weights i * (b i).weights m :=
     mul_pos ((a.nonneg i).lt_of_ne' (by grind)) (((b i).nonneg m).lt_of_ne' (by grind))
-  have hnonneg (k : ι) (hk : k ∈ a.support) : 0 ≤ a.weights k * (b k).weights m := by
+  have hnonneg (k : M) (hk : k ∈ a.support) : 0 ≤ a.weights k * (b k).weights m := by
     exact mul_nonneg (a.nonneg k) ((b k).nonneg m)
   have hsum_pos : 0 < ∑ k ∈ a.support, a.weights k * (b k).weights m :=
     lt_of_lt_of_le hpos (Finset.single_le_sum hnonneg hi)
-  rw [Finsupp.mem_support_iff, convexWeightsMul_eq]
+  rw [Finsupp.mem_support_iff, bind_weights]
   positivity
 
-lemma convexWeightsMul_sum_smul (f : ι' → E) [Module R E] :
-    a.sum (fun i wi ↦ wi • (b i).sum (fun m bm ↦ bm • f m))
-    = (convexWeightsMul a b).sum (fun m cwm ↦ cwm • f m) := by
+/-- Given a doubly-indexed family of convex weights `cw : ℕ → ℕ → StdSimplex R ℕ`,
+`iteratedBind cw k n` is the iterated convex multiplication obtained by combining
+the weights `cw 0 n, cw 1 n, …, cw k n` via `StdSimplex.bind`. -/
+def iteratedBind (cw : ℕ → ℕ → StdSimplex R ℕ) : ℕ → ℕ → StdSimplex R ℕ
+  | 0 => cw 0
+  | k + 1 => fun n ↦ bind (cw (k + 1) n) (iteratedBind cw k)
+
+lemma iteratedBind_cong {cw1 cw2 : ℕ → ℕ → StdSimplex R ℕ} {k : ℕ}
+    (h : ∀ i ≤ k, cw1 i = cw2 i) :
+    iteratedBind cw1 k = iteratedBind cw2 k := by
+  induction k with
+  | zero => simp [iteratedBind, h]
+  | succ k ih => simp [iteratedBind, h, ih (fun i hi => h i (Nat.le_succ_of_le hi))]
+
+lemma bind_sum_smul {E : Type*} (f : N → E) [AddCommGroup E] [Module R E] [IsDomain R] :
+  (bind a b).sum (fun m cwm ↦ cwm • f m) =
+  a.sum (fun i wi ↦ wi • (b i).sum (fun m bm ↦ bm • f m)) := by
   classical
-  simp only [convexWeightsMul, StdSimplex.join, StdSimplex.map]
+  simp only [bind, StdSimplex.join, StdSimplex.map]
   rw [Finsupp.sum_sum_index (fun _ => by simp) (fun _ _ _ => by simp [add_smul]),
       Finsupp.sum_mapDomain_index (fun _ => by simp)
       (fun d r₁ r₂ => by simp [add_smul, Finsupp.sum_add_index, add_smul])]
@@ -78,35 +83,4 @@ lemma convexWeightsMul_sum_smul (f : ι' → E) [Module R E] :
     Finsupp.support_smul_eq (by grind)
   simp [hsupp, Finset.smul_sum, Finsupp.smul_apply, smul_smul]
 
-/-- Given a doubly-indexed family of convex weights `cw : ℕ → ℕ → StdSimplex R ℕ`,
-`convexWeightsConvolution cw k n` is the iterated convex multiplication obtained by combining
-the weights `cw 0 n, cw 1 n, …, cw k n` via `convexWeightsMul`. -/
-def convexWeightsConvolution (cw : ℕ → ℕ → StdSimplex R ℕ) : ℕ → ℕ → StdSimplex R ℕ
-  | 0 => fun n ↦ cw 0 n
-  | k + 1 => fun n ↦ convexWeightsMul (cw (k + 1) n) (convexWeightsConvolution cw k)
-
-lemma convexWeightsConvolution_cong {cw1 cw2 : ℕ → ℕ → StdSimplex R ℕ} {k : ℕ}
-    (h : ∀ i ≤ k, cw1 i = cw2 i) :
-    convexWeightsConvolution cw1 k = convexWeightsConvolution cw2 k := by
-  induction k with
-  | zero => simp [convexWeightsConvolution, h]
-  | succ k ih => simp [convexWeightsConvolution, h, ih (fun i hi => h i (Nat.le_succ_of_le hi))]
-
-omit [AddCommGroup E] in
-lemma convex_combination_bounded [NormedAddCommGroup E] [InnerProductSpace ℝ E] {x : ℕ → E}
-    {w : ℕ → StdSimplex ℝ ℕ} (hx : ∃ M : ℝ, ∀ n, ‖x n‖ ≤ M) :
-    ∃ M, ∀ n, ‖(w n).sum (fun i wi ↦ wi • x i)‖ ≤ M := by
-  obtain ⟨M, hM⟩ := hx
-  use M
-  intro n
-  have h_sum : ‖(w n).sum (fun i wi => wi • x i)‖ ≤ ∑ i ∈ (w n).support, ((w n).weights i) * ‖x i‖
-    := by
-    convert norm_sum_le _ _
-    simp [norm_smul, abs_of_nonneg ((w _).nonneg _)]
-  refine le_trans h_sum (le_trans (Finset.sum_le_sum fun i hi =>
-    mul_le_mul_of_nonneg_left (hM i) ((w n).nonneg i)) ?_)
-  rw [← Finset.sum_mul _ _ _]
-  have bound : (∑ i ∈ (w n).support, (w n).weights i) ≤ 1 := by
-    rw [← (w n).total, Finsupp.sum]
-  refine mul_le_of_le_one_left ?_ bound
-  exact le_trans (norm_nonneg (x 0)) (hM 0)
+end StdSimplex
diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 840dbe7b..45786b05 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -120,19 +120,60 @@ lemma komlos_norm [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
   rcases CompleteSpace.complete g_cauchy with ⟨x, hx⟩
   tauto
 
+
+lemma stdSimplex_of_mem_convexHull {M ι : Type*} [AddCommGroup E] [Field M] [LinearOrder M]
+    [IsStrictOrderedRing M] [Module M E] {s : ι → E} {x : E}
+    (hx : x ∈ convexHull M (Set.range s)) :
+    ∃ (w : StdSimplex M ι), x = w.sum (fun i wi ↦ wi • s i) := by
+  classical
+  rw [mem_convexHull_iff] at hx
+  specialize hx {y | ∃ w : StdSimplex M ι, y = w.sum (fun i wi => wi • s i)} ?_ ?_
+  · rintro _ ⟨i, rfl⟩
+    use StdSimplex.single i
+    simp
+  · rintro x ⟨w₁, hw₁⟩ y ⟨w₂, hw₂⟩ a b ha hb hab
+    use (StdSimplex.duple w₁ w₂ ha hb hab).join
+    simp only [StdSimplex.join, StdSimplex.duple]
+    repeat rw [Finsupp.sum_add_index (by simp) (fun _ _ _ _ ↦ Module.add_smul _ _ _)]
+    have aux (c : M) (w : StdSimplex M ι) : c • (w.sum fun i wi ↦ wi • s i)
+      = ((Finsupp.single w c).sum fun d r ↦ r • d.weights).sum fun i wi ↦ wi • s i := by
+      simp only [zero_smul, Finsupp.sum_single_index]
+      rw [Finsupp.sum_smul_index (by simp only [zero_smul, implies_true])]
+      simp_rw [mul_smul, ← Finsupp.smul_sum]
+    simp [aux, hw₁, hw₂]
+  exact hx
+
 noncomputable section
 variable [NormedAddCommGroup E] [InnerProductSpace ℝ E]
 
+lemma convex_combination_bounded {x : ℕ → E}
+    {w : ℕ → StdSimplex ℝ ℕ} (hx : ∃ M : ℝ, ∀ n, ‖x n‖ ≤ M) :
+    ∃ M, ∀ n, ‖(w n).sum (fun i wi ↦ wi • x i)‖ ≤ M := by
+  obtain ⟨M, hM⟩ := hx
+  use M
+  intro n
+  have h_sum : ‖(w n).sum (fun i wi => wi • x i)‖ ≤ ∑ i ∈ (w n).support, ((w n).weights i) * ‖x i‖
+    := by
+    convert norm_sum_le _ _
+    simp [norm_smul, abs_of_nonneg ((w _).nonneg _)]
+  refine le_trans h_sum (le_trans (Finset.sum_le_sum fun i hi =>
+    mul_le_mul_of_nonneg_left (hM i) ((w n).nonneg i)) ?_)
+  rw [← Finset.sum_mul _ _ _]
+  have bound : (∑ i ∈ (w n).support, (w n).weights i) ≤ 1 := by
+    rw [← (w n).total, Finsupp.sum]
+  refine mul_le_of_le_one_left ?_ bound
+  exact le_trans (norm_nonneg (x 0)) (hM 0)
+
 /-- `komlosFormula x cw k n` is the convex combination of the stage-`k` vectors `x k m`,
-weighted by `convexWeightsConvolutionSimplex cw k n`. It is the sequence whose convergence is
+weighted by `iteratedBindSimplex cw k n`. It is the sequence whose convergence is
 established at each stage of the Komlós construction. -/
 def komlosFormula (x : ℕ → ℕ → E) (cw : ℕ → ℕ → StdSimplex ℝ ℕ) (k i n : ℕ) : E :=
-  (convexWeightsConvolution cw k n).sum (fun m cwm ↦ cwm • x i m)
+  (StdSimplex.iteratedBind cw k n).sum (fun m cwm ↦ cwm • x i m)
 
 lemma komlosFormula_cong (x : ℕ → ℕ → E) {cw1 : ℕ → ℕ → StdSimplex ℝ ℕ}
   {cw2 : ℕ → ℕ → StdSimplex ℝ ℕ} {k : ℕ} (h : ∀ k' ≤ k, cw1 k' = cw2 k') :
   komlosFormula x cw1 k = komlosFormula x cw2 k := by
-  unfold komlosFormula; rw [convexWeightsConvolution_cong]
+  unfold komlosFormula; rw [StdSimplex.iteratedBind_cong]
   exact h
 
 /--
@@ -186,12 +227,14 @@ lemma komlos_base {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n,
   · intro n
     exact (Classical.choose_spec (convex_weights_of_mem_convexTail_reindexed h_convex n)).2
 
+open StdSimplex
+
 lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (k : ℕ)
   (cw : ℕ → ℕ → StdSimplex ℝ ℕ) :
   ∃ (cw_new : ℕ → ℕ → StdSimplex ℝ ℕ),
     (∃ glim : E, Tendsto (komlosFormula x cw_new (k+1) (k+1)) atTop (𝓝 glim))
     ∧ (∀ i ≤ k, cw_new i = cw i) ∧ (∀ n, ∀ m < n, (cw_new (k+1) n).weights m = 0) := by
-  let gtilde := fun n ↦ (convexWeightsConvolution cw k n).sum (fun m cwm ↦ cwm • (x (k+1) m))
+  let gtilde := fun n ↦ (iteratedBind cw k n).sum (fun m cwm ↦ cwm • (x (k+1) m))
   have gtilde_bound : ∃ M, ∀ n, ‖gtilde n‖ ≤ M := convex_combination_bounded (hx (k+1))
   obtain ⟨g_step, gstep_conv, glim, hglim⟩ := komlos_norm (gtilde_bound)
   obtain ⟨cw_step, ⟨hzero, g_step_eq_gtilde⟩⟩ : ∃ w : ℕ → StdSimplex ℝ ℕ,
@@ -202,13 +245,13 @@ lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n,
       (fun n ↦ (Classical.choose_spec (convex_weights_of_mem_convexTail_reindexed gstep_conv n)).1)
   let cw_new := Function.update cw (k+1) cw_step
   have g_step_eq (n : ℕ) : g_step n =
-    (convexWeightsConvolution cw_new (k + 1) n).sum (fun m cwm ↦ cwm • x (k+1) m) := by
-    have aux : (convexWeightsConvolution cw_new (k + 1) n)
-      = (convexWeightsMul (cw_step n) (convexWeightsConvolution cw k)) := by
+    (iteratedBind cw_new (k + 1) n).sum (fun m cwm ↦ cwm • x (k+1) m) := by
+    have aux : (iteratedBind cw_new (k + 1) n)
+      = (bind (cw_step n) (iteratedBind cw k)) := by
       unfold cw_new
-      rw [convexWeightsConvolution, Function.update_self, convexWeightsConvolution_cong]
+      rw [iteratedBind, Function.update_self, iteratedBind_cong]
       grind
-    rw [g_step_eq_gtilde n, aux, ← convexWeightsMul_sum_smul]
+    rw [g_step_eq_gtilde n, aux, ← bind_sum_smul]
   use cw_new
   refine ⟨?_, by grind, ?_⟩
   · use glim; exact Tendsto.congr g_step_eq hglim
diff --git a/blueprint/src/chapters/doob_meyer.tex b/blueprint/src/chapters/doob_meyer.tex
index 2de4a656..dbef2d91 100644
--- a/blueprint/src/chapters/doob_meyer.tex
+++ b/blueprint/src/chapters/doob_meyer.tex
@@ -93,7 +93,7 @@ \section{Komlòs Lemma}
 By convex weights on $\mathbb{N}$, we mean a sequence of non-negative real numbers $(a_n)_{n \in \mathbb{N}}$ with finitely many nonzero entries such that $\sum_{n \in \mathbb{N}} a_n = 1$.
 
 \begin{definition}\label{def:convex_weights_product}
-  \lean{convexWeightsMul} \leanok
+  \lean{StdSimplex.bind} \leanok
 If $(a_m)_{m \in \mathbb{N}}$ are convex weights and $(b^n_m)_{n,m \in \mathbb{N}}$ is such that for all $n$, the $(b^n_m)$ are convex weights, then we denote by $(a_\cdot) * (b^\cdot_\cdot)$ the convex weights defined by $((a_\cdot) * (b^\cdot_\cdot))_m = \sum_{k} a_k b^k_m$.
 \end{definition}
 

From 8dd4517de2b5200dd9d376459149f7934ff61496 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Thu, 30 Apr 2026 12:49:32 +0100
Subject: [PATCH 33/37] Apply suggestions from code review
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Rémy Degenne <remydegenne@gmail.com>
---
 .../StochasticIntegral/ConvexWeights.lean        |  8 ++++----
 BrownianMotion/StochasticIntegral/Komlos.lean    | 16 ++++++----------
 2 files changed, 10 insertions(+), 14 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
index b4d348f2..b9dca7c8 100644
--- a/BrownianMotion/StochasticIntegral/ConvexWeights.lean
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -33,15 +33,15 @@ lemma bind_single (i : M) : bind (single i) b = b i := by simp [bind, join]
 @[simp]
 lemma bind_const (c : StdSimplex R N) : bind a (fun _ ↦ c) = c := by simp [bind, join]
 
-lemma bind_weights :
-  (bind a b).weights = (fun m ↦ ∑ k ∈ a.support, a.weights k * (b k).weights m) := by
+lemma weights_bind :
+    (bind a b).weights = (fun m ↦ ∑ k ∈ a.support, a.weights k * (b k).weights m) := by
   ext m
   rw [bind, join, map]
   simp only [Finsupp.sum_apply]
   rw [Finsupp.sum_mapDomain_index (fun _ => by simp) (fun _ _ _ => by simp [add_mul])]
   simp [Finsupp.sum]
 
-lemma support_subset_bind_support {a : StdSimplex R M} (b : M → StdSimplex R N)
+lemma support_subset_support_bind {a : StdSimplex R M} (b : M → StdSimplex R N)
     {i : M} (hi : i ∈ a.support) :
     (b i).support ⊆ (bind a b).support := by
   intro m hm
@@ -61,7 +61,7 @@ def iteratedBind (cw : ℕ → ℕ → StdSimplex R ℕ) : ℕ → ℕ → StdSi
   | 0 => cw 0
   | k + 1 => fun n ↦ bind (cw (k + 1) n) (iteratedBind cw k)
 
-lemma iteratedBind_cong {cw1 cw2 : ℕ → ℕ → StdSimplex R ℕ} {k : ℕ}
+lemma iteratedBind_congr {cw1 cw2 : ℕ → ℕ → StdSimplex R ℕ} {k : ℕ}
     (h : ∀ i ≤ k, cw1 i = cw2 i) :
     iteratedBind cw1 k = iteratedBind cw2 k := by
   induction k with
diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 45786b05..529e52b6 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -121,7 +121,7 @@ lemma komlos_norm [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
   tauto
 
 
-lemma stdSimplex_of_mem_convexHull {M ι : Type*} [AddCommGroup E] [Field M] [LinearOrder M]
+lemma exists_stdSimplex_of_mem_convexHull {M ι : Type*} [AddCommGroup E] [Field M] [LinearOrder M]
     [IsStrictOrderedRing M] [Module M E] {s : ι → E} {x : E}
     (hx : x ∈ convexHull M (Set.range s)) :
     ∃ (w : StdSimplex M ι), x = w.sum (fun i wi ↦ wi • s i) := by
@@ -147,11 +147,8 @@ noncomputable section
 variable [NormedAddCommGroup E] [InnerProductSpace ℝ E]
 
 lemma convex_combination_bounded {x : ℕ → E}
-    {w : ℕ → StdSimplex ℝ ℕ} (hx : ∃ M : ℝ, ∀ n, ‖x n‖ ≤ M) :
-    ∃ M, ∀ n, ‖(w n).sum (fun i wi ↦ wi • x i)‖ ≤ M := by
-  obtain ⟨M, hM⟩ := hx
-  use M
-  intro n
+    {w : ℕ → StdSimplex ℝ ℕ} {M : ℝ} (hx : ∀ n, ‖x n‖ ≤ M) (n : ℕ) :
+    ‖(w n).sum (fun i wi ↦ wi • x i)‖ ≤ M := by
   have h_sum : ‖(w n).sum (fun i wi => wi • x i)‖ ≤ ∑ i ∈ (w n).support, ((w n).weights i) * ‖x i‖
     := by
     convert norm_sum_le _ _
@@ -170,7 +167,7 @@ established at each stage of the Komlós construction. -/
 def komlosFormula (x : ℕ → ℕ → E) (cw : ℕ → ℕ → StdSimplex ℝ ℕ) (k i n : ℕ) : E :=
   (StdSimplex.iteratedBind cw k n).sum (fun m cwm ↦ cwm • x i m)
 
-lemma komlosFormula_cong (x : ℕ → ℕ → E) {cw1 : ℕ → ℕ → StdSimplex ℝ ℕ}
+lemma komlosFormula_congr (x : ℕ → ℕ → E) {cw1 : ℕ → ℕ → StdSimplex ℝ ℕ}
   {cw2 : ℕ → ℕ → StdSimplex ℝ ℕ} {k : ℕ} (h : ∀ k' ≤ k, cw1 k' = cw2 k') :
   komlosFormula x cw1 k = komlosFormula x cw2 k := by
   unfold komlosFormula; rw [StdSimplex.iteratedBind_cong]
@@ -183,9 +180,8 @@ every `y n` can be written as a convex combination of elements `x k` with `k ≥
 def convexTail (x : ℕ → E) : Set (ℕ → E) :=
   { y | ∀ n, y n ∈ convexHull ℝ (Set.range (fun m ↦ x (n + m))) }
 
-lemma convex_weights_of_mem_convexTail_reindexed {x g : ℕ → E} (hg : g ∈ convexTail x) :
-  ∀ n, ∃ w : StdSimplex ℝ ℕ, g n = w.sum (fun i wi ↦ wi • x i) ∧ ∀ m < n, w.weights m = 0 := by
-  intro n
+lemma exists_stdSimplex_of_mem_convexTail_reindexed {x g : ℕ → E} (hg : g ∈ convexTail x) (n : ℕ) :
+  ∃ w : StdSimplex ℝ ℕ, g n = w.sum (fun i wi ↦ wi • x i) ∧ ∀ m < n, w.weights m = 0 := by
   obtain ⟨w₀, hw₀⟩ := stdSimplex_of_mem_convexHull (hg n)
   let weights := Finsupp.embDomain ⟨fun i ↦ n + i, add_right_injective n⟩ w₀.weights
   have nonneg (i : ℕ) : 0 ≤ weights i := by

From da5fad4067933ad66e86a8a1251bcde1a7c4b022 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Thu, 30 Apr 2026 13:03:21 +0100
Subject: [PATCH 34/37] fix: repair proofs broken by accepting quick changes

---
 .../StochasticIntegral/ConvexWeights.lean     |  9 ++---
 BrownianMotion/StochasticIntegral/Komlos.lean | 34 ++++++++++---------
 2 files changed, 23 insertions(+), 20 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/ConvexWeights.lean b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
index b9dca7c8..cd1737db 100644
--- a/BrownianMotion/StochasticIntegral/ConvexWeights.lean
+++ b/BrownianMotion/StochasticIntegral/ConvexWeights.lean
@@ -7,7 +7,7 @@ public import Mathlib.LinearAlgebra.ConvexSpace
 # Lemmas on StdSimplex
 -/
 
-@[expose] public noncomputable section
+@[expose] public section
 
 variable {R : Type*} [PartialOrder R] [Semiring R] {M N P : Type*}
 
@@ -23,7 +23,8 @@ variable [IsStrictOrderedRing R]
 /-- Given convex weights `a : StdSimplex R ι` and a family of convex weights
 `b : ι → StdSimplex R ι'`, `StdSimplex.bind a b` is the convex combination of the `b k`, weighted
 by `a`, defined as monadic bind. -/
-def bind (a : StdSimplex R M) (b : M → StdSimplex R N) : StdSimplex R N := (a.map b).join
+noncomputable def bind (a : StdSimplex R M) (b : M → StdSimplex R N) : StdSimplex R N :=
+  (a.map b).join
 
 variable (a : StdSimplex R M) (b : M → StdSimplex R N)
 
@@ -51,13 +52,13 @@ lemma support_subset_support_bind {a : StdSimplex R M} (b : M → StdSimplex R N
     exact mul_nonneg (a.nonneg k) ((b k).nonneg m)
   have hsum_pos : 0 < ∑ k ∈ a.support, a.weights k * (b k).weights m :=
     lt_of_lt_of_le hpos (Finset.single_le_sum hnonneg hi)
-  rw [Finsupp.mem_support_iff, bind_weights]
+  rw [Finsupp.mem_support_iff, weights_bind]
   positivity
 
 /-- Given a doubly-indexed family of convex weights `cw : ℕ → ℕ → StdSimplex R ℕ`,
 `iteratedBind cw k n` is the iterated convex multiplication obtained by combining
 the weights `cw 0 n, cw 1 n, …, cw k n` via `StdSimplex.bind`. -/
-def iteratedBind (cw : ℕ → ℕ → StdSimplex R ℕ) : ℕ → ℕ → StdSimplex R ℕ
+noncomputable def iteratedBind (cw : ℕ → ℕ → StdSimplex R ℕ) : ℕ → ℕ → StdSimplex R ℕ
   | 0 => cw 0
   | k + 1 => fun n ↦ bind (cw (k + 1) n) (iteratedBind cw k)
 
diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 529e52b6..3819a324 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -143,7 +143,7 @@ lemma exists_stdSimplex_of_mem_convexHull {M ι : Type*} [AddCommGroup E] [Field
     simp [aux, hw₁, hw₂]
   exact hx
 
-noncomputable section
+section
 variable [NormedAddCommGroup E] [InnerProductSpace ℝ E]
 
 lemma convex_combination_bounded {x : ℕ → E}
@@ -154,17 +154,17 @@ lemma convex_combination_bounded {x : ℕ → E}
     convert norm_sum_le _ _
     simp [norm_smul, abs_of_nonneg ((w _).nonneg _)]
   refine le_trans h_sum (le_trans (Finset.sum_le_sum fun i hi =>
-    mul_le_mul_of_nonneg_left (hM i) ((w n).nonneg i)) ?_)
+    mul_le_mul_of_nonneg_left (hx i) ((w n).nonneg i)) ?_)
   rw [← Finset.sum_mul _ _ _]
   have bound : (∑ i ∈ (w n).support, (w n).weights i) ≤ 1 := by
     rw [← (w n).total, Finsupp.sum]
   refine mul_le_of_le_one_left ?_ bound
-  exact le_trans (norm_nonneg (x 0)) (hM 0)
+  exact le_trans (norm_nonneg (x 0)) (hx 0)
 
 /-- `komlosFormula x cw k n` is the convex combination of the stage-`k` vectors `x k m`,
 weighted by `iteratedBindSimplex cw k n`. It is the sequence whose convergence is
 established at each stage of the Komlós construction. -/
-def komlosFormula (x : ℕ → ℕ → E) (cw : ℕ → ℕ → StdSimplex ℝ ℕ) (k i n : ℕ) : E :=
+noncomputable def komlosFormula (x : ℕ → ℕ → E) (cw : ℕ → ℕ → StdSimplex ℝ ℕ) (k i n : ℕ) : E :=
   (StdSimplex.iteratedBind cw k n).sum (fun m cwm ↦ cwm • x i m)
 
 lemma komlosFormula_congr (x : ℕ → ℕ → E) {cw1 : ℕ → ℕ → StdSimplex ℝ ℕ}
@@ -182,7 +182,7 @@ def convexTail (x : ℕ → E) : Set (ℕ → E) :=
 
 lemma exists_stdSimplex_of_mem_convexTail_reindexed {x g : ℕ → E} (hg : g ∈ convexTail x) (n : ℕ) :
   ∃ w : StdSimplex ℝ ℕ, g n = w.sum (fun i wi ↦ wi • x i) ∧ ∀ m < n, w.weights m = 0 := by
-  obtain ⟨w₀, hw₀⟩ := stdSimplex_of_mem_convexHull (hg n)
+  obtain ⟨w₀, hw₀⟩ := exists_stdSimplex_of_mem_convexHull (hg n)
   let weights := Finsupp.embDomain ⟨fun i ↦ n + i, add_right_injective n⟩ w₀.weights
   have nonneg (i : ℕ) : 0 ≤ weights i := by
     unfold weights
@@ -211,17 +211,17 @@ lemma komlos_base {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n,
     ∃ (cw : ℕ → ℕ → StdSimplex ℝ ℕ), (∃ glim : E,
     Tendsto (komlosFormula x cw 0 0) atTop (𝓝 glim)) ∧ ∀ n, ∀ m < n, (cw 0 n).weights m = 0 := by
   obtain ⟨g, h_convex, lim, hlim⟩ := komlos_norm (hx 0)
-  let cw (n : ℕ) := Classical.choose (convex_weights_of_mem_convexTail_reindexed h_convex n)
+  let cw (n : ℕ) := Classical.choose (exists_stdSimplex_of_mem_convexTail_reindexed h_convex n)
   use (fun k ↦ cw)
   have hg (n : ℕ) : g n = (cw n).weights.sum (fun m cwm ↦ cwm • x 0 m) := by
-    exact (Classical.choose_spec (convex_weights_of_mem_convexTail_reindexed h_convex n)).1
+    exact (Classical.choose_spec (exists_stdSimplex_of_mem_convexTail_reindexed h_convex n)).1
   unfold komlosFormula
   constructor
   · use lim
     apply Tendsto.congr hg
     exact hlim
   · intro n
-    exact (Classical.choose_spec (convex_weights_of_mem_convexTail_reindexed h_convex n)).2
+    exact (Classical.choose_spec (exists_stdSimplex_of_mem_convexTail_reindexed h_convex n)).2
 
 open StdSimplex
 
@@ -231,14 +231,15 @@ lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n,
     (∃ glim : E, Tendsto (komlosFormula x cw_new (k+1) (k+1)) atTop (𝓝 glim))
     ∧ (∀ i ≤ k, cw_new i = cw i) ∧ (∀ n, ∀ m < n, (cw_new (k+1) n).weights m = 0) := by
   let gtilde := fun n ↦ (iteratedBind cw k n).sum (fun m cwm ↦ cwm • (x (k+1) m))
-  have gtilde_bound : ∃ M, ∀ n, ‖gtilde n‖ ≤ M := convex_combination_bounded (hx (k+1))
+  obtain ⟨M, hM⟩ := hx (k+1)
+  have gtilde_bound : ∃ M, ∀ n, ‖gtilde n‖ ≤ M := ⟨M, convex_combination_bounded hM⟩
   obtain ⟨g_step, gstep_conv, glim, hglim⟩ := komlos_norm (gtilde_bound)
   obtain ⟨cw_step, ⟨hzero, g_step_eq_gtilde⟩⟩ : ∃ w : ℕ → StdSimplex ℝ ℕ,
     (∀ n, ∀ m < n, (w n).weights m = 0) ∧ ∀ n, g_step n = (w n).sum (fun i wi ↦ wi • gtilde i) := by
-    refine ⟨fun n ↦ Classical.choose (convex_weights_of_mem_convexTail_reindexed gstep_conv n), ?_⟩
-    exact And.intro
-      (fun n ↦ (Classical.choose_spec (convex_weights_of_mem_convexTail_reindexed gstep_conv n)).2)
-      (fun n ↦ (Classical.choose_spec (convex_weights_of_mem_convexTail_reindexed gstep_conv n)).1)
+    let existence (n : ℕ) := exists_stdSimplex_of_mem_convexTail_reindexed gstep_conv n
+    exact ⟨fun n ↦ Classical.choose (existence n), And.intro
+      (fun n ↦ (Classical.choose_spec (existence n)).2)
+      (fun n ↦ (Classical.choose_spec (existence n)).1)⟩
   let cw_new := Function.update cw (k+1) cw_step
   have g_step_eq (n : ℕ) : g_step n =
     (iteratedBind cw_new (k + 1) n).sum (fun m cwm ↦ cwm • x (k+1) m) := by
@@ -255,8 +256,9 @@ lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n,
     simp only [Function.update_self]
     exact hzero
 
-private def komlosStage {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) (stage : ℕ) :
-  { w : ℕ → ℕ → StdSimplex ℝ ℕ // ∀ k ≤ stage, ∀ n, ∀ m < n, (w k n).weights m = 0 } :=
+private noncomputable def komlosStage {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M)
+    (stage : ℕ) :
+    { w : ℕ → ℕ → StdSimplex ℝ ℕ // ∀ k ≤ stage, ∀ n, ∀ m < n, (w k n).weights m = 0 } :=
   match stage with
   | 0 => by
       use Classical.choose (komlos_base hx)
@@ -306,7 +308,7 @@ lemma komlos_convex_weights {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : 
     ∧ (∀ k n, ∀ m < n, (cw k n).weights m = 0) := by
   let cw (k : ℕ) : ℕ → StdSimplex ℝ ℕ := (komlosStage hx k).val k
   have transfer (k : ℕ) : komlosFormula x cw k = komlosFormula x (komlosStage hx k) k :=
-    komlosFormula_cong x (fun i hi ↦ komlosStage_cong hx i k hi)
+    komlosFormula_congr x (fun i hi ↦ komlosStage_cong hx i k hi)
   use cw
   constructor
   · intro k; simp [transfer k, komlosStage_lim hx k]

From 9c67464dad89b89f96ef8e1c5c3860d57b839398 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Thu, 30 Apr 2026 14:32:00 +0100
Subject: [PATCH 35/37] chore: import new file in BrownianMotion.lean

---
 BrownianMotion.lean                           | 3 ++-
 BrownianMotion/StochasticIntegral/Komlos.lean | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/BrownianMotion.lean b/BrownianMotion.lean
index c9f7ce6c..58958f91 100644
--- a/BrownianMotion.lean
+++ b/BrownianMotion.lean
@@ -1,4 +1,4 @@
-module
+module  -- shake: keep-all
 
 public import BrownianMotion.Auxiliary.Adapted
 public import BrownianMotion.Auxiliary.Algebra
@@ -47,6 +47,7 @@ public import BrownianMotion.StochasticIntegral.ApproxSeq
 public import BrownianMotion.StochasticIntegral.Cadlag
 public import BrownianMotion.StochasticIntegral.Centering
 public import BrownianMotion.StochasticIntegral.ClassD
+public import BrownianMotion.StochasticIntegral.ConvexWeights
 public import BrownianMotion.StochasticIntegral.DoobLp
 public import BrownianMotion.StochasticIntegral.DoobMeyer
 public import BrownianMotion.StochasticIntegral.Komlos
diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 3819a324..8d3af412 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -170,7 +170,7 @@ noncomputable def komlosFormula (x : ℕ → ℕ → E) (cw : ℕ → ℕ → St
 lemma komlosFormula_congr (x : ℕ → ℕ → E) {cw1 : ℕ → ℕ → StdSimplex ℝ ℕ}
   {cw2 : ℕ → ℕ → StdSimplex ℝ ℕ} {k : ℕ} (h : ∀ k' ≤ k, cw1 k' = cw2 k') :
   komlosFormula x cw1 k = komlosFormula x cw2 k := by
-  unfold komlosFormula; rw [StdSimplex.iteratedBind_cong]
+  unfold komlosFormula; rw [StdSimplex.iteratedBind_congr]
   exact h
 
 /--
@@ -246,7 +246,7 @@ lemma komlos_step {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n,
     have aux : (iteratedBind cw_new (k + 1) n)
       = (bind (cw_step n) (iteratedBind cw k)) := by
       unfold cw_new
-      rw [iteratedBind, Function.update_self, iteratedBind_cong]
+      rw [iteratedBind, Function.update_self, iteratedBind_congr]
       grind
     rw [g_step_eq_gtilde n, aux, ← bind_sum_smul]
   use cw_new

From c33c1ad2f0688ce9127f5b6ce6cfad440823c4d6 Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Fri, 1 May 2026 09:08:04 +0100
Subject: [PATCH 36/37] refactor(Komlos): generalize komlos_convex to ordered
 semifield
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Makes the lemma reusable for the ENNReal version of the Komlós lemma
---
 BrownianMotion/StochasticIntegral/Komlos.lean | 35 ++++++++++---------
 1 file changed, 19 insertions(+), 16 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 8d3af412..705a9262 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -23,40 +23,41 @@ variable {E Ω : Type*} {mΩ : MeasurableSpace Ω}
 open Filter MeasureTheory
 open scoped Topology NNReal ENNReal
 
-lemma komlos_convex [AddCommMonoid E] [Module ℝ E]
+lemma komlos_convex (R : Type*) [Semifield R] [LinearOrder R] [IsStrictOrderedRing R]
+  [AddCommMonoid E] [Module R E]
   {f : ℕ → E} {φ : E → ℝ} (hφ_nonneg : 0 ≤ φ)
   (hφ_bdd : ∃ M : ℝ, ∀ n, φ (f n) ≤ M) :
-  ∃ g : ℕ → E, (∀ n, g n ∈ convexHull ℝ (Set.range fun m ↦ f (n + m))) ∧
+  ∃ g : ℕ → E, (∀ n, g n ∈ convexHull R (Set.range fun m ↦ f (n + m))) ∧
     ∀ δ > 0, ∃ N, ∀ n m, N ≤ n → N ≤ m →
-      2⁻¹ * φ (g n) + 2⁻¹ * φ (g m) - φ ((2 : ℝ)⁻¹ • (g n + g m)) < δ := by
+      2⁻¹ * φ (g n) + 2⁻¹ * φ (g m) - φ ((2 : R)⁻¹ • (g n + g m)) < δ := by
   obtain ⟨M, hM⟩ := hφ_bdd
-  let r : ℕ → ℝ := fun n ↦ sInf (Set.image φ (convexHull ℝ (Set.range (fun m ↦ f (n + m)))))
+  let r : ℕ → ℝ := fun n ↦ sInf (Set.image φ (convexHull R (Set.range (fun m ↦ f (n + m)))))
   have hr_nondec n : r n ≤ r (n + 1) := by
     apply_rules [csInf_le_csInf]
     · exact ⟨0, Set.forall_mem_image.2 fun x hx ↦ hφ_nonneg x⟩
-    · exact ⟨_, ⟨ _, subset_convexHull ℝ _ ⟨0, rfl⟩, rfl⟩⟩
-    · refine Set.image_mono <| convexHull_min ?_ (convex_convexHull ℝ _)
-      rintro _ ⟨m, rfl⟩; exact subset_convexHull ℝ _ ⟨m + 1, by simp [add_comm, add_left_comm]⟩
+    · exact ⟨_, ⟨ _, subset_convexHull R _ ⟨0, rfl⟩, rfl⟩⟩
+    · refine Set.image_mono <| convexHull_min ?_ (convex_convexHull R _)
+      rintro _ ⟨m, rfl⟩; exact subset_convexHull R _ ⟨m + 1, by simp [add_comm, add_left_comm]⟩
   obtain ⟨A, hA⟩ : ∃ A, Filter.Tendsto r Filter.atTop (nhds A) := by
     refine ⟨_, tendsto_atTop_ciSup (monotone_nat_of_le_succ hr_nondec) ?_⟩
     exact ⟨M, Set.forall_mem_range.mpr fun n ↦ csInf_le
       ⟨0, Set.forall_mem_image.mpr fun x hx ↦ hφ_nonneg x⟩
-        (Set.mem_image_of_mem _ <| subset_convexHull ℝ _
+        (Set.mem_image_of_mem _ <| subset_convexHull R _
           <| Set.mem_range_self 0) |> le_trans <| by simpa using hM n⟩
   obtain ⟨g, hg⟩ :
-      ∃ g : ℕ → E, (∀ n, g n ∈ convexHull ℝ (Set.range (fun m ↦ f (n + m))))
+      ∃ g : ℕ → E, (∀ n, g n ∈ convexHull R (Set.range (fun m ↦ f (n + m))))
           ∧ (∀ n, φ (g n) ≤ A + 1 / (n + 1)) := by
     have h_exists_g :
-        ∀ n, ∃ g ∈ convexHull ℝ (Set.range (fun m ↦ f (n + m))), φ g ≤ A + 1 / (n + 1) := by
+        ∀ n, ∃ g ∈ convexHull R (Set.range (fun m ↦ f (n + m))), φ g ≤ A + 1 / (n + 1) := by
       intro n
       have h_exists_g :
-          ∃ g ∈ convexHull ℝ (Set.range (fun m ↦ f (n + m))), φ g < A + 1 / (n + 1) := by
+          ∃ g ∈ convexHull R (Set.range (fun m ↦ f (n + m))), φ g < A + 1 / (n + 1) := by
         have h_exists_g : r n < A + 1 / (n + 1) := by
           exact lt_add_of_le_of_pos (le_of_tendsto_of_tendsto tendsto_const_nhds hA
             (Filter.eventually_atTop.2 ⟨n, fun m hm ↦ by
               induction hm <;> [tauto; linarith [hr_nondec ‹_›]]⟩)) (by positivity)
         contrapose! h_exists_g
-        exact le_csInf ⟨ _, Set.mem_image_of_mem _ <| subset_convexHull ℝ _
+        exact le_csInf ⟨ _, Set.mem_image_of_mem _ <| subset_convexHull R _
           <| Set.mem_range_self 0 ⟩ fun x hx ↦ by
             rcases hx with ⟨ g, hg, rfl ⟩; exact h_exists_g g hg
       exact ⟨h_exists_g.choose, h_exists_g.choose_spec.1, le_of_lt h_exists_g.choose_spec.2⟩
@@ -70,16 +71,18 @@ lemma komlos_convex [AddCommMonoid E] [Module ℝ E]
     exact ⟨N + ⌈ε⁻¹⌉₊, by linarith [abs_lt.mp (hN (N + ⌈ε⁻¹⌉₊) (by grind))], by
       simpa using inv_le_of_inv_le₀ εpos (by linarith [Nat.le_ceil (ε⁻¹)])⟩
   refine ⟨N, fun n m hn hm ↦ ?_⟩
-  have h_convex : φ ((1 / 2 : ℝ) • (g n + g m)) ≥ A - ε := by
+  have h_convex : φ ((1 / 2 : R) • (g n + g m)) ≥ A - ε := by
     have h_convex :
-        (1 / 2 : ℝ) • (g n + g m) ∈ convexHull ℝ (Set.range (fun m ↦ f (N + m))) := by
+        (1 / 2 : R) • (g n + g m) ∈ convexHull R (Set.range (fun m ↦ f (N + m))) := by
       simp only [one_div, gt_iff_lt, ge_iff_le, tsub_le_iff_right, smul_add] at *
-      refine convex_convexHull ℝ _ ?_ ?_ ?_ ?_ ?_ <;> norm_num
+      refine convex_convexHull R _ ?_ ?_ ?_ ?_ ?_ <;> norm_num
       · refine convexHull_mono (Set.range_subset_iff.2 fun m ↦ ?_) (hg.1 n)
         exact ⟨m + (n - N), by grind⟩
       · refine convexHull_mono ?_ (hg.1 m)
         exact Set.range_subset_iff.2 fun k ↦ ⟨k + (m - N), by
           simp [show N + (k + (m - N)) = m + k by grind]⟩
+      · positivity
+      · positivity
     refine le_trans hN.1 ?_
     exact csInf_le ⟨0, Set.forall_mem_image.2 fun x hx ↦ hφ_nonneg _⟩ ⟨_, h_convex, rfl⟩
   norm_num at *
@@ -97,7 +100,7 @@ lemma komlos_norm [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpac
   have φ_bdd : ∃ M : ℝ, ∀ n, φ (f n) ≤ M := by
     rcases h_bdd with ⟨M, hM⟩
     exact ⟨M ^ 2, fun n ↦ pow_le_pow_left₀ (norm_nonneg _) (hM n) 2⟩
-  rcases komlos_convex φ_nonneg φ_bdd with ⟨g, hg, h⟩
+  rcases komlos_convex (R := ℝ) φ_nonneg φ_bdd with ⟨g, hg, h⟩
   use g
   have parallelogram_identity (x y : E) :
       2⁻¹ * ‖x‖ ^ 2 + 2⁻¹ * ‖y‖ ^ 2 - ‖(2 : ℝ)⁻¹ • (x + y)‖ ^ 2 = ‖y - x‖ ^ 2 / 4 := by

From 4b4a72c5ef0048f3cf804407886b9c782c8b5a0d Mon Sep 17 00:00:00 2001
From: Jonas Bayer <jonas.bayer999@gmail.com>
Date: Fri, 1 May 2026 10:49:41 +0100
Subject: [PATCH 37/37] refactor: implement review suggestions

---
 BrownianMotion/StochasticIntegral/Komlos.lean | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/BrownianMotion/StochasticIntegral/Komlos.lean b/BrownianMotion/StochasticIntegral/Komlos.lean
index 705a9262..c49f356e 100644
--- a/BrownianMotion/StochasticIntegral/Komlos.lean
+++ b/BrownianMotion/StochasticIntegral/Komlos.lean
@@ -287,14 +287,14 @@ private lemma komlosStage_lim {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M :
   | zero => exact (Classical.choose_spec (komlos_base hx)).1
   | succ k _ => exact Classical.choose_spec (komlos_step hx k (komlosStage hx k)) |>.1
 
-private lemma komlosStage_cong_succ {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M)
-  (k : ℕ) : ∀ i ≤ k, (komlosStage hx k).val i = (komlosStage hx (k+1)).val i := by
-  intro i hi
+private lemma komlosStage_congr_succ {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M)
+    (k i : ℕ) (hi : i ≤ k) :
+    (komlosStage hx k).val i = (komlosStage hx (k+1)).val i := by
   let aux := komlos_step hx k (komlosStage hx k)
   let ⟨_, aux2, _⟩ := Classical.choose_spec aux
   exact Eq.symm (aux2 i hi)
 
-private lemma komlosStage_cong {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M)
+private lemma komlosStage_congr {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M)
     (i k : ℕ) (hi : i ≤ k) : (komlosStage hx i).val i = (komlosStage hx k).val i := by
   let n := k-i
   suffices (komlosStage hx i).val i = (komlosStage hx (i+n)).val i by
@@ -303,7 +303,7 @@ private lemma komlosStage_cong {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M
   | zero => rfl
   | succ n hn =>
   rw [← add_assoc, hn]
-  apply komlosStage_cong_succ hx (i+n) i (by grind)
+  apply komlosStage_congr_succ hx (i+n) i (by grind)
 
 lemma komlos_convex_weights {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :
     ∃ (cw : ℕ → ℕ → StdSimplex ℝ ℕ),
@@ -311,7 +311,7 @@ lemma komlos_convex_weights {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : 
     ∧ (∀ k n, ∀ m < n, (cw k n).weights m = 0) := by
   let cw (k : ℕ) : ℕ → StdSimplex ℝ ℕ := (komlosStage hx k).val k
   have transfer (k : ℕ) : komlosFormula x cw k = komlosFormula x (komlosStage hx k) k :=
-    komlosFormula_congr x (fun i hi ↦ komlosStage_cong hx i k hi)
+    komlosFormula_congr x (fun i hi ↦ komlosStage_congr hx i k hi)
   use cw
   constructor
   · intro k; simp [transfer k, komlosStage_lim hx k]
@@ -337,7 +337,7 @@ lemma TendstoUniformly_convexTail {x : ℕ → E} {xlim : E} (hx : Tendsto x atT
 
 omit [CompleteSpace E] in
 lemma Tendsto_convexTail {x : ℕ → E} {xlim : E} (hx : Tendsto x atTop (𝓝 xlim)) :
-  ∀ y ∈ convexTail x, Tendsto y atTop (𝓝 xlim) := by
+    ∀ y ∈ convexTail x, Tendsto y atTop (𝓝 xlim) := by
   intro y hy
   exact TendstoUniformly.tendsto_at (TendstoUniformly_convexTail hx) ⟨y, hy⟩
 
@@ -348,8 +348,8 @@ lemma komlos_uniform_convergence
     ∀ i, TendstoUniformly (fun k ↦ komlosFormula x cw k i) lim atTop
     -- maybe too strong, the blueprint statement limits to k ≥ i
      := by
-    intro i
-    sorry
+  intro i
+  sorry
 
 lemma komlos_convex_weights_diagonal
     {x : ℕ → ℕ → E} (hx : ∀ i : ℕ, ∃ M : ℝ, ∀ n, ‖x i n‖ ≤ M) :