File: Mathlib/Probability/Process/Adapted.lean

full_name: MeasureTheory.Adapted
code: /-- A sequence of functions `u` is adapted to a filtration `f` if for all `i`,
`u i` is `f i`-measurable. -/
def Adapted (f : Filtration ι m) (u : ι → Ω → β) : Prop 
goal: Prop

full_name: MeasureTheory.Adapted.mul
code: @[to_additive]
protected theorem mul [Mul β] [ContinuousMul β] (hu : Adapted f u) (hv : Adapted f v) :
    Adapted f (u * v) 
goal: MeasureTheory.Adapted f (u * v)

full_name: MeasureTheory.Adapted.add
code: @[to_additive]
protected theorem mul [Mul β] [ContinuousMul β] (hu : Adapted f u) (hv : Adapted f v) :
    Adapted f (u * v) 
goal: MeasureTheory.Adapted f (u + v)

full_name: MeasureTheory.Adapted.div
code: @[to_additive]
protected theorem div [Div β] [ContinuousDiv β] (hu : Adapted f u) (hv : Adapted f v) :
    Adapted f (u / v) 
goal: MeasureTheory.Adapted f (u / v)

full_name: MeasureTheory.Adapted.sub
code: @[to_additive]
protected theorem div [Div β] [ContinuousDiv β] (hu : Adapted f u) (hv : Adapted f v) :
    Adapted f (u / v) 
goal: MeasureTheory.Adapted f (u - v)

full_name: MeasureTheory.Adapted.inv
code: @[to_additive]
protected theorem inv [Group β] [TopologicalGroup β] (hu : Adapted f u) :
    Adapted f u⁻¹ 
goal: MeasureTheory.Adapted f u⁻¹

full_name: MeasureTheory.Adapted.neg
code: @[to_additive]
protected theorem inv [Group β] [TopologicalGroup β] (hu : Adapted f u) :
    Adapted f u⁻¹ 
goal: MeasureTheory.Adapted f (-u)

full_name: MeasureTheory.Adapted.smul
code: protected theorem smul [SMul ℝ β] [ContinuousSMul ℝ β] (c : ℝ) (hu : Adapted f u) :
    Adapted f (c • u) 
goal: MeasureTheory.Adapted f (c • u)

full_name: MeasureTheory.Adapted.stronglyMeasurable
code: protected theorem stronglyMeasurable {i : ι} (hf : Adapted f u) : StronglyMeasurable[m] (u i) 
goal: MeasureTheory.StronglyMeasurable (u i)

full_name: MeasureTheory.Adapted.stronglyMeasurable_le
code: theorem stronglyMeasurable_le {i j : ι} (hf : Adapted f u) (hij : i ≤ j) :
    StronglyMeasurable[f j] (u i) 
goal: MeasureTheory.StronglyMeasurable (u i)

full_name: MeasureTheory.adapted_const
code: theorem adapted_const (f : Filtration ι m) (x : β) : Adapted f fun _ _ => x 
goal: MeasureTheory.Adapted f fun x_1 x_2 => x

full_name: MeasureTheory.adapted_zero
code: theorem adapted_zero [Zero β] (f : Filtration ι m) : Adapted f (0 : ι → Ω → β) 
goal: MeasureTheory.Adapted f 0

full_name: MeasureTheory.Filtration.adapted_natural
code: theorem Filtration.adapted_natural [MetrizableSpace β] [mβ : MeasurableSpace β] [BorelSpace β]
    {u : ι → Ω → β} (hum : ∀ i, StronglyMeasurable[m] (u i)) :
    Adapted (Filtration.natural u hum) u 
goal: MeasureTheory.Adapted (MeasureTheory.Filtration.natural u hum) u

full_name: MeasureTheory.ProgMeasurable
code: /-- Progressively measurable process. A sequence of functions `u` is said to be progressively
measurable with respect to a filtration `f` if at each point in time `i`, `u` restricted to
`Set.Iic i × Ω` is measurable with respect to the product `MeasurableSpace` structure where the
σ-algebra used for `Ω` is `f i`.
The usual definition uses the interval `[0,i]`, which we replace by `Set.Iic i`. We recover the
usual definition for index types `ℝ≥0` or `ℕ`. -/
def ProgMeasurable [MeasurableSpace ι] (f : Filtration ι m) (u : ι → Ω → β) : Prop 
goal: Prop

