File: Mathlib/Probability/Process/Filtration.lean

full_name: MeasureTheory.Filtration.le'
code: /-- A `Filtration` on a measurable space `Ω` with σ-algebra `m` is a monotone
sequence of sub-σ-algebras of `m`. -/
structure Filtration {Ω : Type*} (ι : Type*) [Preorder ι] (m : MeasurableSpace Ω) where
  seq : ι → MeasurableSpace Ω
  mono' : Monotone seq
  le' : ∀ i : ι, seq i ≤ m
goal: ↑self i ≤ m

full_name: MeasureTheory.Filtration.mono'
code: /-- A `Filtration` on a measurable space `Ω` with σ-algebra `m` is a monotone
sequence of sub-σ-algebras of `m`. -/
structure Filtration {Ω : Type*} (ι : Type*) [Preorder ι] (m : MeasurableSpace Ω) where
  seq : ι → MeasurableSpace Ω
  mono' : Monotone seq
  le' : ∀ i : ι, seq i ≤ m
goal: Monotone ↑self

full_name: MeasureTheory.Filtration
code: /-- A `Filtration` on a measurable space `Ω` with σ-algebra `m` is a monotone
sequence of sub-σ-algebras of `m`. -/
structure Filtration {Ω : Type*} (ι : Type*) [Preorder ι] (m : MeasurableSpace Ω) where
  seq : ι → MeasurableSpace Ω
  mono' : Monotone seq
  le' : ∀ i : ι, seq i ≤ m
goal: Type (max u_1 u_2)

full_name: MeasureTheory.Filtration.seq
code: /-- A `Filtration` on a measurable space `Ω` with σ-algebra `m` is a monotone
sequence of sub-σ-algebras of `m`. -/
structure Filtration {Ω : Type*} (ι : Type*) [Preorder ι] (m : MeasurableSpace Ω) where
  seq : ι → MeasurableSpace Ω
  mono' : Monotone seq
  le' : ∀ i : ι, seq i ≤ m
goal: ι → MeasurableSpace Ω

full_name: MeasureTheory.instCoeFunFiltrationForallMeasurableSpace
code: instance [Preorder ι] : CoeFun (Filtration ι m) fun _ => ι → MeasurableSpace Ω 
goal: CoeFun (MeasureTheory.Filtration ι m) fun x => ι → MeasurableSpace Ω

full_name: MeasureTheory.Filtration.mono
code: protected theorem mono {i j : ι} (f : Filtration ι m) (hij : i ≤ j) : f i ≤ f j 
goal: ↑f i ≤ ↑f j

full_name: MeasureTheory.Filtration.le
code: protected theorem le (f : Filtration ι m) (i : ι) : f i ≤ m 
goal: ↑f i ≤ m

full_name: MeasureTheory.Filtration.ext
code: @[ext]
protected theorem ext {f g : Filtration ι m} (h : (f : ι → MeasurableSpace Ω) = g) : f = g 
goal: f = g

