File: Mathlib/Probability/Process/Stopping.lean

full_name: MeasureTheory.IsStoppingTime
code: /-- A stopping time with respect to some filtration `f` is a function
`τ` such that for all `i`, the preimage of `{j | j ≤ i}` along `τ` is measurable
with respect to `f i`.

Intuitively, the stopping time `τ` describes some stopping rule such that at time
`i`, we may determine it with the information we have at time `i`. -/
def IsStoppingTime [Preorder ι] (f : Filtration ι m) (τ : Ω → ι) 
goal: Prop

full_name: MeasureTheory.isStoppingTime_const
code: theorem isStoppingTime_const [Preorder ι] (f : Filtration ι m) (i : ι) :
    IsStoppingTime f fun _ => i 
goal: MeasureTheory.IsStoppingTime f fun x => i

full_name: MeasureTheory.IsStoppingTime.measurableSet_le
code: protected theorem IsStoppingTime.measurableSet_le (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[f i] {ω | τ ω ≤ i} 
goal: MeasurableSet {ω | τ ω ≤ i}

full_name: MeasureTheory.IsStoppingTime.measurableSet_lt_of_pred
code: theorem IsStoppingTime.measurableSet_lt_of_pred [PredOrder ι] (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[f i] {ω | τ ω < i} 
goal: MeasurableSet {ω | τ ω < i}

full_name: MeasureTheory.IsStoppingTime.measurableSet_eq_of_countable_range
code: protected theorem measurableSet_eq_of_countable_range (hτ : IsStoppingTime f τ)
    (h_countable : (Set.range τ).Countable) (i : ι) : MeasurableSet[f i] {ω | τ ω = i} 
goal: MeasurableSet {ω | τ ω = i}

full_name: MeasureTheory.IsStoppingTime.measurableSet_eq_of_countable
code: protected theorem measurableSet_eq_of_countable [Countable ι] (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[f i] {ω | τ ω = i} 
goal: MeasurableSet {ω | τ ω = i}

full_name: MeasureTheory.IsStoppingTime.measurableSet_lt_of_countable_range
code: protected theorem measurableSet_lt_of_countable_range (hτ : IsStoppingTime f τ)
    (h_countable : (Set.range τ).Countable) (i : ι) : MeasurableSet[f i] {ω | τ ω < i} 
goal: MeasurableSet {ω | τ ω < i}

full_name: MeasureTheory.IsStoppingTime.measurableSet_lt_of_countable
code: protected theorem measurableSet_lt_of_countable [Countable ι] (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[f i] {ω | τ ω < i} 
goal: MeasurableSet {ω | τ ω < i}

full_name: MeasureTheory.IsStoppingTime.measurableSet_ge_of_countable_range
code: protected theorem measurableSet_ge_of_countable_range {ι} [LinearOrder ι] {τ : Ω → ι}
    {f : Filtration ι m} (hτ : IsStoppingTime f τ) (h_countable : (Set.range τ).Countable) (i : ι) :
    MeasurableSet[f i] {ω | i ≤ τ ω} 
goal: MeasurableSet {ω | i ≤ τ ω}

full_name: MeasureTheory.IsStoppingTime.measurableSet_ge_of_countable
code: protected theorem measurableSet_ge_of_countable {ι} [LinearOrder ι] {τ : Ω → ι} {f : Filtration ι m}
    [Countable ι] (hτ : IsStoppingTime f τ) (i : ι) : MeasurableSet[f i] {ω | i ≤ τ ω} 
goal: MeasurableSet {ω | i ≤ τ ω}

full_name: MeasureTheory.IsStoppingTime.measurableSet_gt
code: theorem IsStoppingTime.measurableSet_gt (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[f i] {ω | i < τ ω} 
goal: MeasurableSet {ω | i < τ ω}

full_name: MeasureTheory.IsStoppingTime.measurableSet_lt_of_isLUB
code: /-- Auxiliary lemma for `MeasureTheory.IsStoppingTime.measurableSet_lt`. -/
theorem IsStoppingTime.measurableSet_lt_of_isLUB (hτ : IsStoppingTime f τ) (i : ι)
    (h_lub : IsLUB (Set.Iio i) i) : MeasurableSet[f i] {ω | τ ω < i} 
goal: MeasurableSet {ω | τ ω < i}

full_name: MeasureTheory.IsStoppingTime.measurableSet_lt
code: theorem IsStoppingTime.measurableSet_lt (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[f i] {ω | τ ω < i} 
goal: MeasurableSet {ω | τ ω < i}

full_name: MeasureTheory.IsStoppingTime.measurableSet_ge
code: theorem IsStoppingTime.measurableSet_ge (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[f i] {ω | i ≤ τ ω} 
goal: MeasurableSet {ω | i ≤ τ ω}

full_name: MeasureTheory.IsStoppingTime.measurableSet_eq
code: theorem IsStoppingTime.measurableSet_eq (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[f i] {ω | τ ω = i} 
goal: MeasurableSet {ω | τ ω = i}

full_name: MeasureTheory.IsStoppingTime.measurableSet_eq_le
code: theorem IsStoppingTime.measurableSet_eq_le (hτ : IsStoppingTime f τ) {i j : ι} (hle : i ≤ j) :
    MeasurableSet[f j] {ω | τ ω = i} 
goal: MeasurableSet {ω | τ ω = i}

full_name: MeasureTheory.IsStoppingTime.measurableSet_lt_le
code: theorem IsStoppingTime.measurableSet_lt_le (hτ : IsStoppingTime f τ) {i j : ι} (hle : i ≤ j) :
    MeasurableSet[f j] {ω | τ ω < i} 
goal: MeasurableSet {ω | τ ω < i}

full_name: MeasureTheory.isStoppingTime_of_measurableSet_eq
code: theorem isStoppingTime_of_measurableSet_eq [Preorder ι] [Countable ι] {f : Filtration ι m}
    {τ : Ω → ι} (hτ : ∀ i, MeasurableSet[f i] {ω | τ ω = i}) : IsStoppingTime f τ 
goal: MeasureTheory.IsStoppingTime f τ

full_name: MeasureTheory.IsStoppingTime.max
code: protected theorem max [LinearOrder ι] {f : Filtration ι m} {τ π : Ω → ι} (hτ : IsStoppingTime f τ)
    (hπ : IsStoppingTime f π) : IsStoppingTime f fun ω => max (τ ω) (π ω) 
goal: MeasureTheory.IsStoppingTime f fun ω => max (τ ω) (π ω)

full_name: MeasureTheory.IsStoppingTime.max_const
code: protected theorem max_const [LinearOrder ι] {f : Filtration ι m} {τ : Ω → ι}
    (hτ : IsStoppingTime f τ) (i : ι) : IsStoppingTime f fun ω => max (τ ω) i 
goal: MeasureTheory.IsStoppingTime f fun ω => max (τ ω) i

full_name: MeasureTheory.IsStoppingTime.min
code: protected theorem min [LinearOrder ι] {f : Filtration ι m} {τ π : Ω → ι} (hτ : IsStoppingTime f τ)
    (hπ : IsStoppingTime f π) : IsStoppingTime f fun ω => min (τ ω) (π ω) 
goal: MeasureTheory.IsStoppingTime f fun ω => min (τ ω) (π ω)

full_name: MeasureTheory.IsStoppingTime.min_const
code: protected theorem min_const [LinearOrder ι] {f : Filtration ι m} {τ : Ω → ι}
    (hτ : IsStoppingTime f τ) (i : ι) : IsStoppingTime f fun ω => min (τ ω) i 
goal: MeasureTheory.IsStoppingTime f fun ω => min (τ ω) i

full_name: MeasureTheory.IsStoppingTime.add_const
code: theorem add_const [AddGroup ι] [Preorder ι] [CovariantClass ι ι (Function.swap (· + ·)) (· ≤ ·)]
    [CovariantClass ι ι (· + ·) (· ≤ ·)] {f : Filtration ι m} {τ : Ω → ι} (hτ : IsStoppingTime f τ)
    {i : ι} (hi : 0 ≤ i) : IsStoppingTime f fun ω => τ ω + i 
goal: MeasureTheory.IsStoppingTime f fun ω => τ ω + i

full_name: MeasureTheory.IsStoppingTime.add_const_nat
code: theorem add_const_nat {f : Filtration ℕ m} {τ : Ω → ℕ} (hτ : IsStoppingTime f τ) {i : ℕ} :
    IsStoppingTime f fun ω => τ ω + i 
goal: MeasureTheory.IsStoppingTime f fun ω => τ ω + i

full_name: MeasureTheory.IsStoppingTime.add
code: theorem add {f : Filtration ℕ m} {τ π : Ω → ℕ} (hτ : IsStoppingTime f τ) (hπ : IsStoppingTime f π) :
    IsStoppingTime f (τ + π) 
goal: MeasureTheory.IsStoppingTime f (τ + π)

full_name: MeasureTheory.IsStoppingTime.measurableSpace
code: /-- The associated σ-algebra with a stopping time. -/
protected def measurableSpace (hτ : IsStoppingTime f τ) : MeasurableSpace Ω 
goal: MeasurableSpace Ω

full_name: MeasureTheory.IsStoppingTime.measurableSet
code: protected theorem measurableSet (hτ : IsStoppingTime f τ) (s : Set Ω) :
    MeasurableSet[hτ.measurableSpace] s ↔ ∀ i : ι, MeasurableSet[f i] (s ∩ {ω | τ ω ≤ i}) 
goal: MeasurableSet s ↔ ∀ (i : ι), MeasurableSet (s ∩ {ω | τ ω ≤ i})

full_name: MeasureTheory.IsStoppingTime.measurableSpace_mono
code: theorem measurableSpace_mono (hτ : IsStoppingTime f τ) (hπ : IsStoppingTime f π) (hle : τ ≤ π) :
    hτ.measurableSpace ≤ hπ.measurableSpace 
goal: hτ.measurableSpace ≤ hπ.measurableSpace

full_name: MeasureTheory.IsStoppingTime.measurableSpace_le_of_countable
code: theorem measurableSpace_le_of_countable [Countable ι] (hτ : IsStoppingTime f τ) :
    hτ.measurableSpace ≤ m 
goal: hτ.measurableSpace ≤ m

full_name: MeasureTheory.IsStoppingTime.measurableSpace_le'
code: theorem measurableSpace_le' [IsCountablyGenerated (atTop : Filter ι)] [(atTop : Filter ι).NeBot]
    (hτ : IsStoppingTime f τ) : hτ.measurableSpace ≤ m 
goal: hτ.measurableSpace ≤ m

full_name: MeasureTheory.IsStoppingTime.measurableSpace_le
code: theorem measurableSpace_le {ι} [SemilatticeSup ι] {f : Filtration ι m} {τ : Ω → ι}
    [IsCountablyGenerated (atTop : Filter ι)] (hτ : IsStoppingTime f τ) :
    hτ.measurableSpace ≤ m 
goal: hτ.measurableSpace ≤ m

full_name: MeasureTheory.IsStoppingTime.measurableSpace_const
code: @[simp]
theorem measurableSpace_const (f : Filtration ι m) (i : ι) :
    (isStoppingTime_const f i).measurableSpace = f i 
goal: ⋯.measurableSpace = ↑f i

full_name: MeasureTheory.IsStoppingTime.measurableSet_inter_eq_iff
code: theorem measurableSet_inter_eq_iff (hτ : IsStoppingTime f τ) (s : Set Ω) (i : ι) :
    MeasurableSet[hτ.measurableSpace] (s ∩ {ω | τ ω = i}) ↔
      MeasurableSet[f i] (s ∩ {ω | τ ω = i}) 
goal: MeasurableSet (s ∩ {ω | τ ω = i}) ↔ MeasurableSet (s ∩ {ω | τ ω = i})

full_name: MeasureTheory.IsStoppingTime.measurableSpace_le_of_le_const
code: theorem measurableSpace_le_of_le_const (hτ : IsStoppingTime f τ) {i : ι} (hτ_le : ∀ ω, τ ω ≤ i) :
    hτ.measurableSpace ≤ f i 
goal: hτ.measurableSpace ≤ ↑f i

full_name: MeasureTheory.IsStoppingTime.measurableSpace_le_of_le
code: theorem measurableSpace_le_of_le (hτ : IsStoppingTime f τ) {n : ι} (hτ_le : ∀ ω, τ ω ≤ n) :
    hτ.measurableSpace ≤ m 
goal: hτ.measurableSpace ≤ m

full_name: MeasureTheory.IsStoppingTime.le_measurableSpace_of_const_le
code: theorem le_measurableSpace_of_const_le (hτ : IsStoppingTime f τ) {i : ι} (hτ_le : ∀ ω, i ≤ τ ω) :
    f i ≤ hτ.measurableSpace 
goal: ↑f i ≤ hτ.measurableSpace

full_name: MeasureTheory.IsStoppingTime.sigmaFinite_stopping_time
code: instance sigmaFinite_stopping_time {ι} [SemilatticeSup ι] [OrderBot ι]
    [(Filter.atTop : Filter ι).IsCountablyGenerated] {μ : Measure Ω} {f : Filtration ι m}
    {τ : Ω → ι} [SigmaFiniteFiltration μ f] (hτ : IsStoppingTime f τ) :
    SigmaFinite (μ.trim hτ.measurableSpace_le) 
goal: MeasureTheory.SigmaFinite (μ.trim ⋯)

full_name: MeasureTheory.IsStoppingTime.sigmaFinite_stopping_time_of_le
code: instance sigmaFinite_stopping_time_of_le {ι} [SemilatticeSup ι] [OrderBot ι] {μ : Measure Ω}
    {f : Filtration ι m} {τ : Ω → ι} [SigmaFiniteFiltration μ f] (hτ : IsStoppingTime f τ) {n : ι}
    (hτ_le : ∀ ω, τ ω ≤ n) : SigmaFinite (μ.trim (hτ.measurableSpace_le_of_le hτ_le)) 
goal: MeasureTheory.SigmaFinite (μ.trim ⋯)

full_name: MeasureTheory.IsStoppingTime.measurableSet_le'
code: protected theorem measurableSet_le' (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[hτ.measurableSpace] {ω | τ ω ≤ i} 
goal: MeasurableSet {ω | τ ω ≤ i}

full_name: MeasureTheory.IsStoppingTime.measurableSet_gt'
code: protected theorem measurableSet_gt' (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[hτ.measurableSpace] {ω | i < τ ω} 
goal: MeasurableSet {ω | i < τ ω}

full_name: MeasureTheory.IsStoppingTime.measurableSet_eq'
code: protected theorem measurableSet_eq' [TopologicalSpace ι] [OrderTopology ι]
    [FirstCountableTopology ι] (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[hτ.measurableSpace] {ω | τ ω = i} 
goal: MeasurableSet {ω | τ ω = i}

full_name: MeasureTheory.IsStoppingTime.measurableSet_ge'
code: protected theorem measurableSet_ge' [TopologicalSpace ι] [OrderTopology ι]
    [FirstCountableTopology ι] (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[hτ.measurableSpace] {ω | i ≤ τ ω} 
goal: MeasurableSet {ω | i ≤ τ ω}

full_name: MeasureTheory.IsStoppingTime.measurableSet_lt'
code: protected theorem measurableSet_lt' [TopologicalSpace ι] [OrderTopology ι]
    [FirstCountableTopology ι] (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[hτ.measurableSpace] {ω | τ ω < i} 
goal: MeasurableSet {ω | τ ω < i}

full_name: MeasureTheory.IsStoppingTime.measurableSet_eq_of_countable_range'
code: protected theorem measurableSet_eq_of_countable_range' (hτ : IsStoppingTime f τ)
    (h_countable : (Set.range τ).Countable) (i : ι) :
    MeasurableSet[hτ.measurableSpace] {ω | τ ω = i} 
goal: MeasurableSet {ω | τ ω = i}

full_name: MeasureTheory.IsStoppingTime.measurableSet_eq_of_countable'
code: protected theorem measurableSet_eq_of_countable' [Countable ι] (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[hτ.measurableSpace] {ω | τ ω = i} 
goal: MeasurableSet {ω | τ ω = i}

full_name: MeasureTheory.IsStoppingTime.measurableSet_ge_of_countable_range'
code: protected theorem measurableSet_ge_of_countable_range' (hτ : IsStoppingTime f τ)
    (h_countable : (Set.range τ).Countable) (i : ι) :
    MeasurableSet[hτ.measurableSpace] {ω | i ≤ τ ω} 
goal: MeasurableSet {ω | i ≤ τ ω}

full_name: MeasureTheory.IsStoppingTime.measurableSet_ge_of_countable'
code: protected theorem measurableSet_ge_of_countable' [Countable ι] (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[hτ.measurableSpace] {ω | i ≤ τ ω} 
goal: MeasurableSet {ω | i ≤ τ ω}

full_name: MeasureTheory.IsStoppingTime.measurableSet_lt_of_countable_range'
code: protected theorem measurableSet_lt_of_countable_range' (hτ : IsStoppingTime f τ)
    (h_countable : (Set.range τ).Countable) (i : ι) :
    MeasurableSet[hτ.measurableSpace] {ω | τ ω < i} 
goal: MeasurableSet {ω | τ ω < i}

full_name: MeasureTheory.IsStoppingTime.measurableSet_lt_of_countable'
code: protected theorem measurableSet_lt_of_countable' [Countable ι] (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[hτ.measurableSpace] {ω | τ ω < i} 
goal: MeasurableSet {ω | τ ω < i}

full_name: MeasureTheory.IsStoppingTime.measurableSpace_le_of_countable_range
code: protected theorem measurableSpace_le_of_countable_range (hτ : IsStoppingTime f τ)
    (h_countable : (Set.range τ).Countable) : hτ.measurableSpace ≤ m 
goal: hτ.measurableSpace ≤ m

full_name: MeasureTheory.IsStoppingTime.measurable
code: protected theorem measurable [TopologicalSpace ι] [MeasurableSpace ι] [BorelSpace ι]
    [OrderTopology ι] [SecondCountableTopology ι] (hτ : IsStoppingTime f τ) :
    Measurable[hτ.measurableSpace] τ 
goal: Measurable τ

full_name: MeasureTheory.IsStoppingTime.measurable_of_le
code: protected theorem measurable_of_le [TopologicalSpace ι] [MeasurableSpace ι] [BorelSpace ι]
    [OrderTopology ι] [SecondCountableTopology ι] (hτ : IsStoppingTime f τ) {i : ι}
    (hτ_le : ∀ ω, τ ω ≤ i) : Measurable[f i] τ 
goal: Measurable τ

full_name: MeasureTheory.IsStoppingTime.measurableSpace_min
code: theorem measurableSpace_min (hτ : IsStoppingTime f τ) (hπ : IsStoppingTime f π) :
    (hτ.min hπ).measurableSpace = hτ.measurableSpace ⊓ hπ.measurableSpace 
goal: ⋯.measurableSpace = hτ.measurableSpace ⊓ hπ.measurableSpace

full_name: MeasureTheory.IsStoppingTime.measurableSet_min_iff
code: theorem measurableSet_min_iff (hτ : IsStoppingTime f τ) (hπ : IsStoppingTime f π) (s : Set Ω) :
    MeasurableSet[(hτ.min hπ).measurableSpace] s ↔
      MeasurableSet[hτ.measurableSpace] s ∧ MeasurableSet[hπ.measurableSpace] s 
goal: MeasurableSet s ↔ MeasurableSet s ∧ MeasurableSet s

full_name: MeasureTheory.IsStoppingTime.measurableSpace_min_const
code: theorem measurableSpace_min_const (hτ : IsStoppingTime f τ) {i : ι} :
    (hτ.min_const i).measurableSpace = hτ.measurableSpace ⊓ f i 
goal: ⋯.measurableSpace = hτ.measurableSpace ⊓ ↑f i

full_name: MeasureTheory.IsStoppingTime.measurableSet_min_const_iff
code: theorem measurableSet_min_const_iff (hτ : IsStoppingTime f τ) (s : Set Ω) {i : ι} :
    MeasurableSet[(hτ.min_const i).measurableSpace] s ↔
      MeasurableSet[hτ.measurableSpace] s ∧ MeasurableSet[f i] s 
goal: MeasurableSet s ↔ MeasurableSet s ∧ MeasurableSet s

full_name: MeasureTheory.IsStoppingTime.measurableSet_inter_le
code: theorem measurableSet_inter_le [TopologicalSpace ι] [SecondCountableTopology ι] [OrderTopology ι]
    [MeasurableSpace ι] [BorelSpace ι] (hτ : IsStoppingTime f τ) (hπ : IsStoppingTime f π)
    (s : Set Ω) (hs : MeasurableSet[hτ.measurableSpace] s) :
    MeasurableSet[(hτ.min hπ).measurableSpace] (s ∩ {ω | τ ω ≤ π ω}) 
goal: MeasurableSet (s ∩ {ω | τ ω ≤ π ω})

full_name: MeasureTheory.IsStoppingTime.measurableSet_inter_le_iff
code: theorem measurableSet_inter_le_iff [TopologicalSpace ι] [SecondCountableTopology ι]
    [OrderTopology ι] [MeasurableSpace ι] [BorelSpace ι] (hτ : IsStoppingTime f τ)
    (hπ : IsStoppingTime f π) (s : Set Ω) :
    MeasurableSet[hτ.measurableSpace] (s ∩ {ω | τ ω ≤ π ω}) ↔
      MeasurableSet[(hτ.min hπ).measurableSpace] (s ∩ {ω | τ ω ≤ π ω}) 
goal: MeasurableSet (s ∩ {ω | τ ω ≤ π ω}) ↔ MeasurableSet (s ∩ {ω | τ ω ≤ π ω})

full_name: MeasureTheory.IsStoppingTime.measurableSet_inter_le_const_iff
code: theorem measurableSet_inter_le_const_iff (hτ : IsStoppingTime f τ) (s : Set Ω) (i : ι) :
    MeasurableSet[hτ.measurableSpace] (s ∩ {ω | τ ω ≤ i}) ↔
      MeasurableSet[(hτ.min_const i).measurableSpace] (s ∩ {ω | τ ω ≤ i}) 
goal: MeasurableSet (s ∩ {ω | τ ω ≤ i}) ↔ MeasurableSet (s ∩ {ω | τ ω ≤ i})

full_name: MeasureTheory.IsStoppingTime.measurableSet_le_stopping_time
code: theorem measurableSet_le_stopping_time [TopologicalSpace ι] [SecondCountableTopology ι]
    [OrderTopology ι] [MeasurableSpace ι] [BorelSpace ι] (hτ : IsStoppingTime f τ)
    (hπ : IsStoppingTime f π) : MeasurableSet[hτ.measurableSpace] {ω | τ ω ≤ π ω} 
goal: MeasurableSet {ω | τ ω ≤ π ω}

full_name: MeasureTheory.IsStoppingTime.measurableSet_stopping_time_le
code: theorem measurableSet_stopping_time_le [TopologicalSpace ι] [SecondCountableTopology ι]
    [OrderTopology ι] [MeasurableSpace ι] [BorelSpace ι] (hτ : IsStoppingTime f τ)
    (hπ : IsStoppingTime f π) : MeasurableSet[hπ.measurableSpace] {ω | τ ω ≤ π ω} 
goal: MeasurableSet {ω | τ ω ≤ π ω}

full_name: MeasureTheory.IsStoppingTime.measurableSet_eq_stopping_time
code: theorem measurableSet_eq_stopping_time [AddGroup ι] [TopologicalSpace ι] [MeasurableSpace ι]
    [BorelSpace ι] [OrderTopology ι] [MeasurableSingletonClass ι] [SecondCountableTopology ι]
    [MeasurableSub₂ ι] (hτ : IsStoppingTime f τ) (hπ : IsStoppingTime f π) :
    MeasurableSet[hτ.measurableSpace] {ω | τ ω = π ω} 
goal: MeasurableSet {ω | τ ω = π ω}

full_name: MeasureTheory.IsStoppingTime.measurableSet_eq_stopping_time_of_countable
code: theorem measurableSet_eq_stopping_time_of_countable [Countable ι] [TopologicalSpace ι]
    [MeasurableSpace ι] [BorelSpace ι] [OrderTopology ι] [MeasurableSingletonClass ι]
    [SecondCountableTopology ι] (hτ : IsStoppingTime f τ) (hπ : IsStoppingTime f π) :
    MeasurableSet[hτ.measurableSpace] {ω | τ ω = π ω} 
goal: MeasurableSet {ω | τ ω = π ω}

full_name: MeasureTheory.stoppedValue
code: /-- Given a map `u : ι → Ω → E`, its stopped value with respect to the stopping
time `τ` is the map `x ↦ u (τ ω) ω`. -/
def stoppedValue (u : ι → Ω → β) (τ : Ω → ι) : Ω → β 
goal: Ω → β

full_name: MeasureTheory.stoppedValue_const
code: theorem stoppedValue_const (u : ι → Ω → β) (i : ι) : (stoppedValue u fun _ => i) = u i 
goal: (MeasureTheory.stoppedValue u fun x => i) = u i

full_name: MeasureTheory.stoppedProcess
code: /-- Given a map `u : ι → Ω → E`, the stopped process with respect to `τ` is `u i ω` if
`i ≤ τ ω`, and `u (τ ω) ω` otherwise.

Intuitively, the stopped process stops evolving once the stopping time has occured. -/
def stoppedProcess (u : ι → Ω → β) (τ : Ω → ι) : ι → Ω → β 
goal: ι → Ω → β

full_name: MeasureTheory.stoppedProcess_eq_stoppedValue
code: theorem stoppedProcess_eq_stoppedValue {u : ι → Ω → β} {τ : Ω → ι} :
    stoppedProcess u τ = fun i => stoppedValue u fun ω => min i (τ ω) 
goal: MeasureTheory.stoppedProcess u τ = fun i => MeasureTheory.stoppedValue u fun ω => min i (τ ω)

full_name: MeasureTheory.stoppedValue_stoppedProcess
code: theorem stoppedValue_stoppedProcess {u : ι → Ω → β} {τ σ : Ω → ι} :
    stoppedValue (stoppedProcess u τ) σ = stoppedValue u fun ω => min (σ ω) (τ ω) 
goal: MeasureTheory.stoppedValue (MeasureTheory.stoppedProcess u τ) σ = MeasureTheory.stoppedValue u fun ω => min (σ ω) (τ ω)

full_name: MeasureTheory.stoppedProcess_eq_of_le
code: theorem stoppedProcess_eq_of_le {u : ι → Ω → β} {τ : Ω → ι} {i : ι} {ω : Ω} (h : i ≤ τ ω) :
    stoppedProcess u τ i ω = u i ω 
goal: MeasureTheory.stoppedProcess u τ i ω = u i ω

full_name: MeasureTheory.stoppedProcess_eq_of_ge
code: theorem stoppedProcess_eq_of_ge {u : ι → Ω → β} {τ : Ω → ι} {i : ι} {ω : Ω} (h : τ ω ≤ i) :
    stoppedProcess u τ i ω = u (τ ω) ω 
goal: MeasureTheory.stoppedProcess u τ i ω = u (τ ω) ω

full_name: MeasureTheory.progMeasurable_min_stopping_time
code: theorem progMeasurable_min_stopping_time [MetrizableSpace ι] (hτ : IsStoppingTime f τ) :
    ProgMeasurable f fun i ω => min i (τ ω) 
goal: MeasureTheory.ProgMeasurable f fun i ω => min i (τ ω)

full_name: MeasureTheory.ProgMeasurable.stoppedProcess
code: theorem ProgMeasurable.stoppedProcess [MetrizableSpace ι] (h : ProgMeasurable f u)
    (hτ : IsStoppingTime f τ) : ProgMeasurable f (stoppedProcess u τ) 
goal: MeasureTheory.ProgMeasurable f (MeasureTheory.stoppedProcess u τ)

full_name: MeasureTheory.ProgMeasurable.adapted_stoppedProcess
code: theorem ProgMeasurable.adapted_stoppedProcess [MetrizableSpace ι] (h : ProgMeasurable f u)
    (hτ : IsStoppingTime f τ) : Adapted f (MeasureTheory.stoppedProcess u τ) 
goal: MeasureTheory.Adapted f (MeasureTheory.stoppedProcess u τ)

full_name: MeasureTheory.ProgMeasurable.stronglyMeasurable_stoppedProcess
code: theorem ProgMeasurable.stronglyMeasurable_stoppedProcess [MetrizableSpace ι]
    (hu : ProgMeasurable f u) (hτ : IsStoppingTime f τ) (i : ι) :
    StronglyMeasurable (MeasureTheory.stoppedProcess u τ i) 
goal: MeasureTheory.StronglyMeasurable (MeasureTheory.stoppedProcess u τ i)

full_name: MeasureTheory.stronglyMeasurable_stoppedValue_of_le
code: theorem stronglyMeasurable_stoppedValue_of_le (h : ProgMeasurable f u) (hτ : IsStoppingTime f τ)
    {n : ι} (hτ_le : ∀ ω, τ ω ≤ n) : StronglyMeasurable[f n] (stoppedValue u τ) 
goal: MeasureTheory.StronglyMeasurable (MeasureTheory.stoppedValue u τ)

full_name: MeasureTheory.measurable_stoppedValue
code: theorem measurable_stoppedValue [MetrizableSpace β] [MeasurableSpace β] [BorelSpace β]
    (hf_prog : ProgMeasurable f u) (hτ : IsStoppingTime f τ) :
    Measurable[hτ.measurableSpace] (stoppedValue u τ) 
goal: Measurable (MeasureTheory.stoppedValue u τ)

full_name: MeasureTheory.stoppedValue_eq_of_mem_finset
code: theorem stoppedValue_eq_of_mem_finset [AddCommMonoid E] {s : Finset ι} (hbdd : ∀ ω, τ ω ∈ s) :
    stoppedValue u τ = ∑ i ∈ s, Set.indicator {ω | τ ω = i} (u i) 
goal: MeasureTheory.stoppedValue u τ = ∑ i ∈ s, {ω | τ ω = i}.indicator (u i)

full_name: MeasureTheory.stoppedValue_eq'
code: theorem stoppedValue_eq' [Preorder ι] [LocallyFiniteOrderBot ι] [AddCommMonoid E] {N : ι}
    (hbdd : ∀ ω, τ ω ≤ N) :
    stoppedValue u τ = ∑ i ∈ Finset.Iic N, Set.indicator {ω | τ ω = i} (u i) 
goal: MeasureTheory.stoppedValue u τ = ∑ i ∈ Finset.Iic N, {ω | τ ω = i}.indicator (u i)

full_name: MeasureTheory.stoppedProcess_eq_of_mem_finset
code: theorem stoppedProcess_eq_of_mem_finset [LinearOrder ι] [AddCommMonoid E] {s : Finset ι} (n : ι)
    (hbdd : ∀ ω, τ ω < n → τ ω ∈ s) : stoppedProcess u τ n = Set.indicator {a | n ≤ τ a} (u n) +
      ∑ i ∈ s.filter (· < n), Set.indicator {ω | τ ω = i} (u i) 
goal: MeasureTheory.stoppedProcess u τ n =
  {a | n ≤ τ a}.indicator (u n) + ∑ i ∈ Finset.filter (fun x => x < n) s, {ω | τ ω = i}.indicator (u i)

full_name: MeasureTheory.stoppedProcess_eq''
code: theorem stoppedProcess_eq'' [LinearOrder ι] [LocallyFiniteOrderBot ι] [AddCommMonoid E] (n : ι) :
    stoppedProcess u τ n = Set.indicator {a | n ≤ τ a} (u n) +
      ∑ i ∈ Finset.Iio n, Set.indicator {ω | τ ω = i} (u i) 
goal: MeasureTheory.stoppedProcess u τ n = {a | n ≤ τ a}.indicator (u n) + ∑ i ∈ Finset.Iio n, {ω | τ ω = i}.indicator (u i)

full_name: MeasureTheory.memℒp_stoppedValue_of_mem_finset
code: theorem memℒp_stoppedValue_of_mem_finset (hτ : IsStoppingTime ℱ τ) (hu : ∀ n, Memℒp (u n) p μ)
    {s : Finset ι} (hbdd : ∀ ω, τ ω ∈ s) : Memℒp (stoppedValue u τ) p μ 
goal: MeasureTheory.Memℒp (MeasureTheory.stoppedValue u τ) p μ

full_name: MeasureTheory.memℒp_stoppedValue
code: theorem memℒp_stoppedValue [LocallyFiniteOrderBot ι] (hτ : IsStoppingTime ℱ τ)
    (hu : ∀ n, Memℒp (u n) p μ) {N : ι} (hbdd : ∀ ω, τ ω ≤ N) : Memℒp (stoppedValue u τ) p μ 
goal: MeasureTheory.Memℒp (MeasureTheory.stoppedValue u τ) p μ

full_name: MeasureTheory.integrable_stoppedValue_of_mem_finset
code: theorem integrable_stoppedValue_of_mem_finset (hτ : IsStoppingTime ℱ τ)
    (hu : ∀ n, Integrable (u n) μ) {s : Finset ι} (hbdd : ∀ ω, τ ω ∈ s) :
    Integrable (stoppedValue u τ) μ 
goal: MeasureTheory.Integrable (MeasureTheory.stoppedValue u τ) μ

full_name: MeasureTheory.integrable_stoppedValue
code: theorem integrable_stoppedValue [LocallyFiniteOrderBot ι] (hτ : IsStoppingTime ℱ τ)
    (hu : ∀ n, Integrable (u n) μ) {N : ι} (hbdd : ∀ ω, τ ω ≤ N) :
    Integrable (stoppedValue u τ) μ 
goal: MeasureTheory.Integrable (MeasureTheory.stoppedValue u τ) μ

full_name: MeasureTheory.memℒp_stoppedProcess_of_mem_finset
code: theorem memℒp_stoppedProcess_of_mem_finset (hτ : IsStoppingTime ℱ τ) (hu : ∀ n, Memℒp (u n) p μ)
    (n : ι) {s : Finset ι} (hbdd : ∀ ω, τ ω < n → τ ω ∈ s) : Memℒp (stoppedProcess u τ n) p μ 
goal: MeasureTheory.Memℒp (MeasureTheory.stoppedProcess u τ n) p μ

full_name: MeasureTheory.memℒp_stoppedProcess
code: theorem memℒp_stoppedProcess [LocallyFiniteOrderBot ι] (hτ : IsStoppingTime ℱ τ)
    (hu : ∀ n, Memℒp (u n) p μ) (n : ι) : Memℒp (stoppedProcess u τ n) p μ 
goal: MeasureTheory.Memℒp (MeasureTheory.stoppedProcess u τ n) p μ

full_name: MeasureTheory.integrable_stoppedProcess_of_mem_finset
code: theorem integrable_stoppedProcess_of_mem_finset (hτ : IsStoppingTime ℱ τ)
    (hu : ∀ n, Integrable (u n) μ) (n : ι) {s : Finset ι} (hbdd : ∀ ω, τ ω < n → τ ω ∈ s) :
    Integrable (stoppedProcess u τ n) μ 
goal: MeasureTheory.Integrable (MeasureTheory.stoppedProcess u τ n) μ

full_name: MeasureTheory.integrable_stoppedProcess
code: theorem integrable_stoppedProcess [LocallyFiniteOrderBot ι] (hτ : IsStoppingTime ℱ τ)
    (hu : ∀ n, Integrable (u n) μ) (n : ι) : Integrable (stoppedProcess u τ n) μ 
goal: MeasureTheory.Integrable (MeasureTheory.stoppedProcess u τ n) μ

full_name: MeasureTheory.Adapted.stoppedProcess
code: /-- The stopped process of an adapted process with continuous paths is adapted. -/
theorem Adapted.stoppedProcess [MetrizableSpace ι] (hu : Adapted f u)
    (hu_cont : ∀ ω, Continuous fun i => u i ω) (hτ : IsStoppingTime f τ) :
    Adapted f (stoppedProcess u τ) 
goal: MeasureTheory.Adapted f (MeasureTheory.stoppedProcess u τ)

full_name: MeasureTheory.Adapted.stoppedProcess_of_discrete
code: /-- If the indexing order has the discrete topology, then the stopped process of an adapted process
is adapted. -/
theorem Adapted.stoppedProcess_of_discrete [DiscreteTopology ι] (hu : Adapted f u)
    (hτ : IsStoppingTime f τ) : Adapted f (MeasureTheory.stoppedProcess u τ) 
goal: MeasureTheory.Adapted f (MeasureTheory.stoppedProcess u τ)

full_name: MeasureTheory.Adapted.stronglyMeasurable_stoppedProcess
code: theorem Adapted.stronglyMeasurable_stoppedProcess [MetrizableSpace ι] (hu : Adapted f u)
    (hu_cont : ∀ ω, Continuous fun i => u i ω) (hτ : IsStoppingTime f τ) (n : ι) :
    StronglyMeasurable (MeasureTheory.stoppedProcess u τ n) 
goal: MeasureTheory.StronglyMeasurable (MeasureTheory.stoppedProcess u τ n)

full_name: MeasureTheory.Adapted.stronglyMeasurable_stoppedProcess_of_discrete
code: theorem Adapted.stronglyMeasurable_stoppedProcess_of_discrete [DiscreteTopology ι]
    (hu : Adapted f u) (hτ : IsStoppingTime f τ) (n : ι) :
    StronglyMeasurable (MeasureTheory.stoppedProcess u τ n) 
goal: MeasureTheory.StronglyMeasurable (MeasureTheory.stoppedProcess u τ n)

full_name: MeasureTheory.stoppedValue_sub_eq_sum
code: theorem stoppedValue_sub_eq_sum [AddCommGroup β] (hle : τ ≤ π) :
    stoppedValue u π - stoppedValue u τ = fun ω =>
      (∑ i ∈ Finset.Ico (τ ω) (π ω), (u (i + 1) - u i)) ω 
goal: MeasureTheory.stoppedValue u π - MeasureTheory.stoppedValue u τ = fun ω =>
  (∑ i ∈ Finset.Ico (τ ω) (π ω), (u (i + 1) - u i)) ω

full_name: MeasureTheory.stoppedValue_sub_eq_sum'
code: theorem stoppedValue_sub_eq_sum' [AddCommGroup β] (hle : τ ≤ π) {N : ℕ} (hbdd : ∀ ω, π ω ≤ N) :
    stoppedValue u π - stoppedValue u τ = fun ω =>
      (∑ i ∈ Finset.range (N + 1), Set.indicator {ω | τ ω ≤ i ∧ i < π ω} (u (i + 1) - u i)) ω 
goal: MeasureTheory.stoppedValue u π - MeasureTheory.stoppedValue u τ = fun ω =>
  (∑ i ∈ Finset.range (N + 1), {ω | τ ω ≤ i ∧ i < π ω}.indicator (u (i + 1) - u i)) ω

full_name: MeasureTheory.stoppedValue_eq
code: theorem stoppedValue_eq {N : ℕ} (hbdd : ∀ ω, τ ω ≤ N) : stoppedValue u τ = fun x =>
    (∑ i ∈ Finset.range (N + 1), Set.indicator {ω | τ ω = i} (u i)) x 
goal: MeasureTheory.stoppedValue u τ = fun x => (∑ i ∈ Finset.range (N + 1), {ω | τ ω = i}.indicator (u i)) x

full_name: MeasureTheory.stoppedProcess_eq
code: theorem stoppedProcess_eq (n : ℕ) : stoppedProcess u τ n = Set.indicator {a | n ≤ τ a} (u n) +
    ∑ i ∈ Finset.range n, Set.indicator {ω | τ ω = i} (u i) 
goal: MeasureTheory.stoppedProcess u τ n = {a | n ≤ τ a}.indicator (u n) + ∑ i ∈ Finset.range n, {ω | τ ω = i}.indicator (u i)

full_name: MeasureTheory.stoppedProcess_eq'
code: theorem stoppedProcess_eq' (n : ℕ) : stoppedProcess u τ n = Set.indicator {a | n + 1 ≤ τ a} (u n) +
    ∑ i ∈ Finset.range (n + 1), Set.indicator {a | τ a = i} (u i) 
goal: MeasureTheory.stoppedProcess u τ n =
  {a | n + 1 ≤ τ a}.indicator (u n) + ∑ i ∈ Finset.range (n + 1), {a | τ a = i}.indicator (u i)

full_name: MeasureTheory.IsStoppingTime.piecewise_of_le
code: /-- Given stopping times `τ` and `η` which are bounded below, `Set.piecewise s τ η` is also
a stopping time with respect to the same filtration. -/
theorem IsStoppingTime.piecewise_of_le (hτ_st : IsStoppingTime 𝒢 τ) (hη_st : IsStoppingTime 𝒢 η)
    (hτ : ∀ ω, i ≤ τ ω) (hη : ∀ ω, i ≤ η ω) (hs : MeasurableSet[𝒢 i] s) :
    IsStoppingTime 𝒢 (s.piecewise τ η) 
goal: MeasureTheory.IsStoppingTime 𝒢 (s.piecewise τ η)

full_name: MeasureTheory.isStoppingTime_piecewise_const
code: theorem isStoppingTime_piecewise_const (hij : i ≤ j) (hs : MeasurableSet[𝒢 i] s) :
    IsStoppingTime 𝒢 (s.piecewise (fun _ => i) fun _ => j) 
goal: MeasureTheory.IsStoppingTime 𝒢 (s.piecewise (fun x => i) fun x => j)

full_name: MeasureTheory.stoppedValue_piecewise_const
code: theorem stoppedValue_piecewise_const {ι' : Type*} {i j : ι'} {f : ι' → Ω → ℝ} :
    stoppedValue f (s.piecewise (fun _ => i) fun _ => j) = s.piecewise (f i) (f j) 
goal: MeasureTheory.stoppedValue f (s.piecewise (fun x => i) fun x => j) = s.piecewise (f i) (f j)

full_name: MeasureTheory.stoppedValue_piecewise_const'
code: theorem stoppedValue_piecewise_const' {ι' : Type*} {i j : ι'} {f : ι' → Ω → ℝ} :
    stoppedValue f (s.piecewise (fun _ => i) fun _ => j) =
    s.indicator (f i) + sᶜ.indicator (f j) 
goal: MeasureTheory.stoppedValue f (s.piecewise (fun x => i) fun x => j) = s.indicator (f i) + sᶜ.indicator (f j)

full_name: MeasureTheory.condexp_stopping_time_ae_eq_restrict_eq_of_countable_range
code: theorem condexp_stopping_time_ae_eq_restrict_eq_of_countable_range [SigmaFiniteFiltration μ ℱ]
    (hτ : IsStoppingTime ℱ τ) (h_countable : (Set.range τ).Countable)
    [SigmaFinite (μ.trim (hτ.measurableSpace_le_of_countable_range h_countable))] (i : ι) :
    μ[f|hτ.measurableSpace] =ᵐ[μ.restrict {x | τ x = i}] μ[f|ℱ i] 
goal: μ[f|hτ.measurableSpace] =ᵐ[μ.restrict {x | τ x = i}] μ[f|↑ℱ i]

full_name: MeasureTheory.condexp_stopping_time_ae_eq_restrict_eq_of_countable
code: theorem condexp_stopping_time_ae_eq_restrict_eq_of_countable [Countable ι]
    [SigmaFiniteFiltration μ ℱ] (hτ : IsStoppingTime ℱ τ)
    [SigmaFinite (μ.trim hτ.measurableSpace_le_of_countable)] (i : ι) :
    μ[f|hτ.measurableSpace] =ᵐ[μ.restrict {x | τ x = i}] μ[f|ℱ i] 
goal: μ[f|hτ.measurableSpace] =ᵐ[μ.restrict {x | τ x = i}] μ[f|↑ℱ i]

full_name: MeasureTheory.condexp_min_stopping_time_ae_eq_restrict_le_const
code: theorem condexp_min_stopping_time_ae_eq_restrict_le_const (hτ : IsStoppingTime ℱ τ) (i : ι)
    [SigmaFinite (μ.trim (hτ.min_const i).measurableSpace_le)] :
    μ[f|(hτ.min_const i).measurableSpace] =ᵐ[μ.restrict {x | τ x ≤ i}] μ[f|hτ.measurableSpace] 
goal: μ[f|⋯.measurableSpace] =ᵐ[μ.restrict {x | τ x ≤ i}] μ[f|hτ.measurableSpace]

full_name: MeasureTheory.condexp_stopping_time_ae_eq_restrict_eq
code: theorem condexp_stopping_time_ae_eq_restrict_eq [FirstCountableTopology ι]
    [SigmaFiniteFiltration μ ℱ] (hτ : IsStoppingTime ℱ τ)
    [SigmaFinite (μ.trim hτ.measurableSpace_le)] (i : ι) :
    μ[f|hτ.measurableSpace] =ᵐ[μ.restrict {x | τ x = i}] μ[f|ℱ i] 
goal: μ[f|hτ.measurableSpace] =ᵐ[μ.restrict {x | τ x = i}] μ[f|↑ℱ i]

full_name: MeasureTheory.condexp_min_stopping_time_ae_eq_restrict_le
code: theorem condexp_min_stopping_time_ae_eq_restrict_le [MeasurableSpace ι] [SecondCountableTopology ι]
    [BorelSpace ι] (hτ : IsStoppingTime ℱ τ) (hσ : IsStoppingTime ℱ σ)
    [SigmaFinite (μ.trim (hτ.min hσ).measurableSpace_le)] :
    μ[f|(hτ.min hσ).measurableSpace] =ᵐ[μ.restrict {x | τ x ≤ σ x}] μ[f|hτ.measurableSpace] 
goal: μ[f|⋯.measurableSpace] =ᵐ[μ.restrict {x | τ x ≤ σ x}] μ[f|hτ.measurableSpace]