full_name: MeasureTheory.progMeasurable_const
code: theorem progMeasurable_const [MeasurableSpace ι] (f : Filtration ι m) (b : β) :
    ProgMeasurable f (fun _ _ => b : ι → Ω → β) 
goal: MeasureTheory.ProgMeasurable f fun x x => b

full_name: MeasureTheory.ProgMeasurable.adapted
code: protected theorem adapted (h : ProgMeasurable f u) : Adapted f u 
goal: MeasureTheory.Adapted f u

full_name: MeasureTheory.ProgMeasurable.comp
code: protected theorem comp {t : ι → Ω → ι} [TopologicalSpace ι] [BorelSpace ι] [MetrizableSpace ι]
    (h : ProgMeasurable f u) (ht : ProgMeasurable f t) (ht_le : ∀ i ω, t i ω ≤ i) :
    ProgMeasurable f fun i ω => u (t i ω) ω 
goal: MeasureTheory.ProgMeasurable f fun i ω => u (t i ω) ω

full_name: MeasureTheory.ProgMeasurable.add
code: @[to_additive]
protected theorem mul [Mul β] [ContinuousMul β] (hu : ProgMeasurable f u)
    (hv : ProgMeasurable f v) : ProgMeasurable f fun i ω => u i ω * v i ω 
goal: MeasureTheory.ProgMeasurable f fun i ω => u i ω + v i ω

full_name: MeasureTheory.ProgMeasurable.mul
code: @[to_additive]
protected theorem mul [Mul β] [ContinuousMul β] (hu : ProgMeasurable f u)
    (hv : ProgMeasurable f v) : ProgMeasurable f fun i ω => u i ω * v i ω 
goal: MeasureTheory.ProgMeasurable f fun i ω => u i ω * v i ω

full_name: MeasureTheory.ProgMeasurable.finset_prod'
code: @[to_additive]
protected theorem finset_prod' {γ} [CommMonoid β] [ContinuousMul β] {U : γ → ι → Ω → β}
    {s : Finset γ} (h : ∀ c ∈ s, ProgMeasurable f (U c)) : ProgMeasurable f (∏ c ∈ s, U c) 
goal: MeasureTheory.ProgMeasurable f (∏ c ∈ s, U c)

full_name: MeasureTheory.ProgMeasurable.finset_sum'
code: @[to_additive]
protected theorem finset_prod' {γ} [CommMonoid β] [ContinuousMul β] {U : γ → ι → Ω → β}
    {s : Finset γ} (h : ∀ c ∈ s, ProgMeasurable f (U c)) : ProgMeasurable f (∏ c ∈ s, U c) 
goal: MeasureTheory.ProgMeasurable f (∑ c ∈ s, U c)

full_name: MeasureTheory.ProgMeasurable.finset_prod
code: @[to_additive]
protected theorem finset_prod {γ} [CommMonoid β] [ContinuousMul β] {U : γ → ι → Ω → β}
    {s : Finset γ} (h : ∀ c ∈ s, ProgMeasurable f (U c)) :
    ProgMeasurable f fun i a => ∏ c ∈ s, U c i a 
goal: MeasureTheory.ProgMeasurable f fun i a => ∏ c ∈ s, U c i a

full_name: MeasureTheory.ProgMeasurable.finset_sum
code: @[to_additive]
protected theorem finset_prod {γ} [CommMonoid β] [ContinuousMul β] {U : γ → ι → Ω → β}
    {s : Finset γ} (h : ∀ c ∈ s, ProgMeasurable f (U c)) :
    ProgMeasurable f fun i a => ∏ c ∈ s, U c i a 
goal: MeasureTheory.ProgMeasurable f fun i a => ∑ c ∈ s, U c i a