full_name: MeasureTheory.Filtration.const
code: /-- The constant filtration which is equal to `m` for all `i : ι`. -/
def const (m' : MeasurableSpace Ω) (hm' : m' ≤ m) : Filtration ι m 
goal: MeasureTheory.Filtration ι m

full_name: MeasureTheory.Filtration.const_apply
code: @[simp]
theorem const_apply {m' : MeasurableSpace Ω} {hm' : m' ≤ m} (i : ι) : const ι m' hm' i = m' 
goal: ↑(MeasureTheory.Filtration.const ι m' hm') i = m'

full_name: MeasureTheory.Filtration.instInhabited
code: instance : Inhabited (Filtration ι m) 
goal: Inhabited (MeasureTheory.Filtration ι m)

full_name: MeasureTheory.Filtration.instLE
code: instance : LE (Filtration ι m) 
goal: LE (MeasureTheory.Filtration ι m)

full_name: MeasureTheory.Filtration.instBot
code: instance : Bot (Filtration ι m) 
goal: Bot (MeasureTheory.Filtration ι m)

full_name: MeasureTheory.Filtration.instTop
code: instance : Top (Filtration ι m) 
goal: Top (MeasureTheory.Filtration ι m)

full_name: MeasureTheory.Filtration.instSup
code: instance : Sup (Filtration ι m) 
goal: Sup (MeasureTheory.Filtration ι m)

full_name: MeasureTheory.Filtration.coeFn_sup
code: @[norm_cast]
theorem coeFn_sup {f g : Filtration ι m} : ⇑(f ⊔ g) = ⇑f ⊔ ⇑g 
goal: ↑(f ⊔ g) = ↑f ⊔ ↑g

full_name: MeasureTheory.Filtration.instInf
code: instance : Inf (Filtration ι m) 
goal: Inf (MeasureTheory.Filtration ι m)

full_name: MeasureTheory.Filtration.coeFn_inf
code: @[norm_cast]
theorem coeFn_inf {f g : Filtration ι m} : ⇑(f ⊓ g) = ⇑f ⊓ ⇑g 
goal: ↑(f ⊓ g) = ↑f ⊓ ↑g

full_name: MeasureTheory.Filtration.instSupSet
code: instance : SupSet (Filtration ι m) 
goal: SupSet (MeasureTheory.Filtration ι m)

full_name: MeasureTheory.Filtration.sSup_def
code: theorem sSup_def (s : Set (Filtration ι m)) (i : ι) :
    sSup s i = sSup ((fun f : Filtration ι m => f i) '' s) 
goal: ↑(sSup s) i = sSup ((fun f => ↑f i) '' s)

full_name: MeasureTheory.Filtration.instInfSet
code: noncomputable instance : InfSet (Filtration ι m) 
goal: InfSet (MeasureTheory.Filtration ι m)

full_name: MeasureTheory.Filtration.sInf_def
code: theorem sInf_def (s : Set (Filtration ι m)) (i : ι) :
    sInf s i = if Set.Nonempty s then sInf ((fun f : Filtration ι m => f i) '' s) else m 
goal: ↑(sInf s) i = if s.Nonempty then sInf ((fun f => ↑f i) '' s) else m

full_name: MeasureTheory.Filtration.instCompleteLattice
code: noncomputable instance instCompleteLattice : CompleteLattice (Filtration ι m) 
goal: CompleteLattice (MeasureTheory.Filtration ι m)

full_name: MeasureTheory.measurableSet_of_filtration
code: theorem measurableSet_of_filtration [Preorder ι] {f : Filtration ι m} {s : Set Ω} {i : ι}
    (hs : MeasurableSet[f i] s) : MeasurableSet[m] s 
goal: MeasurableSet s

full_name: MeasureTheory.SigmaFiniteFiltration
code: /-- A measure is σ-finite with respect to filtration if it is σ-finite with respect
to all the sub-σ-algebra of the filtration. -/
class SigmaFiniteFiltration [Preorder ι] (μ : Measure Ω) (f : Filtration ι m) : Prop where
  SigmaFinite : ∀ i : ι, SigmaFinite (μ.trim (f.le i))
goal: Prop

full_name: MeasureTheory.SigmaFiniteFiltration.SigmaFinite
code: /-- A measure is σ-finite with respect to filtration if it is σ-finite with respect
to all the sub-σ-algebra of the filtration. -/
class SigmaFiniteFiltration [Preorder ι] (μ : Measure Ω) (f : Filtration ι m) : Prop where
  SigmaFinite : ∀ i : ι, SigmaFinite (μ.trim (f.le i))
goal: MeasureTheory.SigmaFinite (μ.trim ⋯)

full_name: MeasureTheory.sigmaFinite_of_sigmaFiniteFiltration
code: instance sigmaFinite_of_sigmaFiniteFiltration [Preorder ι] (μ : Measure Ω) (f : Filtration ι m)
    [hf : SigmaFiniteFiltration μ f] (i : ι) : SigmaFinite (μ.trim (f.le i)) 
goal: MeasureTheory.SigmaFinite (μ.trim ⋯)

full_name: MeasureTheory.IsFiniteMeasure.sigmaFiniteFiltration
code: instance (priority := 100) IsFiniteMeasure.sigmaFiniteFiltration [Preorder ι] (μ : Measure Ω)
    (f : Filtration ι m) [IsFiniteMeasure μ] : SigmaFiniteFiltration μ f 
goal: MeasureTheory.SigmaFiniteFiltration μ f

full_name: MeasureTheory.Integrable.uniformIntegrable_condexp_filtration
code: /-- Given an integrable function `g`, the conditional expectations of `g` with respect to a
filtration is uniformly integrable. -/
theorem Integrable.uniformIntegrable_condexp_filtration [Preorder ι] {μ : Measure Ω}
    [IsFiniteMeasure μ] {f : Filtration ι m} {g : Ω → ℝ} (hg : Integrable g μ) :
    UniformIntegrable (fun i => μ[g|f i]) 1 μ 
goal: MeasureTheory.UniformIntegrable (fun i => μ[g|↑f i]) 1 μ

full_name: MeasureTheory.filtrationOfSet
code: /-- Given a sequence of measurable sets `(sₙ)`, `filtrationOfSet` is the smallest filtration
such that `sₙ` is measurable with respect to the `n`-th sub-σ-algebra in `filtrationOfSet`. -/
def filtrationOfSet {s : ι → Set Ω} (hsm : ∀ i, MeasurableSet (s i)) : Filtration ι m 
goal: MeasureTheory.Filtration ι m

full_name: MeasureTheory.measurableSet_filtrationOfSet
code: theorem measurableSet_filtrationOfSet {s : ι → Set Ω} (hsm : ∀ i, MeasurableSet[m] (s i)) (i : ι)
    {j : ι} (hj : j ≤ i) : MeasurableSet[filtrationOfSet hsm i] (s j) 
goal: MeasurableSet (s j)

full_name: MeasureTheory.measurableSet_filtrationOfSet'
code: theorem measurableSet_filtrationOfSet' {s : ι → Set Ω} (hsm : ∀ n, MeasurableSet[m] (s n))
    (i : ι) : MeasurableSet[filtrationOfSet hsm i] (s i) 
goal: MeasurableSet (s i)

full_name: MeasureTheory.Filtration.natural
code: /-- Given a sequence of functions, the natural filtration is the smallest sequence
of σ-algebras such that that sequence of functions is measurable with respect to
the filtration. -/
def natural (u : ι → Ω → β) (hum : ∀ i, StronglyMeasurable (u i)) : Filtration ι m 
goal: MeasureTheory.Filtration ι m

full_name: MeasureTheory.Filtration.filtrationOfSet_eq_natural
code: theorem filtrationOfSet_eq_natural [MulZeroOneClass β] [Nontrivial β] {s : ι → Set Ω}
    (hsm : ∀ i, MeasurableSet[m] (s i)) :
    filtrationOfSet hsm = natural (fun i => (s i).indicator (fun _ => 1 : Ω → β)) fun i =>
      stronglyMeasurable_one.indicator (hsm i) 
goal: MeasureTheory.filtrationOfSet hsm = MeasureTheory.Filtration.natural (fun i => (s i).indicator fun x => 1) ⋯

full_name: MeasureTheory.Filtration.limitProcess
code: /-- Given a process `f` and a filtration `ℱ`, if `f` converges to some `g` almost everywhere and
`g` is `⨆ n, ℱ n`-measurable, then `limitProcess f ℱ μ` chooses said `g`, else it returns 0.

This definition is used to phrase the a.e. martingale convergence theorem
`Submartingale.ae_tendsto_limitProcess` where an L¹-bounded submartingale `f` adapted to `ℱ`
converges to `limitProcess f ℱ μ` `μ`-almost everywhere. -/
noncomputable def limitProcess (f : ι → Ω → E) (ℱ : Filtration ι m)
    (μ : Measure Ω) 
goal: Ω → E

full_name: MeasureTheory.Filtration.stronglyMeasurable_limitProcess
code: theorem stronglyMeasurable_limitProcess : StronglyMeasurable[⨆ n, ℱ n] (limitProcess f ℱ μ) 
goal: MeasureTheory.StronglyMeasurable (MeasureTheory.Filtration.limitProcess f ℱ μ)

full_name: MeasureTheory.Filtration.stronglyMeasurable_limit_process'
code: theorem stronglyMeasurable_limit_process' : StronglyMeasurable[m] (limitProcess f ℱ μ) 
goal: MeasureTheory.StronglyMeasurable (MeasureTheory.Filtration.limitProcess f ℱ μ)

full_name: MeasureTheory.Filtration.memℒp_limitProcess_of_eLpNorm_bdd
code: theorem memℒp_limitProcess_of_eLpNorm_bdd {R : ℝ≥0} {p : ℝ≥0∞} {F : Type*} [NormedAddCommGroup F]
    {ℱ : Filtration ℕ m} {f : ℕ → Ω → F} (hfm : ∀ n, AEStronglyMeasurable (f n) μ)
    (hbdd : ∀ n, eLpNorm (f n) p μ ≤ R) : Memℒp (limitProcess f ℱ μ) p μ 
goal: MeasureTheory.Memℒp (MeasureTheory.Filtration.limitProcess f ℱ μ) p μ