Documentation

Atlas.FourierAnalysis.code.BrownianMotion

theorem GaussianLinearTransform.concrete_converse_covariance_entries {m : } (μ_Y μ_Z : MeasureTheory.Measure (EuclideanSpace (Fin m))) [ProbabilityTheory.IsGaussian μ_Y] [ProbabilityTheory.IsGaussian μ_Z] (hmY : (x : EuclideanSpace (Fin m)), id x μ_Y = 0) (hmZ : (x : EuclideanSpace (Fin m)), id x μ_Z = 0) (hcov : ∀ (i k : Fin m), ProbabilityTheory.covariance (fun (x : EuclideanSpace (Fin m)) => x.ofLp i) (fun (x : EuclideanSpace (Fin m)) => x.ofLp k) μ_Y = ProbabilityTheory.covariance (fun (x : EuclideanSpace (Fin m)) => x.ofLp i) (fun (x : EuclideanSpace (Fin m)) => x.ofLp k) μ_Z) :
μ_Y = μ_Z
noncomputable def BetaIntegralBound.R_beta (β : ) (m : ) :
Instances For
    theorem BetaIntegralBound.Gamma_succ_le_two (β : ) (hβ0 : 0 β) (hβ2 : β 2) :
    Real.Gamma (β + 1) 2
    theorem BetaIntegralBound.beta_integral_bound (m : ) (hm : 1 m) (β : ) (hβ0 : 0 β) (hβ2 : β 2) :
    R_beta β m 100 * m ^ (-(1 + β))
    Instances For
      Instances For
        theorem BrownianCharacterization.isGaussianProcess_uncorrelated_iIndepFun {Ω : Type u_1} {ι : Type u_2} [MeasurableSpace Ω] [Fintype ι] {X : ιΩ} {P : MeasureTheory.Measure Ω} (hgauss : ProbabilityTheory.IsGaussianProcess X P) (huncorr : ∀ (i j : ι), i j (ω : Ω), X i ω * X j ω P = ( (ω : Ω), X i ω P) * (ω : Ω), X j ω P) :
        noncomputable def BrownianCharacterization.partialSumCLM {α : Type u_1} [Fintype α] (n : ) (pos : αFin (n + 1)) :
        (Fin n) →L[] α
        Instances For
          theorem BrownianCharacterization.fin_telescope_sum {n : } (f : Fin (n + 1)) (hf0 : f 0 = 0) (j : Fin (n + 1)) :
          f j = k : Fin n with k < j, (f k.succ - f k.castSucc)
          theorem BrownianCharacterization.indepGaussInc_covariance_le {Ω : Type u_1} [MeasurableSpace Ω] {B : NNRealΩ} {P : MeasureTheory.Measure Ω} (h : HasIndependentGaussianIncrements B P) (s t : NNReal) (hst : s t) :
          (ω : Ω), B s ω * B t ω P = s
          theorem BrownianCharacterization.indepGaussInc_covariance {Ω : Type u_1} [MeasurableSpace Ω] {B : NNRealΩ} {P : MeasureTheory.Measure Ω} (h : HasIndependentGaussianIncrements B P) (s t : NNReal) :
          (ω : Ω), B s ω * B t ω P = min s t
          theorem BrownianCharacterization.brownianChar_indep_increments {Ω : Type u_1} [MeasurableSpace Ω] {B : NNRealΩ} {P : MeasureTheory.Measure Ω} (h : HasBrownianCharacterization B P) (n : ) (t : Fin (n + 1)NNReal) (ht : StrictMono t) (ht0 : t 0 = 0) :
          ProbabilityTheory.iIndepFun (fun (j : Fin n) (ω : Ω) => B (t j.succ) ω - B (t j.castSucc) ω) P
          theorem BrownianCharacterization.brownianChar_gaussian_increments {Ω : Type u_1} [MeasurableSpace Ω] {B : NNRealΩ} {P : MeasureTheory.Measure Ω} (h : HasBrownianCharacterization B P) (n : ) (t : Fin (n + 1)NNReal) (ht : StrictMono t) (ht0 : t 0 = 0) (j : Fin n) :
          ProbabilityTheory.HasLaw (fun (ω : Ω) => B (t j.succ) ω - B (t j.castSucc) ω) (ProbabilityTheory.gaussianReal 0 (t j.succ - t j.castSucc)) P
          structure GradientIntegrability.IsIIDStdGaussian {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (P : MeasureTheory.Measure Ω) :
          Instances For
            noncomputable def GradientIntegrability.randomPowerSeries {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (z : ) (ω : Ω) :
            Instances For
              noncomputable def GradientIntegrability.powerSeriesDeriv {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (z : ) (ω : Ω) :
              Instances For
                noncomputable def GradientIntegrability.weightedGradientIntegral {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (β : ) (ω : Ω) :
                Instances For
                  noncomputable def GradientIntegrability.weightedGradientIntegralENNReal {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (β : ) (ω : Ω) :
                  Instances For
                    theorem GradientIntegrability.measurableSet_summable_complex {Ω : Type u_1} [MeasurableSpace Ω] {f : Ω} (hf : ∀ (j : ), Measurable (f j)) :
                    MeasurableSet {ω : Ω | Summable fun (j : ) => f j ω}
                    theorem GradientIntegrability.measurable_tsum_complex {Ω : Type u_1} [MeasurableSpace Ω] {f : Ω} (hf : ∀ (j : ), Measurable (f j)) :
                    Measurable fun (ω : Ω) => ∑' (j : ), f j ω
                    theorem GradientIntegrability.continuous_gradient_integrand {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (β : ) (ω : Ω) (hcont_ps : Continuous fun (z : ) => powerSeriesDeriv a z ω) ( : 0 β) :
                    Continuous (Function.uncurry fun (t r : ) => 4 * powerSeriesDeriv a (r * Complex.exp (t * Complex.I)) ω ^ 4 * (1 - r) ^ β * r)
                    theorem GradientIntegrability.integrableOn_inner_gradient_integrand {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (β : ) (ω : Ω) (t : ) (hcont_ps : Continuous fun (z : ) => powerSeriesDeriv a z ω) ( : 0 β) :
                    theorem GradientIntegrability.integrableOn_outer_gradient_integrand {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (β : ) (ω : Ω) (hcont_ps : Continuous fun (z : ) => powerSeriesDeriv a z ω) ( : 0 β) :
                    MeasureTheory.IntegrableOn (fun (t : ) => (r : ) in 0..1, 4 * powerSeriesDeriv a (r * Complex.exp (t * Complex.I)) ω ^ 4 * (1 - r) ^ β * r) (Set.Icc 0 (2 * Real.pi)) MeasureTheory.volume
                    theorem GradientIntegrability.weightedGradientIntegralENNReal_eq_ofReal {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (β : ) (ω : Ω) (hcont_ps : Continuous fun (z : ) => powerSeriesDeriv a z ω) ( : 0 β) :
                    theorem GradientIntegrability.weightedGradientIntegral_eq_toReal_of_lt_top {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (β : ) (ω : Ω) (hcont_ps : Continuous fun (z : ) => powerSeriesDeriv a z ω) ( : 0 β) (hfin : weightedGradientIntegralENNReal a β ω < ) :
                    theorem GradientIntegrability.summable_odd_rpow_inv (p : ) (hp : 1 < p) :
                    Summable fun (n : ) => ((2 * n + 1) ^ p)⁻¹
                    theorem GradientIntegrability.product_rpow_le (j k : ) (β : ) ( : 1 < β) :
                    ((2 * j + 1) * (2 * k + 1)) ^ ((1 + β) / 2) (2 * j + 2 * k + 1) ^ (1 + β)
                    theorem GradientIntegrability.summable_double_sum_rpow (β : ) ( : 1 < β) :
                    Summable fun (jk : × ) => ((2 * jk.1 + 2 * jk.2 + 1) ^ (1 + β))⁻¹
                    theorem GradientIntegrability.R_beta_antitone {β₁ β₂ : } (hle : β₁ β₂) (hβ₁ : 0 < β₁) (m : ) :
                    theorem GradientIntegrability.cast_index_eq (j k : ) :
                    ↑(2 * j + 2 * k + 1) = 2 * j + 2 * k + 1
                    theorem GradientIntegrability.summable_beta_integrals_le2 (β : ) (hβ1 : 1 < β) (hβ2 : β 2) :
                    Summable fun (jk : × ) => BetaIntegralBound.R_beta β (2 * jk.1 + 2 * jk.2 + 1)
                    theorem GradientIntegrability.summable_beta_integrals (β : ) ( : 1 < β) :
                    Summable fun (jk : × ) => BetaIntegralBound.R_beta β (2 * jk.1 + 2 * jk.2 + 1)
                    theorem GradientIntegrability.rhs_integrand_nonneg {Ω : Type u_1} [MeasurableSpace Ω] (P : MeasureTheory.Measure Ω) (a : Ω) (r : ) :
                    0 (t : ) in 0..2 * Real.pi, (ω : Ω), 4 * powerSeriesDeriv a (r * Complex.exp (t * Complex.I)) ω ^ 4 P
                    theorem GradientIntegrability.rhs_full_integrand_nonneg {Ω : Type u_1} [MeasurableSpace Ω] (P : MeasureTheory.Measure Ω) (a : Ω) (β r : ) (hr : r Set.Icc 0 1) :
                    0 ( (t : ) in 0..2 * Real.pi, (ω : Ω), 4 * powerSeriesDeriv a (r * Complex.exp (t * Complex.I)) ω ^ 4 P) * ((1 - r) ^ β * r)
                    theorem GradientIntegrability.rhs_integral_nonneg {Ω : Type u_1} [MeasurableSpace Ω] (P : MeasureTheory.Measure Ω) (a : Ω) (β : ) :
                    0 (r : ) in 0..1, ( (t : ) in 0..2 * Real.pi, (ω : Ω), 4 * powerSeriesDeriv a (r * Complex.exp (t * Complex.I)) ω ^ 4 P) * ((1 - r) ^ β * r)
                    theorem GradientIntegrability.weightedGradientIntegral_nonneg {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (β : ) (ω : Ω) :
                    theorem GradientIntegrability.hfi_fubini_omega_t {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : IsIIDStdGaussian a P) (β : ) ( : 1 < β) (hint : MeasureTheory.Integrable (fun (ω : Ω) => weightedGradientIntegral a β ω) P) :
                    theorem GradientIntegrability.integrable_fubini_omega_t {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : IsIIDStdGaussian a P) (β : ) ( : 1 < β) (hint : MeasureTheory.Integrable (fun (ω : Ω) => weightedGradientIntegral a β ω) P) :
                    MeasureTheory.Integrable (Function.uncurry fun (ω : Ω) (t : ) => (r : ) in Set.Ioc 0 1, 4 * powerSeriesDeriv a (r * Complex.exp (t * Complex.I)) ω ^ 4 * (1 - r) ^ β * r) (P.prod (MeasureTheory.volume.restrict (Set.Ioc 0 (2 * Real.pi))))
                    theorem GradientIntegrability.integrable_fubini_omega_r {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : IsIIDStdGaussian a P) (β : ) ( : 1 < β) (hint : MeasureTheory.Integrable (fun (ω : Ω) => weightedGradientIntegral a β ω) P) (t : ) :
                    MeasureTheory.Integrable (Function.uncurry fun (ω : Ω) (r : ) => 4 * powerSeriesDeriv a (r * Complex.exp (t * Complex.I)) ω ^ 4 * (1 - r) ^ β * r) (P.prod (MeasureTheory.volume.restrict (Set.Ioc 0 1)))
                    theorem GradientIntegrability.rhs_bound_integrable_fwd (β : ) ( : 1 < β) :
                    IntervalIntegrable (fun (r : ) => (24 * Real.pi * ∑' (jk : × ), r ^ (2 * jk.1 + 2 * jk.2)) * ((1 - r) ^ β * r)) MeasureTheory.volume 0 1
                    theorem GradientIntegrability.tonelli_fubini_eq {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : IsIIDStdGaussian a P) (β : ) ( : 1 < β) (hint : MeasureTheory.Integrable (fun (ω : Ω) => weightedGradientIntegral a β ω) P) :
                    (ω : Ω), weightedGradientIntegral a β ω P = (r : ) in 0..1, ( (t : ) in 0..2 * Real.pi, (ω : Ω), 4 * powerSeriesDeriv a (r * Complex.exp (t * Complex.I)) ω ^ 4 P) * ((1 - r) ^ β * r)
                    theorem GradientIntegrability.tonelli_gradient_swap {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : IsIIDStdGaussian a P) (β : ) ( : 1 < β) :
                    (ω : Ω), weightedGradientIntegral a β ω P (r : ) in 0..1, ( (t : ) in 0..2 * Real.pi, (ω : Ω), 4 * powerSeriesDeriv a (r * Complex.exp (t * Complex.I)) ω ^ 4 P) * ((1 - r) ^ β * r)
                    theorem GradientIntegrability.hasDerivAt_exp_sq_half' (t : ) :
                    HasDerivAt (fun (t : ) => Real.exp (t ^ 2 / 2)) (t * Real.exp (t ^ 2 / 2)) t
                    theorem GradientIntegrability.hda_poly1 (t : ) :
                    HasDerivAt (fun (t : ) => t * Real.exp (t ^ 2 / 2)) ((1 + t ^ 2) * Real.exp (t ^ 2 / 2)) t
                    theorem GradientIntegrability.hda_poly2 (t : ) :
                    HasDerivAt (fun (t : ) => (1 + t ^ 2) * Real.exp (t ^ 2 / 2)) ((3 * t + t ^ 3) * Real.exp (t ^ 2 / 2)) t
                    theorem GradientIntegrability.hda_poly3 (t : ) :
                    HasDerivAt (fun (t : ) => (3 * t + t ^ 3) * Real.exp (t ^ 2 / 2)) ((3 + 6 * t ^ 2 + t ^ 4) * Real.exp (t ^ 2 / 2)) t
                    theorem GradientIntegrability.isserlis_angular_bound {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : IsIIDStdGaussian a P) (r : ) (hr : r Set.Icc 0 1) :
                    (t : ) in 0..2 * Real.pi, (ω : Ω), 4 * powerSeriesDeriv a (r * Complex.exp (t * Complex.I)) ω ^ 4 P 24 * Real.pi * ∑' (jk : × ), r ^ (2 * jk.1 + 2 * jk.2)
                    theorem GradientIntegrability.aesm_lhs_integrand {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : IsIIDStdGaussian a P) (β : ) ( : 1 < β) :
                    MeasureTheory.AEStronglyMeasurable (fun (r : ) => ( (t : ) in 0..2 * Real.pi, (ω : Ω), 4 * powerSeriesDeriv a (r * Complex.exp (t * Complex.I)) ω ^ 4 P) * ((1 - r) ^ β * r)) (MeasureTheory.volume.restrict (Set.uIoc 0 1))
                    theorem GradientIntegrability.continuous_pow_mul_rpow_mul' (β : ) ( : 0 < β) (m : ) :
                    Continuous fun (r : ) => r ^ m * ((1 - r) ^ β * r)
                    theorem GradientIntegrability.integrableOn_Ioc_pow_rpow_mul' (β : ) ( : 0 < β) (m : ) :
                    MeasureTheory.IntegrableOn (fun (r : ) => r ^ m * ((1 - r) ^ β * r)) (Set.Ioc 0 1) MeasureTheory.volume
                    theorem GradientIntegrability.lintegral_enorm_eq_ofReal'' (β : ) ( : 0 < β) (m : ) :
                    ∫⁻ (r : ) in Set.Ioc 0 1, r ^ m * ((1 - r) ^ β * r)‖ₑ = ENNReal.ofReal ( (r : ) in Set.Ioc 0 1, r ^ m * ((1 - r) ^ β * r))
                    theorem GradientIntegrability.integrableOn_tsum_nonneg {f : × } (h_meas : ∀ (jk : × ), MeasureTheory.AEStronglyMeasurable (f jk) (MeasureTheory.volume.restrict (Set.Ioc 0 1))) (h_nonneg : ∀ (jk : × ), rSet.Ioc 0 1, 0 f jk r) (h_ne_top : ∑' (jk : × ), ∫⁻ (r : ) in Set.Ioc 0 1, f jk r‖ₑ ) :
                    theorem GradientIntegrability.rhs_bound_integrable (β : ) ( : 1 < β) :
                    IntervalIntegrable (fun (r : ) => (24 * Real.pi * ∑' (jk : × ), r ^ (2 * jk.1 + 2 * jk.2)) * ((1 - r) ^ β * r)) MeasureTheory.volume 0 1
                    theorem GradientIntegrability.tonelli_lhs_integrable {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : IsIIDStdGaussian a P) (β : ) ( : 1 < β) :
                    IntervalIntegrable (fun (r : ) => ( (t : ) in 0..2 * Real.pi, (ω : Ω), 4 * powerSeriesDeriv a (r * Complex.exp (t * Complex.I)) ω ^ 4 P) * ((1 - r) ^ β * r)) MeasureTheory.volume 0 1
                    theorem GradientIntegrability.fubini_isserlis_angular_bound {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : IsIIDStdGaussian a P) (β : ) ( : 1 < β) :
                    (ω : Ω), weightedGradientIntegral a β ω P 24 * Real.pi * (r : ) in 0..1, (∑' (jk : × ), r ^ (2 * jk.1 + 2 * jk.2)) * (1 - r) ^ β * r
                    theorem GradientIntegrability.continuous_pow_mul_rpow_mul (β : ) ( : 0 < β) (m : ) :
                    Continuous fun (r : ) => r ^ m * ((1 - r) ^ β * r)
                    theorem GradientIntegrability.integrableOn_Ioc_pow_rpow_mul (β : ) ( : 0 < β) (m : ) :
                    MeasureTheory.IntegrableOn (fun (r : ) => r ^ m * ((1 - r) ^ β * r)) (Set.Ioc 0 1) MeasureTheory.volume
                    theorem GradientIntegrability.lintegral_enorm_eq_ofReal' (β : ) ( : 0 < β) (m : ) :
                    ∫⁻ (r : ) in Set.Ioc 0 1, r ^ m * ((1 - r) ^ β * r)‖ₑ = ENNReal.ofReal ( (r : ) in Set.Ioc 0 1, r ^ m * ((1 - r) ^ β * r))
                    theorem GradientIntegrability.radial_tsum_integral_eq (β : ) ( : 1 < β) :
                    (r : ) in 0..1, (∑' (jk : × ), r ^ (2 * jk.1 + 2 * jk.2)) * (1 - r) ^ β * r = ∑' (jk : × ), BetaIntegralBound.R_beta β (2 * jk.1 + 2 * jk.2 + 1)
                    theorem GradientIntegrability.lintegral_weightedGradientIntegralENNReal_le {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : IsIIDStdGaussian a P) (β : ) ( : 1 < β) (hcont_ps : ∀ (ω : Ω), Continuous fun (z : ) => powerSeriesDeriv a z ω) :
                    theorem GradientIntegrability.gradient_integral_ennreal_ae_lt_top {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : IsIIDStdGaussian a P) (β : ) ( : 1 < β) (hcont_ps : ∀ (ω : Ω), Continuous fun (z : ) => powerSeriesDeriv a z ω) :
                    theorem GradientIntegrability.gradient_integral_ae_finite {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : IsIIDStdGaussian a P) (β : ) ( : 1 < β) (hcont_ps : ∀ (ω : Ω), Continuous fun (z : ) => powerSeriesDeriv a z ω) :
                    ∀ᵐ (ω : Ω) P, ∃ (C : ), weightedGradientIntegral a β ω C

                    If $X$ has law $\mathcal{N}(0, v)$ under $P$, then $\operatorname{Var}[X; P] = v$.

                    If $X$ has law $\mathcal{N}(0, v)$ under $P$, then $\mathbb{E}[X] = \int_\Omega X \,\mathrm{d}P = 0$.

                    If $X$ has law $\mathcal{N}(0, v)$ under $P$, then $X$ has a Gaussian law under $P$.

                    A real-valued Gaussian random variable with law $\mathcal{N}(0, v)$ lies in $L^2(P)$.

                    theorem SumIndependentGaussians.memLp_partialSum {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} {X : Ω} {v : NNReal} (hgauss : ∀ (k : ), ProbabilityTheory.HasLaw (X k) (ProbabilityTheory.gaussianReal 0 (v k)) P) (n : ) :
                    MeasureTheory.MemLp (fun (ω : Ω) => kFinset.range n, X k ω) 2 P

                    The partial sum $S_n = \sum_{k < n} X_k$ of Gaussian random variables lies in $L^2(P)$.

                    noncomputable def SumIndependentGaussians.partialSumLp {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} {X : Ω} {v : NNReal} (hgauss : ∀ (k : ), ProbabilityTheory.HasLaw (X k) (ProbabilityTheory.gaussianReal 0 (v k)) P) (n : ) :

                    The partial sum $S_n = \sum_{k < n} X_k$ viewed as an element of $L^2(P)$.

                    Instances For

                      For a centered $L^2$ random variable $f$ on a probability space, $\|f\|_{L^2}^2 = \operatorname{Var}(f)$.

                      theorem SumIndependentGaussians.variance_icoSum_eq {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {X : Ω} {v : NNReal} (hindep : ProbabilityTheory.iIndepFun X P) (hgauss : ∀ (k : ), ProbabilityTheory.HasLaw (X k) (ProbabilityTheory.gaussianReal 0 (v k)) P) (n m : ) :
                      ProbabilityTheory.variance (fun (ω : Ω) => kFinset.Ico n m, X k ω) P = kFinset.Ico n m, (v k)

                      For independent Gaussian random variables $X_k \sim \mathcal{N}(0, v_k)$, the variance of the block sum $\sum_{k \in [n, m)} X_k$ equals $\sum_{k \in [n, m)} v_k$.

                      theorem SumIndependentGaussians.sum_Ico_le_tsum_tail (v : NNReal) (hsum : Summable v) (n m : ) :
                      kFinset.Ico n m, (v k) ∑' (k : ), (v (k + n))

                      For a summable nonnegative sequence $v$, the block sum is bounded by the tail of the series: $\sum_{k \in [n, m)} v_k \leq \sum_{k \geq 0} v_{k + n}$.

                      theorem SumIndependentGaussians.dist_partialSumLp_le {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {X : Ω} {v : NNReal} (hindep : ProbabilityTheory.iIndepFun X P) (hgauss : ∀ (k : ), ProbabilityTheory.HasLaw (X k) (ProbabilityTheory.gaussianReal 0 (v k)) P) (hsum : Summable v) {n m : } (hnm : n m) :
                      dist (partialSumLp hgauss n) (partialSumLp hgauss m) (∑' (k : ), (v (k + n)))

                      The $L^2$-distance between partial sums $S_n$ and $S_m$ (with $n \leq m$) is bounded by $\sqrt{\sum_{k \geq 0} v_{k + n}}$, the square root of the tail of the variance series.

                      If $\sum_k v_k < \infty$, then the partial sums $S_n = \sum_{k < n} X_k$ form a Cauchy sequence in $L^2(P)$.

                      theorem SumIndependentGaussians.exists_L2_limit {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] (X : Ω) (v : NNReal) (hindep : ProbabilityTheory.iIndepFun X P) (hgauss : ∀ (k : ), ProbabilityTheory.HasLaw (X k) (ProbabilityTheory.gaussianReal 0 (v k)) P) (hsum : Summable v) :
                      ∃ (S : Ω), MeasureTheory.MemLp S 2 P Filter.Tendsto (fun (n : ) => MeasureTheory.eLpNorm (fun (ω : Ω) => kFinset.range n, X k ω - S ω) 2 P) Filter.atTop (nhds 0)

                      Existence of the $L^2$-limit: completeness of $L^2(P)$ gives an $S \in L^2(P)$ such that the partial sums $S_n = \sum_{k < n} X_k$ converge to $S$ in $L^2(P)$.

                      theorem SumIndependentGaussians.hasGaussianLaw_partialSum {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] (X : Ω) (v : NNReal) (hindep : ProbabilityTheory.iIndepFun X P) (hgauss : ∀ (k : ), ProbabilityTheory.HasLaw (X k) (ProbabilityTheory.gaussianReal 0 (v k)) P) (n : ) :
                      ProbabilityTheory.HasGaussianLaw (fun (ω : Ω) => kFinset.range n, X k ω) P

                      The partial sum of independent Gaussian random variables has a Gaussian law: if each $X_k \sim \mathcal{N}(0, v_k)$ and the $X_k$ are independent, then $\sum_{k < n} X_k$ has a Gaussian law on $\mathbb{R}$.

                      theorem SumIndependentGaussians.hasLaw_partialSum {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] (X : Ω) (v : NNReal) (hindep : ProbabilityTheory.iIndepFun X P) (hgauss : ∀ (k : ), ProbabilityTheory.HasLaw (X k) (ProbabilityTheory.gaussianReal 0 (v k)) P) (n : ) :
                      ProbabilityTheory.HasLaw (fun (ω : Ω) => kFinset.range n, X k ω) (ProbabilityTheory.gaussianReal 0 (∑ kFinset.range n, v k)) P

                      Identification of the law of the partial sum: if $X_k \sim \mathcal{N}(0, v_k)$ are independent, then $\sum_{k < n} X_k \sim \mathcal{N}\bigl(0, \sum_{k < n} v_k\bigr)$.

                      theorem SumIndependentGaussians.hasLaw_of_L2_limit {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] (X : Ω) (v : NNReal) (hindep : ProbabilityTheory.iIndepFun X P) (hgauss : ∀ (k : ), ProbabilityTheory.HasLaw (X k) (ProbabilityTheory.gaussianReal 0 (v k)) P) (hsum : Summable v) (S : Ω) (hS_mem : MeasureTheory.MemLp S 2 P) (hS_lim : Filter.Tendsto (fun (n : ) => MeasureTheory.eLpNorm (fun (ω : Ω) => kFinset.range n, X k ω - S ω) 2 P) Filter.atTop (nhds 0)) :

                      The $L^2$-limit $S$ inherits the Gaussian law: if $S_n = \sum_{k < n} X_k \to S$ in $L^2(P)$, then $S \sim \mathcal{N}\bigl(0, \sum_k v_k\bigr)$. The proof uses convergence in measure $\Rightarrow$ convergence in distribution together with continuity of the characteristic function $\mathcal{N}(0, \sum_{k<n} v_k) \to \mathcal{N}(0, \sum_k v_k)$.

                      theorem SumIndependentGaussians.sum_independent_gaussians {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] (X : Ω) (v : NNReal) (hindep : ProbabilityTheory.iIndepFun X P) (hgauss : ∀ (k : ), ProbabilityTheory.HasLaw (X k) (ProbabilityTheory.gaussianReal 0 (v k)) P) (hsum : Summable v) :
                      ∃ (S : Ω), Filter.Tendsto (fun (n : ) => MeasureTheory.eLpNorm (fun (ω : Ω) => S ω - kFinset.range n, X k ω) 2 P) Filter.atTop (nhds 0) ProbabilityTheory.HasLaw S (ProbabilityTheory.gaussianReal 0 (∑' (k : ), v k)) P

                      Proposition 1 (Brownian Motion). Let $(X_k)_{k \geq 0}$ be independent real-valued Gaussian random variables on a probability space $(\Omega, P)$ with $X_k \sim \mathcal{N}(0, v_k)$ and $\sigma^2 := \sum_k v_k < \infty$. Then there exists a random variable $S$ such that the partial sums $\sum_{k < n} X_k$ converge to $S$ in $L^2(P)$ and $S \sim \mathcal{N}(0, \sigma^2)$.

                      structure BrownianFDD.IsRademacher {Ω : Type u_1} [MeasurableSpace Ω] (R : Ω) (P : MeasureTheory.Measure Ω) :

                      Predicate characterizing a Rademacher-type random variable $R : Ω → ℝ$ on $(Ω, P)$: $R$ is measurable, has mean zero $\mathbb{E}[R] = \int R\,\mathrm{d}P = 0$, and unit variance $\mathbb{E}[R^2] = \int R^2\,\mathrm{d}P = 1$. The canonical example is the symmetric $\pm 1$ Bernoulli (Rademacher) variable.

                      Instances For
                        noncomputable def BrownianFDD.randomWalk {Ω : Type u_1} (R : Ω) (k : ) (ω : Ω) :

                        The $k$-th partial sum (random walk) of a sequence $(R_i)_{i \in ℕ}$ of random variables: $S_k(ω) = \sum_{i < k} R_i(ω)$.

                        Instances For
                          noncomputable def BrownianFDD.scaledIncrement {Ω : Type u_1} (R : Ω) (n k_prev k_next : ) (ω : Ω) :

                          The Donsker-scaled increment of the random walk between indices $k_{\text{prev}}$ and $k_{\text{next}}$: $$\frac{S_{k_{\text{next}}}(ω) - S_{k_{\text{prev}}}(ω)}{\sqrt{n}}.$$ This is the basic building block whose distribution converges to a Gaussian as $n \to \infty$.

                          Instances For
                            noncomputable def BrownianFDD.gridIndex {m : } (n : ) (t : Fin (m + 1)) (j : Fin (m + 1)) :

                            The discrete grid index associated with a continuous time $t_j$ at scale $n$: $\lfloor n \cdot t_j \rfloor$. Converts a continuous time partition into the nearest discrete step on the random walk.

                            Instances For
                              noncomputable def BrownianFDD.varianceVector {m : } (t : Fin (m + 1)) (ht : StrictMono t) :
                              Fin mNNReal

                              The vector of variances $\sigma_j^2 = t_{j+1} - t_j$ for $j = 0, \dots, m-1$ associated with a strictly increasing time partition $t : \mathrm{Fin}(m+1) \to ℝ$. These are the variances of the limiting independent Gaussian increments in Brownian finite-dimensional distribution convergence.

                              Instances For
                                theorem BrownianFDD.gridIndex_mono {m : } (n : ) {t : Fin (m + 1)} (ht : StrictMono t) :
                                Monotone fun (j : Fin (m + 1)) => gridIndex n t j

                                Monotonicity of the grid index: for a strictly monotone time partition $t$ and fixed scale $n$, the discrete grid indices $j \mapsto \lfloor n \cdot t_j \rfloor$ form a monotone sequence.

                                theorem BrownianFDD.tendsto_gridIndex_sub_atTop {m : } {t : Fin (m + 1)} (ht : StrictMono t) (ht0 : 0 t 0) (j : Fin m) :

                                The block size $\lfloor n \cdot t_{j+1} \rfloor - \lfloor n \cdot t_j \rfloor$ tends to infinity as $n \to \infty$, since $t_{j+1} - t_j > 0$. This is what allows the central limit theorem to apply on each block.

                                theorem BrownianFDD.randomWalk_diff_eq_sum_Ico {Ω : Type u_1} (R : Ω) {a b : } (hab : a b) (ω : Ω) :
                                randomWalk R b ω - randomWalk R a ω = iFinset.Ico a b, R i ω

                                The difference of partial sums equals the sum over the half-open interval: $S_b(ω) - S_a(ω) = \sum_{i \in [a, b)} R_i(ω)$ for $a \le b$.

                                theorem BrownianFDD.scaledIncrement_eq_sum_div {Ω : Type u_1} (R : Ω) (n : ) {k_prev k_next : } (h : k_prev k_next) (ω : Ω) :
                                scaledIncrement R n k_prev k_next ω = (∑ iFinset.Ico k_prev k_next, R i ω) / n

                                Rewrite the scaled increment as a normalized sum over a block: $\dfrac{S_{k_{\text{next}}} - S_{k_{\text{prev}}}}{\sqrt{n}} = \dfrac{1}{\sqrt{n}} \sum_{i \in [k_{\text{prev}}, k_{\text{next}})} R_i(ω)$.

                                theorem BrownianFDD.gridIndex_block_ratio_tendsto {m : } {t : Fin (m + 1)} (ht : StrictMono t) (ht0 : 0 t 0) (j : Fin m) :
                                Filter.Tendsto (fun (n : ) => ↑(gridIndex n t j.succ - gridIndex n t j.castSucc) / n) Filter.atTop (nhds (t j.succ - t j.castSucc))

                                The ratio of block size to total scale converges to the time difference: $$\frac{\lfloor n \cdot t_{j+1} \rfloor - \lfloor n \cdot t_j \rfloor}{n} \;\longrightarrow\; t_{j+1} - t_j \quad (n \to \infty).$$ This is the key asymptotic that lets the rescaled increments carry the correct Brownian variance in the limit.

                                theorem BrownianFDD.variable_block_CLT_tendstoInDistribution {Ω : Type u_1} {Ω' : Type u_2} [MeasurableSpace Ω] [MeasurableSpace Ω'] {P : MeasureTheory.Measure Ω} {P' : MeasureTheory.Measure Ω'} [MeasureTheory.IsProbabilityMeasure P] [MeasureTheory.IsProbabilityMeasure P'] {R : Ω} (hR_meas : ∀ (i : ), Measurable (R i)) (hR_mean : ∀ (i : ), (ω : Ω), R i ω P = 0) (hR_var : ∀ (i : ), (ω : Ω), R i ω ^ 2 P = 1) (hindep : ProbabilityTheory.iIndepFun R P) (hident : ∀ (i : ), ProbabilityTheory.IdentDistrib (R i) (R 0) P P) (m_block a_block : ) (hm_atTop : Filter.Tendsto m_block Filter.atTop Filter.atTop) (σ_sq : ) (hσ_sq : 0 σ_sq) (hm_ratio : Filter.Tendsto (fun (n : ) => (m_block n) / n) Filter.atTop (nhds σ_sq)) {Y : Ω'} (hY : ProbabilityTheory.HasLaw Y (ProbabilityTheory.gaussianReal 0 σ_sq, hσ_sq) P') :
                                MeasureTheory.TendstoInDistribution (fun (n : ) (ω : Ω) => (∑ iFinset.Ico (a_block n) (a_block n + m_block n), R i ω) / n) Filter.atTop Y (fun (x : ) => P) P'

                                Central Limit Theorem with variable block sizes. For iid mean-zero unit-variance random variables $(R_i)$, if a block of length $m_n$ starting at $a_n$ satisfies $m_n \to \infty$ and $m_n / n \to \sigma^2$, then the normalized block sum $$\frac{1}{\sqrt{n}} \sum_{i=a_n}^{a_n + m_n - 1} R_i$$ converges in distribution to a centered Gaussian with variance $\sigma^2$.

                                theorem BrownianFDD.increment_tendstoInDistribution_gaussianReal {Ω : Type u_1} {Ω' : Type u_2} [MeasurableSpace Ω] [MeasurableSpace Ω'] {P : MeasureTheory.Measure Ω} {P' : MeasureTheory.Measure Ω'} [MeasureTheory.IsProbabilityMeasure P] [MeasureTheory.IsProbabilityMeasure P'] {R : Ω} (hR : ∀ (i : ), IsRademacher (R i) P) (hindep : ProbabilityTheory.iIndepFun R P) (hident : ∀ (i : ), ProbabilityTheory.IdentDistrib (R i) (R 0) P P) {m : } (t : Fin (m + 1)) (ht : StrictMono t) (ht0 : 0 t 0) (j : Fin m) {Y : Ω'} (hY : ProbabilityTheory.HasLaw Y (ProbabilityTheory.gaussianReal 0 (varianceVector t ht j)) P') :
                                MeasureTheory.TendstoInDistribution (fun (n : ) (ω : Ω) => scaledIncrement R n (gridIndex n t j.castSucc) (gridIndex n t j.succ) ω) Filter.atTop Y (fun (x : ) => P) P'

                                For iid Rademacher variables, the single scaled increment between grid points $t_j$ and $t_{j+1}$ converges in distribution to a Gaussian with mean $0$ and variance $\sigma_j^2 = t_{j+1} - t_j$. This is the one-dimensional marginal of the Brownian FDD convergence, obtained by applying the variable-block CLT to the block $[\lfloor n t_j \rfloor, \lfloor n t_{j+1} \rfloor)$.

                                theorem BrownianFDD.iIndep_biSup_of_disjoint {Ω : Type u_1} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {ι : Type u_2} {κ : Type u_3} [DecidableEq κ] {m : ιMeasurableSpace Ω} (hm : ∀ (i : ι), m i _mΩ) (h_indep : ProbabilityTheory.iIndep m μ) {S : κSet ι} (hS : ∀ (j₁ j₂ : κ), j₁ j₂Disjoint (S j₁) (S j₂)) :
                                ProbabilityTheory.iIndep (fun (j : κ) => iS j, m i) μ

                                Independence of $\sigma$-algebras indexed by disjoint families. Given an $ι$-indexed independent family of $\sigma$-algebras $(m_i)$ and a $κ$-indexed family of pairwise disjoint subsets $(S_j) \subseteq ι$, the bundled $\sigma$-algebras $\bigvee_{i \in S_j} m_i$ are independent across $j$.

                                theorem BrownianFDD.increments_iIndepFun {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {R : Ω} (hindep : ProbabilityTheory.iIndepFun R P) (hR_meas : ∀ (i : ), Measurable (R i)) {m : } (t : Fin (m + 1)) (ht : StrictMono t) (n : ) :
                                ProbabilityTheory.iIndepFun (fun (j : Fin m) (ω : Ω) => scaledIncrement R n (gridIndex n t j.castSucc) (gridIndex n t j.succ) ω) P

                                The collection of scaled increments $\bigl(\mathrm{scaledIncrement}\,R\,n\,\lfloor n t_j \rfloor\,\lfloor n t_{j+1} \rfloor\bigr)_{j \in \mathrm{Fin}\,m}$ is jointly independent, because each increment is measurable with respect to the $\sigma$-algebra generated by $(R_i)$ on a disjoint block of indices.

                                theorem BrownianFDD.indep_marginal_tendstoInDistribution_product {Ω : Type u_1} {Ω' : Type u_2} {m : } [MeasurableSpace Ω] [MeasurableSpace Ω'] {P : MeasureTheory.Measure Ω} {P' : MeasureTheory.Measure Ω'} [MeasureTheory.IsProbabilityMeasure P] [MeasureTheory.IsProbabilityMeasure P'] (X : Fin mΩ) (Z : Fin mΩ') (hmarg : ∀ (j : Fin m), MeasureTheory.TendstoInDistribution (fun (n : ) (ω : Ω) => X n j ω) Filter.atTop (Z j) (fun (x : ) => P) P') (hindep : ∀ (n : ), ProbabilityTheory.iIndepFun (fun (j : Fin m) (ω : Ω) => X n j ω) P) (hindep_limit : ProbabilityTheory.iIndepFun Z P') :
                                MeasureTheory.TendstoInDistribution (fun (n : ) (ω : Ω) (j : Fin m) => X n j ω) Filter.atTop (fun (ω : Ω') (j : Fin m) => Z j ω) (fun (x : ) => P) P'

                                Joint convergence from marginal convergence for independent coordinates. If for each $j$ the marginal sequence $X_n(j)$ converges in distribution to $Z(j)$, and if the coordinates $(X_n(j))_j$ are jointly independent for every $n$ (and the limit coordinates $(Z(j))_j$ are independent), then the full vector $X_n(\cdot)$ converges in distribution to $Z(\cdot)$.

                                theorem BrownianFDD.brownian_fdd_convergence_discrete {Ω : Type u_1} {Ω' : Type u_2} [MeasurableSpace Ω] [MeasurableSpace Ω'] {P : MeasureTheory.Measure Ω} {P' : MeasureTheory.Measure Ω'} [MeasureTheory.IsProbabilityMeasure P] [MeasureTheory.IsProbabilityMeasure P'] {R : Ω} (hR : ∀ (i : ), IsRademacher (R i) P) (hindep : ProbabilityTheory.iIndepFun R P) (hident : ∀ (i : ), ProbabilityTheory.IdentDistrib (R i) (R 0) P P) {m : } (t : Fin (m + 1)) (ht : StrictMono t) (ht0 : 0 t 0) {Z : Fin mΩ'} (hZ : ∀ (j : Fin m), ProbabilityTheory.HasLaw (Z j) (ProbabilityTheory.gaussianReal 0 (varianceVector t ht j)) P') (hZindep : ProbabilityTheory.iIndepFun Z P') :
                                MeasureTheory.TendstoInDistribution (fun (n : ) (ω : Ω) (j : Fin m) => scaledIncrement R n (gridIndex n t j.castSucc) (gridIndex n t j.succ) ω) Filter.atTop (fun (ω : Ω') (j : Fin m) => Z j ω) (fun (x : ) => P) P'

                                Brownian FDD convergence (discrete version). For iid Rademacher random variables $(R_i)$, the vector of scaled increments on a partition $0 \le t_0 < t_1 < \cdots < t_m$ converges jointly in distribution to a vector of independent Gaussians with variances $\sigma_j^2 = t_{j+1} - t_j$. This combines the one-dimensional CLT on each block (increment_tendstoInDistribution_gaussianReal) with the joint-from-marginal-with-independence principle (indep_marginal_tendstoInDistribution_product).

                                noncomputable def BrownianFDD.piecewiseLinearInterp {Ω : Type u_1} (R : Ω) (n : ) (t : ) (ω : Ω) :

                                The Donsker-scale piecewise linear interpolation $f_n(t)$ of the random walk: between integer scaled times $k/n$ and $(k+1)/n$, the function interpolates linearly between $S_k/\sqrt{n}$ and $S_{k+1}/\sqrt{n}$. Explicitly, with $k = \lfloor n t \rfloor$ and fractional part $\{nt\} = nt - k$, $$f_n(t)(ω) = \frac{S_k(ω)}{\sqrt{n}} + \{nt\} \cdot \frac{R_k(ω)}{\sqrt{n}}.$$ This is the continuous-time process whose finite-dimensional distributions converge to those of Brownian motion.

                                Instances For
                                  noncomputable def BrownianFDD.fnIncrement {Ω : Type u_1} (R : Ω) (n : ) (t_prev t_next : ) (ω : Ω) :

                                  The continuous-time increment of the piecewise linear interpolation between times $t_{\text{prev}}$ and $t_{\text{next}}$: $f_n(t_{\text{next}}) - f_n(t_{\text{prev}})$.

                                  Instances For
                                    theorem BrownianFDD.fnIncrement_eq_scaledIncrement_add_error {Ω : Type u_1} (R : Ω) (n : ) (t_prev t_next : ) (ω : Ω) :
                                    fnIncrement R n t_prev t_next ω = scaledIncrement R n n * t_prev⌋₊ n * t_next⌋₊ ω + ((n * t_next - n * t_next⌋₊) * R n * t_next⌋₊ ω - (n * t_prev - n * t_prev⌋₊) * R n * t_prev⌋₊ ω) / n

                                    Decomposition of the continuous-time increment of $f_n$ into the discrete scaled increment plus a small fractional error: $$f_n(t_{\text{next}}) - f_n(t_{\text{prev}}) = \mathrm{scaledIncrement},R,n,\lfloor n t_{\text{prev}} \rfloor,\lfloor n t_{\text{next}} \rfloor

                                    • \frac{1}{\sqrt{n}}\Bigl({n t_{\text{next}}} R_{\lfloor n t_{\text{next}} \rfloor}
                                    • {n t_{\text{prev}}} R_{\lfloor n t_{\text{prev}} \rfloor}\Bigr).$$ The error term is uniformly bounded by $2/\sqrt{n}$ (provided $|R_i| \le 1$) and so vanishes in the limit; this is the basis of the Slutsky argument for brownian_fdd_convergence.
                                    theorem BrownianFDD.slutsky_deterministic_perturbation {α : Type u_1} {Ω : Type u_2} {Ω' : Type u_3} [MeasurableSpace Ω] [MeasurableSpace Ω'] [TopologicalSpace α] [MeasurableSpace α] [PseudoMetricSpace α] [BorelSpace α] {P : MeasureTheory.Measure Ω} {P' : MeasureTheory.Measure Ω'} [MeasureTheory.IsProbabilityMeasure P] [MeasureTheory.IsProbabilityMeasure P'] {X Y : Ωα} {Z : Ω'α} (ε : ) (hX : MeasureTheory.TendstoInDistribution X Filter.atTop Z (fun (x : ) => P) P') (hclose : ∀ (n : ) (ω : Ω), dist (Y n ω) (X n ω) ε n) ( : Filter.Tendsto ε Filter.atTop (nhds 0)) :

                                    Slutsky's theorem for deterministic perturbations. If $X_n \Rightarrow Z$ in distribution and $Y_n$ is uniformly close to $X_n$, with $\sup_ω \mathrm{dist}(Y_n(ω), X_n(ω)) \le \varepsilon_n \to 0$, then $Y_n \Rightarrow Z$ in distribution as well. This is the standard tool for transferring distributional convergence across a vanishing additive error term.

                                    theorem BrownianFDD.brownian_fdd_convergence {Ω : Type u_1} {Ω' : Type u_2} [MeasurableSpace Ω] [MeasurableSpace Ω'] {P : MeasureTheory.Measure Ω} {P' : MeasureTheory.Measure Ω'} [MeasureTheory.IsProbabilityMeasure P] [MeasureTheory.IsProbabilityMeasure P'] {R : Ω} (hR : ∀ (i : ), IsRademacher (R i) P) (hindep : ProbabilityTheory.iIndepFun R P) (hident : ∀ (i : ), ProbabilityTheory.IdentDistrib (R i) (R 0) P P) (hR_bdd : ∀ (i : ) (ω : Ω), |R i ω| 1) {m : } (t : Fin (m + 1)) (ht : StrictMono t) (ht0 : 0 t 0) {Z : Fin mΩ'} (hZ : ∀ (j : Fin m), ProbabilityTheory.HasLaw (Z j) (ProbabilityTheory.gaussianReal 0 (varianceVector t ht j)) P') (hZindep : ProbabilityTheory.iIndepFun Z P') :
                                    MeasureTheory.TendstoInDistribution (fun (n : ) (ω : Ω) (j : Fin m) => fnIncrement R n (t j.castSucc) (t j.succ) ω) Filter.atTop (fun (ω : Ω') (j : Fin m) => Z j ω) (fun (x : ) => P) P'

                                    Theorem 1 — Brownian Motion (finite-dimensional distribution convergence). Let $(R_i)$ be iid Rademacher random variables with $|R_i| \le 1$. Then for any strictly increasing time partition $0 \le t_0 < t_1 < \cdots < t_m$, the vector of continuous-time increments $$\bigl(f_n(t_1) - f_n(t_0),\; \dots,\; f_n(t_m) - f_n(t_{m-1})\bigr)$$ of the piecewise linear interpolation $f_n$ converges in distribution to a vector of independent centered Gaussians with variances $\sigma_j^2 = t_j - t_{j-1}$. Equivalently, the finite-dimensional distributions of $f_n$ converge to those of a standard Brownian motion. The proof combines the discrete FDD convergence (brownian_fdd_convergence_discrete) with Slutsky's theorem applied to the bounded fractional error $\le 2/\sqrt{n}$ from fnIncrement_eq_scaledIncrement_add_error.

                                    Instances For
                                      theorem HolderBoundary.arc_segment_bound (F : ) (C₀ α ρ t₁ t₂ : ) (hC₀ : 0 C₀) (_hα_pos : 0 < α) (hα_le : α 1) (hρ_pos : 0 < ρ) (hρ_le : ρ 1) (hdiff : DifferentiableOn F (Metric.ball 0 1)) (hgrad : SatisfiesGradientBound F C₀ α) (ht : |t₁ - t₂| ρ) :
                                      F (circleMap 0 (1 - ρ) t₁) - F (circleMap 0 (1 - ρ) t₂) C₀ * ρ ^ α
                                      theorem HolderBoundary.hasDerivAt_circleMap_sub (t s : ) :
                                      HasDerivAt (fun (s : ) => circleMap 0 (1 - s) t) (-circleMap 0 1 t) s
                                      theorem HolderBoundary.radial_segment_bound (F : ) (C₀ α t : ) (hC₀ : 0 C₀) (hα_pos : 0 < α) (hα_le : α 1) (hcont : ContinuousOn F (Metric.closedBall 0 1)) (hdiff : DifferentiableOn F (Metric.ball 0 1)) (hgrad : SatisfiesGradientBound F C₀ α) (ρ : ) (hρ_pos : 0 < ρ) (hρ_le : ρ 1) :
                                      F (circleMap 0 1 t) - F (circleMap 0 (1 - ρ) t) C₀ / α * ρ ^ α
                                      theorem HolderBoundary.holder_boundary_of_gradient_bound (F : ) (C α : ) (hC : 0 < C) (hα_pos : 0 < α) (hα_le : α 1) (hcont : ContinuousOn F (Metric.closedBall 0 1)) (hdiff : DifferentiableOn F (Metric.ball 0 1)) (hgrad : SatisfiesGradientBound F C α) :
                                      ∃ (C' : ), 0 < C' ∀ (t₁ t₂ : ), F (circleMap 0 1 t₁) - F (circleMap 0 1 t₂) C' * |t₁ - t₂| ^ α
                                      noncomputable def WienerConstruction.wienerC0 :
                                      Instances For
                                        noncomputable def WienerConstruction.wienerC1 :
                                        Instances For
                                          noncomputable def WienerConstruction.wienerProcess {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (t : ) (ω : Ω) :
                                          Instances For
                                            theorem WienerConstruction.wienerProcess_zero {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (ω : Ω) :
                                            wienerProcess a 0 ω = 0
                                            Instances For
                                              noncomputable def WienerConstruction.wienerCoeff (n : ) (t c : Fin n) (k : ) :
                                              Instances For
                                                noncomputable def WienerConstruction.wienerCoeffVar (n : ) (t c : Fin n) :
                                                Instances For
                                                  theorem WienerConstruction.summable_wienerCoeffVar (n : ) (t : Fin n) (ht : ∀ (j : Fin n), 0 t j t j Real.pi) (c : Fin n) :
                                                  noncomputable def WienerConstruction.wienerBasisCoeff (s : ) (k : ) :
                                                  Instances For
                                                    theorem WienerConstruction.wienerProcess_eq_tsum {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (s : ) (ω : Ω) (hsum : Summable fun (k : ) => wienerBasisCoeff s k * a k ω) :
                                                    wienerProcess a s ω = ∑' (k : ), wienerBasisCoeff s k * a k ω
                                                    theorem WienerConstruction.wienerLinearComb_ae_eq_L2limit {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : GradientIntegrability.IsIIDStdGaussian a P) (n : ) (t : Fin n) (ht : ∀ (j : Fin n), 0 t j t j Real.pi) (c : Fin n) (S : Ω) (hS : Filter.Tendsto (fun (N : ) => MeasureTheory.eLpNorm (fun (ω : Ω) => S ω - kFinset.range N, wienerCoeff n t c k * a k ω) 2 P) Filter.atTop (nhds 0)) (hS_aesm : MeasureTheory.AEStronglyMeasurable S P := by first | exact ‹_› | exact (‹HasLaw S _ P›).aemeasurable.aestronglyMeasurable) :
                                                    (fun (ω : Ω) => j : Fin n, c j * wienerProcess a (t j) ω) =ᵐ[P] S
                                                    theorem WienerConstruction.wienerProcess_gaussian_linear_comb {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : GradientIntegrability.IsIIDStdGaussian a P) (n : ) (t : Fin n) (ht : ∀ (j : Fin n), 0 t j t j Real.pi) (c : Fin n) :
                                                    ProbabilityTheory.HasGaussianLaw (fun (ω : Ω) => j : Fin n, c j * wienerProcess a (t j) ω) P
                                                    theorem WienerConstruction.integral_mul_of_indep_std_gaussian {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} {a : Ω} (ha : GradientIntegrability.IsIIDStdGaussian a P) {j k : } (hjk : j k) :
                                                    (ω : Ω), a j ω * a k ω P = 0
                                                    theorem WienerConstruction.integral_mul_self_of_std_gaussian {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} {a : Ω} (ha : GradientIntegrability.IsIIDStdGaussian a P) (k : ) :
                                                    (ω : Ω), a k ω * a k ω P = 1
                                                    theorem WienerConstruction.finite_parseval_iid_gaussian {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : GradientIntegrability.IsIIDStdGaussian a P) (α β : ) (N : ) :
                                                    (ω : Ω), (∑ kFinset.range N, α k * a k ω) * kFinset.range N, β k * a k ω P = kFinset.range N, α k * β k
                                                    theorem WienerConstruction.ae_summable_of_sq_summable {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : GradientIntegrability.IsIIDStdGaussian a P) (α : ) ( : Summable fun (k : ) => α k ^ 2) :
                                                    ∀ᵐ (ω : Ω) P, Summable fun (k : ) => α k * a k ω
                                                    theorem WienerConstruction.tsum_ae_eq_L2_limit {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : GradientIntegrability.IsIIDStdGaussian a P) (α : ) ( : Summable fun (k : ) => α k ^ 2) (S : Ω) (hS_mem : MeasureTheory.MemLp S 2 P) (hS_lim : Filter.Tendsto (fun (n : ) => MeasureTheory.eLpNorm (fun (ω : Ω) => kFinset.range n, α k * a k ω - S ω) 2 P) Filter.atTop (nhds 0)) :
                                                    (fun (ω : Ω) => ∑' (k : ), α k * a k ω) =ᵐ[P] S
                                                    theorem WienerConstruction.tendsto_integral_prod_of_L2_limit {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : GradientIntegrability.IsIIDStdGaussian a P) (α β : ) (S T : Ω) (hS : MeasureTheory.MemLp S 2 P) (hT : MeasureTheory.MemLp T 2 P) (hS_lim : Filter.Tendsto (fun (n : ) => MeasureTheory.eLpNorm (fun (ω : Ω) => kFinset.range n, α k * a k ω - S ω) 2 P) Filter.atTop (nhds 0)) (hT_lim : Filter.Tendsto (fun (n : ) => MeasureTheory.eLpNorm (fun (ω : Ω) => kFinset.range n, β k * a k ω - T ω) 2 P) Filter.atTop (nhds 0)) :
                                                    Filter.Tendsto (fun (N : ) => (ω : Ω), (∑ kFinset.range N, α k * a k ω) * kFinset.range N, β k * a k ω P) Filter.atTop (nhds ( (ω : Ω), S ω * T ω P))
                                                    theorem WienerConstruction.bilinear_parseval_iid_gaussian {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : GradientIntegrability.IsIIDStdGaussian a P) (α β : ) ( : Summable fun (k : ) => α k ^ 2) ( : Summable fun (k : ) => β k ^ 2) (hαβ : Summable fun (k : ) => α k * β k) :
                                                    (ω : Ω), (∑' (k : ), α k * a k ω) * ∑' (k : ), β k * a k ω P = ∑' (k : ), α k * β k
                                                    theorem WienerConstruction.tsum_wienerBasisCoeff_eq (s t : ) :
                                                    ∑' (k : ), wienerBasisCoeff s k * wienerBasisCoeff t k = s * t / Real.pi + 2 / Real.pi * ∑' (k : ), Real.sin (↑(k + 1) * s) * Real.sin (↑(k + 1) * t) / ↑(k + 1) ^ 2

                                                    Closed-form decomposition of the coefficient pairing $\sum_k c_k(s)\,c_k(t)$ into the constant-mode term $st/\pi$ and the sine-series tail $\tfrac{2}{\pi}\sum_{k\ge 1}\sin(ks)\sin(kt)/k^2$, where $c_k$ are the Wiener basis coefficients.

                                                    theorem WienerConstruction.wienerProcess_expectation_decomposition {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : GradientIntegrability.IsIIDStdGaussian a P) (s t : ) (hs : 0 s) (hs' : s Real.pi) (ht : 0 t) (ht' : t Real.pi) :
                                                    (ω : Ω), wienerProcess a s ω * wienerProcess a t ω P = s * t / Real.pi + 2 / Real.pi * ∑' (k : ), Real.sin (↑(k + 1) * s) * Real.sin (↑(k + 1) * t) / ↑(k + 1) ^ 2

                                                    Bilinear-Parseval expansion of the Wiener-process covariance: for i.i.d. standard Gaussian coefficients $(a_k)$ the expectation $\mathbb{E}(W_s W_t)$ equals $st/\pi$ plus the Fourier sine tail $\tfrac{2}{\pi}\sum_{k\ge 1}\sin(ks)\sin(kt)/k^2$.

                                                    Helper: evaluate the second Bernoulli polynomial under the $\mathbb{Q}\to\mathbb{R}$ algebra map, giving $B_2(x) = x^2 - x + 1/6$.

                                                    theorem WienerConstruction.hasSum_cos_div_sq (θ : ) ( : θ Set.Icc 0 (2 * Real.pi)) :
                                                    HasSum (fun (n : ) => 1 / n ^ 2 * Real.cos (n * θ)) (θ ^ 2 / 4 - Real.pi * θ / 2 + Real.pi ^ 2 / 6)

                                                    Closed-form for the Fourier cosine series with $1/k^2$ coefficients on $[0,2\pi]$: $\sum_{n\ge 1} \cos(n\theta)/n^2 = \theta^2/4 - \pi\theta/2 + \pi^2/6$. This is the classical Bernoulli evaluation of the second Bernoulli polynomial.

                                                    theorem WienerConstruction.sin_mul_sin_eq' (k s t : ) :
                                                    Real.sin (k * s) * Real.sin (k * t) = (Real.cos (k * (t - s)) - Real.cos (k * (s + t))) / 2

                                                    Product-to-sum identity: $\sin(ks)\sin(kt) = \tfrac12\bigl(\cos(k(t-s)) - \cos(k(s+t))\bigr)$.

                                                    theorem WienerConstruction.tsum_sin_product_eq (s t : ) (hs : 0 s) (hs' : s Real.pi) (ht : 0 t) (ht' : t Real.pi) (hst : s t) :
                                                    ∑' (k : ), Real.sin (↑(k + 1) * s) * Real.sin (↑(k + 1) * t) / ↑(k + 1) ^ 2 = s * (Real.pi - t) / 2

                                                    Closed-form evaluation of the sine cross-product series on $[0,\pi]$: for $0 \le s \le t \le \pi$, $\sum_{k\ge 1}\sin(ks)\sin(kt)/k^2 = s(\pi-t)/2$. This is the off-diagonal Fourier expansion that yields the Brownian covariance $s \wedge t$.

                                                    theorem WienerConstruction.covariance_algebra_le (s t : ) (hst : s t) :
                                                    s * t / Real.pi + 2 / Real.pi * (s * (Real.pi - t) / 2) = min s t

                                                    Algebraic identity collapsing the Wiener covariance decomposition: when $s \le t$, $st/\pi + (2/\pi)\cdot s(\pi-t)/2 = s = s \wedge t$.

                                                    theorem WienerConstruction.wienerProcess_covariance {Ω : Type u_1} [MeasurableSpace Ω] {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] {a : Ω} (ha : GradientIntegrability.IsIIDStdGaussian a P) (s t : ) (hs : 0 s) (hs' : s Real.pi) (ht : 0 t) (ht' : t Real.pi) :
                                                    (ω : Ω), wienerProcess a s ω * wienerProcess a t ω P = min s t

                                                    The Brownian-motion covariance identity for the Wiener construction: for $s, t \in [0,\pi]$, the expectation of $W_s W_t$ equals $s \wedge t$ under any distribution of i.i.d. standard Gaussian coefficients.

                                                    theorem WienerConstruction.sq_intervalIntegral_le {g : } {L : } (hL : 0 < L) (hg_int : IntervalIntegrable g MeasureTheory.volume 0 L) (hg2_int : IntervalIntegrable (fun (t : ) => g t ^ 2) MeasureTheory.volume 0 L) :
                                                    ( (t : ) in 0..L, g t) ^ 2 L * (t : ) in 0..L, g t ^ 2

                                                    Cauchy-Schwarz on intervals: the square of an interval integral is bounded by the length times the integral of the square, $\bigl(\int_0^L g\bigr)^2 \le L\int_0^L g^2$.

                                                    theorem WienerConstruction.bessel_on_circle {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (ω : Ω) (r : ) (hr : 0 < r) (hr1 : r < 1) (u : Finset ) :
                                                    ku, (a (k + 1) ω) ^ 2 * r ^ (2 * k) 1 / (2 * Real.pi) * (t : ) in 0..2 * Real.pi, GradientIntegrability.powerSeriesDeriv a (r * Complex.exp (t * Complex.I)) ω ^ 2

                                                    Bessel's inequality on the circle of radius $r<1$: for any finite truncation $u$, $\sum_{k\in u}|a_{k+1}(\omega)|^2 r^{2k} \le \tfrac{1}{2\pi}\int_0^{2\pi}\|f'(re^{it})\|^2\,dt$, where $f'$ denotes the formal derivative of the random power series.

                                                    theorem WienerConstruction.powerSeriesDeriv_sq_intervalIntegrable {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (ω : Ω) (r : ) (hr : 0 < r) (hr1 : r < 1) :

                                                    The squared norm $\|f'(re^{it})\|^2$ of the random-power-series derivative is interval-integrable on $[0, 2\pi]$ for any $r \in (0,1)$.

                                                    theorem WienerConstruction.powerSeriesDeriv_pow4_intervalIntegrable {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (ω : Ω) (r : ) (hr : 0 < r) (hr1 : r < 1) :

                                                    The fourth-power norm $\|f'(re^{it})\|^4$ of the random-power-series derivative is interval-integrable on $[0, 2\pi]$ for any $r \in (0,1)$; needed later for the Cauchy-Schwarz step in the gradient bound.

                                                    theorem WienerConstruction.tsum_sq_coeff_le_gradient_bound {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (ω : Ω) (β : ) ( : 1 < β) (C : ) (hC : GradientIntegrability.weightedGradientIntegral a β ω C) :
                                                    HasSum (fun (k : ) => (a (k + 1) ω) ^ 2) (∑' (k : ), (a (k + 1) ω) ^ 2) ∑' (k : ), (a (k + 1) ω) ^ 2 4 * ((|C| + 1) / (2 * Real.pi)) + 1

                                                    Bessel-type $\ell^2$ bound on the random Fourier coefficients: if the weighted gradient integral $\int (1-r)^{\beta}\|f'(re^{it})\|^2$ is bounded by $C$, then the sequence $\|a_{k+1}(\omega)\|^2$ is summable with sum at most $4\sqrt{(|C|+1)/(2\pi)} + 1$.

                                                    theorem WienerConstruction.parseval_partial_sum_bound {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (ω : Ω) (β : ) ( : 1 < β) (C : ) (hC : GradientIntegrability.weightedGradientIntegral a β ω C) (u : Finset ) :
                                                    ku, (a (k + 1) ω) ^ 2 4 * ((|C| + 1) / (2 * Real.pi)) + 1

                                                    Uniform partial-sum bound: every finite Parseval partial sum of the squared random Fourier coefficients is bounded by $4\sqrt{(|C|+1)/(2\pi)} + 1$, given the weighted gradient integral bound $C$.

                                                    theorem WienerConstruction.parseval_coefficient_l2_bound {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (ω : Ω) (β : ) ( : 1 < β) (hfin : ∃ (C : ), GradientIntegrability.weightedGradientIntegral a β ω C) :
                                                    Summable fun (k : ) => (a (k + 1) ω) ^ 2

                                                    Parseval $\ell^2$-summability: if the weighted gradient integral is finite, the squared random Fourier coefficients $\|a_{k+1}(\omega)\|^2$ form a summable sequence.

                                                    theorem WienerConstruction.summable_div_of_sq_summable {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (ω : Ω) (hsq : Summable fun (k : ) => (a (k + 1) ω) ^ 2) :
                                                    Summable fun (k : ) => (a (k + 1) ω) / ↑(k + 1)

                                                    AM-GM bridge: if $(\|a_{k+1}(\omega)\|^2)$ is summable, then so is $(\|a_{k+1}(\omega)\|/(k+1))$, since $|a|/(k+1) \le \tfrac12(|a|^2 + 1/(k+1)^2)$ and the $1/(k+1)^2$ series converges.

                                                    theorem WienerConstruction.summable_randomPowerSeries_coefficients {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (ω : Ω) (β : ) ( : 1 < β) (hfin : ∃ (C : ), GradientIntegrability.weightedGradientIntegral a β ω C) :
                                                    Summable fun (k : ) => (a (k + 1) ω) / ↑(k + 1)

                                                    Summability of the random-power-series coefficients $\|a_{k+1}(\omega)\|/(k+1)$, granted a finite weighted gradient integral. This gives uniform convergence of $f(z) = \sum a_{k+1}(\omega) z^{k+1}/(k+1)$ on $\overline{\mathbb{D}}$.

                                                    theorem WienerConstruction.area_mvp_tsum_bound {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (ω : Ω) (β : ) ( : 1 < β) (C_star : ) (hC_star : GradientIntegrability.weightedGradientIntegral a β ω C_star) (z : ) (hz : z < 1) :
                                                    ∑' (k : ), (a (k + 1) ω) / ↑(k + 1) max 1 (|C_star| + 1) / 2 * (1 - z) ^ min ((β - 1) / 4) 1

                                                    Area-mean-value-property tsum bound: at any interior point $z\in\mathbb{D}$, the coefficient sum $\sum\|a_{k+1}(\omega)\|/(k+1)$ is dominated by $\tfrac12\max(1,|C_\star|+1)\,(1-\|z\|)^{\min((\beta-1)/4,1)}$, a quantitative local Hardy-space estimate.

                                                    theorem WienerConstruction.cauchy_bound_le_gradient_bound {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (ω : Ω) (β : ) ( : 1 < β) (C_star : ) (hC_star : GradientIntegrability.weightedGradientIntegral a β ω C_star) (z : ) (hz : z < 1) :
                                                    (∑' (k : ), (a (k + 1) ω) / ↑(k + 1)) / ((1 - z) / 2) max 1 (|C_star| + 1) * (1 - z) ^ (-1 + min ((β - 1) / 4) 1)

                                                    Cauchy-type derivative bound: dividing the coefficient sum by the radius $(1-\|z\|)/2$ produces a quantitative upper bound on the derivative norm at $z$, $\max(1,|C_\star|+1)(1-\|z\|)^{-1+\min((\beta-1)/4,1)}$.

                                                    theorem WienerConstruction.submean_area_gradient_bound {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (ω : Ω) (β : ) ( : 1 < β) (C_star : ) (hC_star : GradientIntegrability.weightedGradientIntegral a β ω C_star) (z : ) (hz : z < 1) :
                                                    fderiv (fun (w : ) => GradientIntegrability.randomPowerSeries a w ω) z max 1 (|C_star| + 1) * (1 - z) ^ (-1 + min ((β - 1) / 4) 1)

                                                    Submean-area gradient bound: the Frechet derivative of the random power series at $z\in\mathbb{D}$ satisfies $\|\nabla f(z)\| \le \max(1,|C_\star|+1)(1-\|z\|)^{-1+\min((\beta-1)/4,1)}$. This is Lemma 4 of the textbook, combining Cauchy's estimate with the area MVP.

                                                    theorem WienerConstruction.gradient_submean_bound {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (ω : Ω) (β : ) ( : 1 < β) (C_star : ) (hC_star : GradientIntegrability.weightedGradientIntegral a β ω C_star) (z : ) (hz : z < 1) :
                                                    fderiv (fun (w : ) => GradientIntegrability.randomPowerSeries a w ω) z max 1 (|C_star| + 1) * (1 - z) ^ (-1 + min ((β - 1) / 4) 1)

                                                    Restatement of submean_area_gradient_bound as a named pointwise gradient estimate, suitable for use in subsequent boundary-regularity proofs.

                                                    Continuity on the closed disk: granted a finite weighted gradient integral, $z\mapsto f(z) = \sum a_{k+1}(\omega)z^{k+1}/(k+1)$ is continuous on $\overline{\mathbb{D}}$ by Weierstrass M-test.

                                                    Real differentiability inside the disk: under the same finite weighted gradient hypothesis, $f$ is real-differentiable on the open disk $\mathbb{D}$, obtained via complex differentiability of a uniformly convergent power series.

                                                    theorem WienerConstruction.randomPowerSeries_gradient_bound {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (ω : Ω) (β : ) ( : 1 < β) (C_star : ) (hC_star : GradientIntegrability.weightedGradientIntegral a β ω C_star) :

                                                    Repackaging the submean gradient bound as a SatisfiesGradientBound predicate with constants $(\max(1,|C_\star|+1),\min((\beta-1)/4,1))$, the hypothesis needed for the abstract Hardy-Littlewood boundary-Hölder argument.

                                                    Lemma 4 packaged: if the weighted gradient integral is finite, the random power series $f$ is continuous on $\overline{\mathbb{D}}$, real-differentiable on $\mathbb{D}$, and satisfies a quantitative gradient bound for some $(C_g,\alpha)$ with $0<\alpha\le 1$ -- precisely the hypotheses of the abstract boundary-Hölder lemma.

                                                    theorem WienerConstruction.holder_boundary_implies_wiener_continuousOn {Ω : Type u_1} [MeasurableSpace Ω] (a : Ω) (ω : Ω) (C' α : ) (hC' : 0 < C') ( : 0 < α) (hholder : ∀ (t₁ t₂ : ), GradientIntegrability.randomPowerSeries a (circleMap 0 1 t₁) ω - GradientIntegrability.randomPowerSeries a (circleMap 0 1 t₂) ω C' * |t₁ - t₂| ^ α) (hsummable : ∀ (t : ), Summable fun (k : ) => (a (k + 1) ω) * circleMap 0 1 t ^ (k + 1) / ↑(k + 1)) :
                                                    ContinuousOn (fun (t : ) => wienerProcess a t ω) (Set.Icc 0 Real.pi)

                                                    Transfer step (Lemma 5): a Hölder estimate on the boundary trace $t\mapsto f(e^{it})$ implies continuity of the Wiener process $t\mapsto W_t$ on $[0,\pi]$. The imaginary part of the boundary values recovers the sine series defining $W_t$.

                                                    Almost-sure continuity (the crux of Theorem 2): for $P$-almost every sample path $\omega$, the Wiener process $t\mapsto W_t(\omega)$ is continuous on $[0,\pi]$. The proof chains the a.s. finiteness of the weighted gradient integral, the gradient bound, the boundary Hölder lemma, and the boundary transfer to the imaginary part of the random power series.

                                                    Main theorem of the chapter (Theorem 2): the Wiener construction $W(t) = c_0 a_0 t + c_1 \sum_{k\ge 1} a_k \sin(kt)/k$, with $(a_k)$ i.i.d. standard Gaussian, is a Brownian motion on $[0,\pi]$, i.e. satisfies the four defining properties: starts at $0$, has mean $0$, is a Gaussian process with $\mathbb{E}(W_s W_t) = s\wedge t$, and has a.s. continuous sample paths.