full_name: MeasureTheory.ProgMeasurable.neg
code: @[to_additive]
protected theorem inv [Group β] [TopologicalGroup β] (hu : ProgMeasurable f u) :
    ProgMeasurable f fun i ω => (u i ω)⁻¹ 
goal: MeasureTheory.ProgMeasurable f fun i ω => -u i ω

full_name: MeasureTheory.ProgMeasurable.inv
code: @[to_additive]
protected theorem inv [Group β] [TopologicalGroup β] (hu : ProgMeasurable f u) :
    ProgMeasurable f fun i ω => (u i ω)⁻¹ 
goal: MeasureTheory.ProgMeasurable f fun i ω => (u i ω)⁻¹

full_name: MeasureTheory.ProgMeasurable.sub
code: @[to_additive]
protected theorem div [Group β] [TopologicalGroup β] (hu : ProgMeasurable f u)
    (hv : ProgMeasurable f v) : ProgMeasurable f fun i ω => u i ω / v i ω 
goal: MeasureTheory.ProgMeasurable f fun i ω => u i ω - v i ω

full_name: MeasureTheory.ProgMeasurable.div
code: @[to_additive]
protected theorem div [Group β] [TopologicalGroup β] (hu : ProgMeasurable f u)
    (hv : ProgMeasurable f v) : ProgMeasurable f fun i ω => u i ω / v i ω 
goal: MeasureTheory.ProgMeasurable f fun i ω => u i ω / v i ω

full_name: MeasureTheory.progMeasurable_of_tendsto'
code: theorem progMeasurable_of_tendsto' {γ} [MeasurableSpace ι] [PseudoMetrizableSpace β]
    (fltr : Filter γ) [fltr.NeBot] [fltr.IsCountablyGenerated] {U : γ → ι → Ω → β}
    (h : ∀ l, ProgMeasurable f (U l)) (h_tendsto : Tendsto U fltr (𝓝 u)) : ProgMeasurable f u 
goal: MeasureTheory.ProgMeasurable f u

full_name: MeasureTheory.progMeasurable_of_tendsto
code: theorem progMeasurable_of_tendsto [MeasurableSpace ι] [PseudoMetrizableSpace β] {U : ℕ → ι → Ω → β}
    (h : ∀ l, ProgMeasurable f (U l)) (h_tendsto : Tendsto U atTop (𝓝 u)) : ProgMeasurable f u 
goal: MeasureTheory.ProgMeasurable f u

full_name: MeasureTheory.Adapted.progMeasurable_of_continuous
code: /-- A continuous and adapted process is progressively measurable. -/
theorem Adapted.progMeasurable_of_continuous [TopologicalSpace ι] [MetrizableSpace ι]
    [SecondCountableTopology ι] [MeasurableSpace ι] [OpensMeasurableSpace ι]
    [PseudoMetrizableSpace β] (h : Adapted f u) (hu_cont : ∀ ω, Continuous fun i => u i ω) :
    ProgMeasurable f u 
goal: MeasureTheory.ProgMeasurable f u

full_name: MeasureTheory.Adapted.progMeasurable_of_discrete
code: /-- For filtrations indexed by a discrete order, `Adapted` and `ProgMeasurable` are equivalent.
This lemma provides `Adapted f u → ProgMeasurable f u`.
See `ProgMeasurable.adapted` for the reverse direction, which is true more generally. -/
theorem Adapted.progMeasurable_of_discrete [TopologicalSpace ι] [DiscreteTopology ι]
    [SecondCountableTopology ι] [MeasurableSpace ι] [OpensMeasurableSpace ι]
    [PseudoMetrizableSpace β] (h : Adapted f u) : ProgMeasurable f u 
goal: MeasureTheory.ProgMeasurable f u

full_name: MeasureTheory.Predictable.adapted
code: theorem Predictable.adapted {f : Filtration ℕ m} {u : ℕ → Ω → β} (hu : Adapted f fun n => u (n + 1))
    (hu0 : StronglyMeasurable[f 0] (u 0)) : Adapted f u 
goal: MeasureTheory.Adapted f u