l3lab/ntp-mathlib huggingface dataset:
theorem measurableSpace_le' [IsCountablyGenerated (atTop : Filter ι)] [(atTop : Filter ι).NeBot]
    (hτ : IsStoppingTime f τ) : hτ.measurableSpace ≤ m := by
  intro s hs
  change ∀ i, MeasurableSet[f i] (s ∩ {ω | τ ω ≤ i}) at hs
  obtain ⟨seq : ℕ → ι, h_seq_tendsto⟩ := (atTop : Filter ι).exists_seq_tendsto
  rw [(_ : s = ⋃ n, s ∩ {ω | τ ω ≤ seq n})]
  · exact MeasurableSet.iUnion fun i => f.le (seq i) _ (hs (seq i))
  · ext ω; 

Proof state:
case h
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι
f : Filtration ι m
τ π : Ω → ι
inst✝¹ : IsCountablyGenerated atTop
inst✝ : NeBot atTop
hτ : IsStoppingTime f τ
s : Set Ω
hs : ∀ (i : ι), MeasurableSet (s ∩ {ω | τ ω ≤ i})
seq : ℕ → ι
h_seq_tendsto : Tendsto seq atTop atTop
ω : Ω
⊢ ω ∈ s ↔ ω ∈ ⋃ n, s ∩ {ω | τ ω ≤ seq n}

Next tactic:
constructor
theorem measurableSpace_le' [IsCountablyGenerated (atTop : Filter ι)] [(atTop : Filter ι).NeBot]
    (hτ : IsStoppingTime f τ) : hτ.measurableSpace ≤ m := by
  intro s hs
  change ∀ i, MeasurableSet[f i] (s ∩ {ω | τ ω ≤ i}) at hs
  obtain ⟨seq : ℕ → ι, h_seq_tendsto⟩ := (atTop : Filter ι).exists_seq_tendsto
  rw [(_ : s = ⋃ n, s ∩ {ω | τ ω ≤ seq n})]
  · exact MeasurableSet.iUnion fun i => f.le (seq i) _ (hs (seq i))
  · ext ω; constructor <;> 

Proof state:
case h.mp
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι
f : Filtration ι m
τ π : Ω → ι
inst✝¹ : IsCountablyGenerated atTop
inst✝ : NeBot atTop
hτ : IsStoppingTime f τ
s : Set Ω
hs : ∀ (i : ι), MeasurableSet (s ∩ {ω | τ ω ≤ i})
seq : ℕ → ι
h_seq_tendsto : Tendsto seq atTop atTop
ω : Ω
⊢ ω ∈ s → ω ∈ ⋃ n, s ∩ {ω | τ ω ≤ seq n}

Next tactic:
rw [Set.mem_iUnion]
theorem measurableSpace_le' [IsCountablyGenerated (atTop : Filter ι)] [(atTop : Filter ι).NeBot]
    (hτ : IsStoppingTime f τ) : hτ.measurableSpace ≤ m := by
  intro s hs
  change ∀ i, MeasurableSet[f i] (s ∩ {ω | τ ω ≤ i}) at hs
  obtain ⟨seq : ℕ → ι, h_seq_tendsto⟩ := (atTop : Filter ι).exists_seq_tendsto
  rw [(_ : s = ⋃ n, s ∩ {ω | τ ω ≤ seq n})]
  · exact MeasurableSet.iUnion fun i => f.le (seq i) _ (hs (seq i))
  · ext ω; constructor <;> 

Proof state:
case h.mpr
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι
f : Filtration ι m
τ π : Ω → ι
inst✝¹ : IsCountablyGenerated atTop
inst✝ : NeBot atTop
hτ : IsStoppingTime f τ
s : Set Ω
hs : ∀ (i : ι), MeasurableSet (s ∩ {ω | τ ω ≤ i})
seq : ℕ → ι
h_seq_tendsto : Tendsto seq atTop atTop
ω : Ω
⊢ ω ∈ ⋃ n, s ∩ {ω | τ ω ≤ seq n} → ω ∈ s

Next tactic:
rw [Set.mem_iUnion]
theorem measurableSpace_le' [IsCountablyGenerated (atTop : Filter ι)] [(atTop : Filter ι).NeBot]
    (hτ : IsStoppingTime f τ) : hτ.measurableSpace ≤ m := by
  intro s hs
  change ∀ i, MeasurableSet[f i] (s ∩ {ω | τ ω ≤ i}) at hs
  obtain ⟨seq : ℕ → ι, h_seq_tendsto⟩ := (atTop : Filter ι).exists_seq_tendsto
  rw [(_ : s = ⋃ n, s ∩ {ω | τ ω ≤ seq n})]
  · exact MeasurableSet.iUnion fun i => f.le (seq i) _ (hs (seq i))
  · ext ω; constructor <;> rw [Set.mem_iUnion]
    · 

Proof state:
case h.mp
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι
f : Filtration ι m
τ π : Ω → ι
inst✝¹ : IsCountablyGenerated atTop
inst✝ : NeBot atTop
hτ : IsStoppingTime f τ
s : Set Ω
hs : ∀ (i : ι), MeasurableSet (s ∩ {ω | τ ω ≤ i})
seq : ℕ → ι
h_seq_tendsto : Tendsto seq atTop atTop
ω : Ω
⊢ ω ∈ s → ∃ i, ω ∈ s ∩ {ω | τ ω ≤ seq i}

Next tactic:
intro hx
theorem measurableSpace_le' [IsCountablyGenerated (atTop : Filter ι)] [(atTop : Filter ι).NeBot]
    (hτ : IsStoppingTime f τ) : hτ.measurableSpace ≤ m := by
  intro s hs
  change ∀ i, MeasurableSet[f i] (s ∩ {ω | τ ω ≤ i}) at hs
  obtain ⟨seq : ℕ → ι, h_seq_tendsto⟩ := (atTop : Filter ι).exists_seq_tendsto
  rw [(_ : s = ⋃ n, s ∩ {ω | τ ω ≤ seq n})]
  · exact MeasurableSet.iUnion fun i => f.le (seq i) _ (hs (seq i))
  · ext ω; constructor <;> rw [Set.mem_iUnion]
    · intro hx
      

Proof state:
case h.mp
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι
f : Filtration ι m
τ π : Ω → ι
inst✝¹ : IsCountablyGenerated atTop
inst✝ : NeBot atTop
hτ : IsStoppingTime f τ
s : Set Ω
hs : ∀ (i : ι), MeasurableSet (s ∩ {ω | τ ω ≤ i})
seq : ℕ → ι
h_seq_tendsto : Tendsto seq atTop atTop
ω : Ω
hx : ω ∈ s
⊢ ∃ i, ω ∈ s ∩ {ω | τ ω ≤ seq i}

Next tactic:
suffices : ∃ i, τ ω ≤ seq i
theorem measurableSpace_le' [IsCountablyGenerated (atTop : Filter ι)] [(atTop : Filter ι).NeBot]
    (hτ : IsStoppingTime f τ) : hτ.measurableSpace ≤ m := by
  intro s hs
  change ∀ i, MeasurableSet[f i] (s ∩ {ω | τ ω ≤ i}) at hs
  obtain ⟨seq : ℕ → ι, h_seq_tendsto⟩ := (atTop : Filter ι).exists_seq_tendsto
  rw [(_ : s = ⋃ n, s ∩ {ω | τ ω ≤ seq n})]
  · exact MeasurableSet.iUnion fun i => f.le (seq i) _ (hs (seq i))
  · ext ω; constructor <;> rw [Set.mem_iUnion]
    · intro hx
      suffices : ∃ i, τ ω ≤ seq i; 

Proof state:
case h.mp
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι
f : Filtration ι m
τ π : Ω → ι
inst✝¹ : IsCountablyGenerated atTop
inst✝ : NeBot atTop
hτ : IsStoppingTime f τ
s : Set Ω
hs : ∀ (i : ι), MeasurableSet (s ∩ {ω | τ ω ≤ i})
seq : ℕ → ι
h_seq_tendsto : Tendsto seq atTop atTop
ω : Ω
hx : ω ∈ s
this : ∃ i, τ ω ≤ seq i
⊢ ∃ i, ω ∈ s ∩ {ω | τ ω ≤ seq i}
case this
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι
f : Filtration ι m
τ π : Ω → ι
inst✝¹ : IsCountablyGenerated atTop
inst✝ : NeBot atTop
hτ : IsStoppingTime f τ
s : Set Ω
hs : ∀ (i : ι), MeasurableSet (s ∩ {ω | τ ω ≤ i})
seq : ℕ → ι
h_seq_tendsto : Tendsto seq atTop atTop
ω : Ω
hx : ω ∈ s
⊢ ∃ i, τ ω ≤ seq i

Next tactic:
exact ⟨this.choose, hx, this.choose_spec⟩
theorem measurableSpace_le' [IsCountablyGenerated (atTop : Filter ι)] [(atTop : Filter ι).NeBot]
    (hτ : IsStoppingTime f τ) : hτ.measurableSpace ≤ m := by
  intro s hs
  change ∀ i, MeasurableSet[f i] (s ∩ {ω | τ ω ≤ i}) at hs
  obtain ⟨seq : ℕ → ι, h_seq_tendsto⟩ := (atTop : Filter ι).exists_seq_tendsto
  rw [(_ : s = ⋃ n, s ∩ {ω | τ ω ≤ seq n})]
  · exact MeasurableSet.iUnion fun i => f.le (seq i) _ (hs (seq i))
  · ext ω; constructor <;> rw [Set.mem_iUnion]
    · intro hx
      suffices : ∃ i, τ ω ≤ seq i; exact ⟨this.choose, hx, this.choose_spec⟩
      

Proof state:
case this
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι
f : Filtration ι m
τ π : Ω → ι
inst✝¹ : IsCountablyGenerated atTop
inst✝ : NeBot atTop
hτ : IsStoppingTime f τ
s : Set Ω
hs : ∀ (i : ι), MeasurableSet (s ∩ {ω | τ ω ≤ i})
seq : ℕ → ι
h_seq_tendsto : Tendsto seq atTop atTop
ω : Ω
hx : ω ∈ s
⊢ ∃ i, τ ω ≤ seq i

Next tactic:
rw [tendsto_atTop] at h_seq_tendsto
theorem measurableSpace_le' [IsCountablyGenerated (atTop : Filter ι)] [(atTop : Filter ι).NeBot]
    (hτ : IsStoppingTime f τ) : hτ.measurableSpace ≤ m := by
  intro s hs
  change ∀ i, MeasurableSet[f i] (s ∩ {ω | τ ω ≤ i}) at hs
  obtain ⟨seq : ℕ → ι, h_seq_tendsto⟩ := (atTop : Filter ι).exists_seq_tendsto
  rw [(_ : s = ⋃ n, s ∩ {ω | τ ω ≤ seq n})]
  · exact MeasurableSet.iUnion fun i => f.le (seq i) _ (hs (seq i))
  · ext ω; constructor <;> rw [Set.mem_iUnion]
    · intro hx
      suffices : ∃ i, τ ω ≤ seq i; exact ⟨this.choose, hx, this.choose_spec⟩
      rw [tendsto_atTop] at h_seq_tendsto
      

Proof state:
case this
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι
f : Filtration ι m
τ π : Ω → ι
inst✝¹ : IsCountablyGenerated atTop
inst✝ : NeBot atTop
hτ : IsStoppingTime f τ
s : Set Ω
hs : ∀ (i : ι), MeasurableSet (s ∩ {ω | τ ω ≤ i})
seq : ℕ → ι
h_seq_tendsto : ∀ (b : ι), ∀ᶠ (a : ℕ) in atTop, b ≤ seq a
ω : Ω
hx : ω ∈ s
⊢ ∃ i, τ ω ≤ seq i

Next tactic:
exact (h_seq_tendsto (τ ω)).exists
theorem measurableSpace_le' [IsCountablyGenerated (atTop : Filter ι)] [(atTop : Filter ι).NeBot]
    (hτ : IsStoppingTime f τ) : hτ.measurableSpace ≤ m := by
  intro s hs
  change ∀ i, MeasurableSet[f i] (s ∩ {ω | τ ω ≤ i}) at hs
  obtain ⟨seq : ℕ → ι, h_seq_tendsto⟩ := (atTop : Filter ι).exists_seq_tendsto
  rw [(_ : s = ⋃ n, s ∩ {ω | τ ω ≤ seq n})]
  · exact MeasurableSet.iUnion fun i => f.le (seq i) _ (hs (seq i))
  · ext ω; constructor <;> rw [Set.mem_iUnion]
    · intro hx
      suffices : ∃ i, τ ω ≤ seq i; exact ⟨this.choose, hx, this.choose_spec⟩
      rw [tendsto_atTop] at h_seq_tendsto
      exact (h_seq_tendsto (τ ω)).exists
    · 

Proof state:
case h.mpr
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι
f : Filtration ι m
τ π : Ω → ι
inst✝¹ : IsCountablyGenerated atTop
inst✝ : NeBot atTop
hτ : IsStoppingTime f τ
s : Set Ω
hs : ∀ (i : ι), MeasurableSet (s ∩ {ω | τ ω ≤ i})
seq : ℕ → ι
h_seq_tendsto : Tendsto seq atTop atTop
ω : Ω
⊢ (∃ i, ω ∈ s ∩ {ω | τ ω ≤ seq i}) → ω ∈ s

Next tactic:
rintro ⟨_, hx, _⟩
theorem measurableSpace_le' [IsCountablyGenerated (atTop : Filter ι)] [(atTop : Filter ι).NeBot]
    (hτ : IsStoppingTime f τ) : hτ.measurableSpace ≤ m := by
  intro s hs
  change ∀ i, MeasurableSet[f i] (s ∩ {ω | τ ω ≤ i}) at hs
  obtain ⟨seq : ℕ → ι, h_seq_tendsto⟩ := (atTop : Filter ι).exists_seq_tendsto
  rw [(_ : s = ⋃ n, s ∩ {ω | τ ω ≤ seq n})]
  · exact MeasurableSet.iUnion fun i => f.le (seq i) _ (hs (seq i))
  · ext ω; constructor <;> rw [Set.mem_iUnion]
    · intro hx
      suffices : ∃ i, τ ω ≤ seq i; exact ⟨this.choose, hx, this.choose_spec⟩
      rw [tendsto_atTop] at h_seq_tendsto
      exact (h_seq_tendsto (τ ω)).exists
    · rintro ⟨_, hx, _⟩
      

Proof state:
case h.mpr.intro.intro
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι
f : Filtration ι m
τ π : Ω → ι
inst✝¹ : IsCountablyGenerated atTop
inst✝ : NeBot atTop
hτ : IsStoppingTime f τ
s : Set Ω
hs : ∀ (i : ι), MeasurableSet (s ∩ {ω | τ ω ≤ i})
seq : ℕ → ι
h_seq_tendsto : Tendsto seq atTop atTop
ω : Ω
w✝ : ℕ
hx : ω ∈ s
right✝ : ω ∈ {ω | τ ω ≤ seq w✝}
⊢ ω ∈ s

Next tactic:
exact hx
theorem measurableSpace_le {ι} [SemilatticeSup ι] {f : Filtration ι m} {τ : Ω → ι}
    [IsCountablyGenerated (atTop : Filter ι)] (hτ : IsStoppingTime f τ) :
    hτ.measurableSpace ≤ m := by
  

Proof state:
Ω : Type u_1
β : Type u_2
ι✝ : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι✝
f✝ : Filtration ι✝ m
τ✝ π : Ω → ι✝
ι : Type u_4
inst✝¹ : SemilatticeSup ι
f : Filtration ι m
τ : Ω → ι
inst✝ : IsCountablyGenerated atTop
hτ : IsStoppingTime f τ
⊢ IsStoppingTime.measurableSpace hτ ≤ m

Next tactic:
cases isEmpty_or_nonempty ι
theorem measurableSpace_le {ι} [SemilatticeSup ι] {f : Filtration ι m} {τ : Ω → ι}
    [IsCountablyGenerated (atTop : Filter ι)] (hτ : IsStoppingTime f τ) :
    hτ.measurableSpace ≤ m := by
  cases isEmpty_or_nonempty ι
  · 

Proof state:
case inl
Ω : Type u_1
β : Type u_2
ι✝ : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι✝
f✝ : Filtration ι✝ m
τ✝ π : Ω → ι✝
ι : Type u_4
inst✝¹ : SemilatticeSup ι
f : Filtration ι m
τ : Ω → ι
inst✝ : IsCountablyGenerated atTop
hτ : IsStoppingTime f τ
h✝ : IsEmpty ι
⊢ IsStoppingTime.measurableSpace hτ ≤ m

Next tactic:
haveI : IsEmpty Ω := ⟨fun ω => IsEmpty.false (τ ω)⟩
theorem measurableSpace_le {ι} [SemilatticeSup ι] {f : Filtration ι m} {τ : Ω → ι}
    [IsCountablyGenerated (atTop : Filter ι)] (hτ : IsStoppingTime f τ) :
    hτ.measurableSpace ≤ m := by
  cases isEmpty_or_nonempty ι
  · haveI : IsEmpty Ω := ⟨fun ω => IsEmpty.false (τ ω)⟩
    

Proof state:
case inl
Ω : Type u_1
β : Type u_2
ι✝ : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι✝
f✝ : Filtration ι✝ m
τ✝ π : Ω → ι✝
ι : Type u_4
inst✝¹ : SemilatticeSup ι
f : Filtration ι m
τ : Ω → ι
inst✝ : IsCountablyGenerated atTop
hτ : IsStoppingTime f τ
h✝ : IsEmpty ι
this : IsEmpty Ω
⊢ IsStoppingTime.measurableSpace hτ ≤ m

Next tactic:
intro s _
theorem measurableSpace_le {ι} [SemilatticeSup ι] {f : Filtration ι m} {τ : Ω → ι}
    [IsCountablyGenerated (atTop : Filter ι)] (hτ : IsStoppingTime f τ) :
    hτ.measurableSpace ≤ m := by
  cases isEmpty_or_nonempty ι
  · haveI : IsEmpty Ω := ⟨fun ω => IsEmpty.false (τ ω)⟩
    intro s _
    

Proof state:
case inl
Ω : Type u_1
β : Type u_2
ι✝ : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι✝
f✝ : Filtration ι✝ m
τ✝ π : Ω → ι✝
ι : Type u_4
inst✝¹ : SemilatticeSup ι
f : Filtration ι m
τ : Ω → ι
inst✝ : IsCountablyGenerated atTop
hτ : IsStoppingTime f τ
h✝ : IsEmpty ι
this : IsEmpty Ω
s : Set Ω
a✝ : MeasurableSet s
⊢ MeasurableSet s

Next tactic:
suffices hs : s = ∅
theorem measurableSpace_le {ι} [SemilatticeSup ι] {f : Filtration ι m} {τ : Ω → ι}
    [IsCountablyGenerated (atTop : Filter ι)] (hτ : IsStoppingTime f τ) :
    hτ.measurableSpace ≤ m := by
  cases isEmpty_or_nonempty ι
  · haveI : IsEmpty Ω := ⟨fun ω => IsEmpty.false (τ ω)⟩
    intro s _
    suffices hs : s = ∅; · 

Proof state:
case inl
Ω : Type u_1
β : Type u_2
ι✝ : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι✝
f✝ : Filtration ι✝ m
τ✝ π : Ω → ι✝
ι : Type u_4
inst✝¹ : SemilatticeSup ι
f : Filtration ι m
τ : Ω → ι
inst✝ : IsCountablyGenerated atTop
hτ : IsStoppingTime f τ
h✝ : IsEmpty ι
this : IsEmpty Ω
s : Set Ω
a✝ : MeasurableSet s
hs : s = ∅
⊢ MeasurableSet s

Next tactic:
rw [hs]
theorem measurableSpace_le {ι} [SemilatticeSup ι] {f : Filtration ι m} {τ : Ω → ι}
    [IsCountablyGenerated (atTop : Filter ι)] (hτ : IsStoppingTime f τ) :
    hτ.measurableSpace ≤ m := by
  cases isEmpty_or_nonempty ι
  · haveI : IsEmpty Ω := ⟨fun ω => IsEmpty.false (τ ω)⟩
    intro s _
    suffices hs : s = ∅; · rw [hs]; 

Proof state:
case inl
Ω : Type u_1
β : Type u_2
ι✝ : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι✝
f✝ : Filtration ι✝ m
τ✝ π : Ω → ι✝
ι : Type u_4
inst✝¹ : SemilatticeSup ι
f : Filtration ι m
τ : Ω → ι
inst✝ : IsCountablyGenerated atTop
hτ : IsStoppingTime f τ
h✝ : IsEmpty ι
this : IsEmpty Ω
s : Set Ω
a✝ : MeasurableSet s
hs : s = ∅
⊢ MeasurableSet ∅

Next tactic:
exact MeasurableSet.empty
theorem measurableSpace_le {ι} [SemilatticeSup ι] {f : Filtration ι m} {τ : Ω → ι}
    [IsCountablyGenerated (atTop : Filter ι)] (hτ : IsStoppingTime f τ) :
    hτ.measurableSpace ≤ m := by
  cases isEmpty_or_nonempty ι
  · haveI : IsEmpty Ω := ⟨fun ω => IsEmpty.false (τ ω)⟩
    intro s _
    suffices hs : s = ∅; · rw [hs]; exact MeasurableSet.empty
    

Proof state:
case hs
Ω : Type u_1
β : Type u_2
ι✝ : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι✝
f✝ : Filtration ι✝ m
τ✝ π : Ω → ι✝
ι : Type u_4
inst✝¹ : SemilatticeSup ι
f : Filtration ι m
τ : Ω → ι
inst✝ : IsCountablyGenerated atTop
hτ : IsStoppingTime f τ
h✝ : IsEmpty ι
this : IsEmpty Ω
s : Set Ω
a✝ : MeasurableSet s
⊢ s = ∅

Next tactic:
haveI : Unique (Set Ω) := Set.uniqueEmpty
theorem measurableSpace_le {ι} [SemilatticeSup ι] {f : Filtration ι m} {τ : Ω → ι}
    [IsCountablyGenerated (atTop : Filter ι)] (hτ : IsStoppingTime f τ) :
    hτ.measurableSpace ≤ m := by
  cases isEmpty_or_nonempty ι
  · haveI : IsEmpty Ω := ⟨fun ω => IsEmpty.false (τ ω)⟩
    intro s _
    suffices hs : s = ∅; · rw [hs]; exact MeasurableSet.empty
    haveI : Unique (Set Ω) := Set.uniqueEmpty
    

Proof state:
case hs
Ω : Type u_1
β : Type u_2
ι✝ : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι✝
f✝ : Filtration ι✝ m
τ✝ π : Ω → ι✝
ι : Type u_4
inst✝¹ : SemilatticeSup ι
f : Filtration ι m
τ : Ω → ι
inst✝ : IsCountablyGenerated atTop
hτ : IsStoppingTime f τ
h✝ : IsEmpty ι
this✝ : IsEmpty Ω
s : Set Ω
a✝ : MeasurableSet s
this : Unique (Set Ω)
⊢ s = ∅

Next tactic:
rw [Unique.eq_default s, Unique.eq_default ∅]
theorem measurableSpace_le {ι} [SemilatticeSup ι] {f : Filtration ι m} {τ : Ω → ι}
    [IsCountablyGenerated (atTop : Filter ι)] (hτ : IsStoppingTime f τ) :
    hτ.measurableSpace ≤ m := by
  cases isEmpty_or_nonempty ι
  · haveI : IsEmpty Ω := ⟨fun ω => IsEmpty.false (τ ω)⟩
    intro s _
    suffices hs : s = ∅; · rw [hs]; exact MeasurableSet.empty
    haveI : Unique (Set Ω) := Set.uniqueEmpty
    rw [Unique.eq_default s, Unique.eq_default ∅]
  

Proof state:
case inr
Ω : Type u_1
β : Type u_2
ι✝ : Type u_3
m : MeasurableSpace Ω
inst✝² : Preorder ι✝
f✝ : Filtration ι✝ m
τ✝ π : Ω → ι✝
ι : Type u_4
inst✝¹ : SemilatticeSup ι
f : Filtration ι m
τ : Ω → ι
inst✝ : IsCountablyGenerated atTop
hτ : IsStoppingTime f τ
h✝ : Nonempty ι
⊢ IsStoppingTime.measurableSpace hτ ≤ m

Next tactic:
exact measurableSpace_le' hτ
@[simp]
theorem measurableSpace_const (f : Filtration ι m) (i : ι) :
    (isStoppingTime_const f i).measurableSpace = f i := by
  

Proof state:
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : Preorder ι
f✝ : Filtration ι m
τ π : Ω → ι
f : Filtration ι m
i : ι
⊢ IsStoppingTime.measurableSpace (_ : IsStoppingTime f fun x => i) = ↑f i

Next tactic:
ext1 s
@[simp]
theorem measurableSpace_const (f : Filtration ι m) (i : ι) :
    (isStoppingTime_const f i).measurableSpace = f i := by
  ext1 s
  

Proof state:
case h
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : Preorder ι
f✝ : Filtration ι m
τ π : Ω → ι
f : Filtration ι m
i : ι
s : Set Ω
⊢ MeasurableSet s ↔ MeasurableSet s

Next tactic:
change MeasurableSet[(isStoppingTime_const f i).measurableSpace] s ↔ MeasurableSet[f i] s
@[simp]
theorem measurableSpace_const (f : Filtration ι m) (i : ι) :
    (isStoppingTime_const f i).measurableSpace = f i := by
  ext1 s
  change MeasurableSet[(isStoppingTime_const f i).measurableSpace] s ↔ MeasurableSet[f i] s
  

Proof state:
case h
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : Preorder ι
f✝ : Filtration ι m
τ π : Ω → ι
f : Filtration ι m
i : ι
s : Set Ω
⊢ MeasurableSet s ↔ MeasurableSet s

Next tactic:
rw [IsStoppingTime.measurableSet]
@[simp]
theorem measurableSpace_const (f : Filtration ι m) (i : ι) :
    (isStoppingTime_const f i).measurableSpace = f i := by
  ext1 s
  change MeasurableSet[(isStoppingTime_const f i).measurableSpace] s ↔ MeasurableSet[f i] s
  rw [IsStoppingTime.measurableSet]
  

Proof state:
case h
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : Preorder ι
f✝ : Filtration ι m
τ π : Ω → ι
f : Filtration ι m
i : ι
s : Set Ω
⊢ (∀ (i_1 : ι), MeasurableSet (s ∩ {ω | i ≤ i_1})) ↔ MeasurableSet s

Next tactic:
constructor
@[simp]
theorem measurableSpace_const (f : Filtration ι m) (i : ι) :
    (isStoppingTime_const f i).measurableSpace = f i := by
  ext1 s
  change MeasurableSet[(isStoppingTime_const f i).measurableSpace] s ↔ MeasurableSet[f i] s
  rw [IsStoppingTime.measurableSet]
  constructor <;> 

Proof state:
case h.mp
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : Preorder ι
f✝ : Filtration ι m
τ π : Ω → ι
f : Filtration ι m
i : ι
s : Set Ω
⊢ (∀ (i_1 : ι), MeasurableSet (s ∩ {ω | i ≤ i_1})) → MeasurableSet s

Next tactic:
intro h
@[simp]
theorem measurableSpace_const (f : Filtration ι m) (i : ι) :
    (isStoppingTime_const f i).measurableSpace = f i := by
  ext1 s
  change MeasurableSet[(isStoppingTime_const f i).measurableSpace] s ↔ MeasurableSet[f i] s
  rw [IsStoppingTime.measurableSet]
  constructor <;> 

Proof state:
case h.mpr
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : Preorder ι
f✝ : Filtration ι m
τ π : Ω → ι
f : Filtration ι m
i : ι
s : Set Ω
⊢ MeasurableSet s → ∀ (i_1 : ι), MeasurableSet (s ∩ {ω | i ≤ i_1})

Next tactic:
intro h
@[simp]
theorem measurableSpace_const (f : Filtration ι m) (i : ι) :
    (isStoppingTime_const f i).measurableSpace = f i := by
  ext1 s
  change MeasurableSet[(isStoppingTime_const f i).measurableSpace] s ↔ MeasurableSet[f i] s
  rw [IsStoppingTime.measurableSet]
  constructor <;> intro h
  · 

Proof state:
case h.mp
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : Preorder ι
f✝ : Filtration ι m
τ π : Ω → ι
f : Filtration ι m
i : ι
s : Set Ω
h : ∀ (i_1 : ι), MeasurableSet (s ∩ {ω | i ≤ i_1})
⊢ MeasurableSet s

Next tactic:
specialize h i
@[simp]
theorem measurableSpace_const (f : Filtration ι m) (i : ι) :
    (isStoppingTime_const f i).measurableSpace = f i := by
  ext1 s
  change MeasurableSet[(isStoppingTime_const f i).measurableSpace] s ↔ MeasurableSet[f i] s
  rw [IsStoppingTime.measurableSet]
  constructor <;> intro h
  · specialize h i
    

Proof state:
case h.mp
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : Preorder ι
f✝ : Filtration ι m
τ π : Ω → ι
f : Filtration ι m
i : ι
s : Set Ω
h : MeasurableSet (s ∩ {ω | i ≤ i})
⊢ MeasurableSet s

Next tactic:
simpa only [le_refl, Set.setOf_true, Set.inter_univ] using h
@[simp]
theorem measurableSpace_const (f : Filtration ι m) (i : ι) :
    (isStoppingTime_const f i).measurableSpace = f i := by
  ext1 s
  change MeasurableSet[(isStoppingTime_const f i).measurableSpace] s ↔ MeasurableSet[f i] s
  rw [IsStoppingTime.measurableSet]
  constructor <;> intro h
  · specialize h i
    simpa only [le_refl, Set.setOf_true, Set.inter_univ] using h
  · 

Proof state:
case h.mpr
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : Preorder ι
f✝ : Filtration ι m
τ π : Ω → ι
f : Filtration ι m
i : ι
s : Set Ω
h : MeasurableSet s
⊢ ∀ (i_1 : ι), MeasurableSet (s ∩ {ω | i ≤ i_1})

Next tactic:
intro j
@[simp]
theorem measurableSpace_const (f : Filtration ι m) (i : ι) :
    (isStoppingTime_const f i).measurableSpace = f i := by
  ext1 s
  change MeasurableSet[(isStoppingTime_const f i).measurableSpace] s ↔ MeasurableSet[f i] s
  rw [IsStoppingTime.measurableSet]
  constructor <;> intro h
  · specialize h i
    simpa only [le_refl, Set.setOf_true, Set.inter_univ] using h
  · intro j
    

Proof state:
case h.mpr
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : Preorder ι
f✝ : Filtration ι m
τ π : Ω → ι
f : Filtration ι m
i : ι
s : Set Ω
h : MeasurableSet s
j : ι
⊢ MeasurableSet (s ∩ {ω | i ≤ j})

Next tactic:
by_cases hij : i ≤ j
@[simp]
theorem measurableSpace_const (f : Filtration ι m) (i : ι) :
    (isStoppingTime_const f i).measurableSpace = f i := by
  ext1 s
  change MeasurableSet[(isStoppingTime_const f i).measurableSpace] s ↔ MeasurableSet[f i] s
  rw [IsStoppingTime.measurableSet]
  constructor <;> intro h
  · specialize h i
    simpa only [le_refl, Set.setOf_true, Set.inter_univ] using h
  · intro j
    by_cases hij : i ≤ j
    · 

Proof state:
case pos
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : Preorder ι
f✝ : Filtration ι m
τ π : Ω → ι
f : Filtration ι m
i : ι
s : Set Ω
h : MeasurableSet s
j : ι
hij : i ≤ j
⊢ MeasurableSet (s ∩ {ω | i ≤ j})

Next tactic:
simp only [hij, Set.setOf_true, Set.inter_univ]
@[simp]
theorem measurableSpace_const (f : Filtration ι m) (i : ι) :
    (isStoppingTime_const f i).measurableSpace = f i := by
  ext1 s
  change MeasurableSet[(isStoppingTime_const f i).measurableSpace] s ↔ MeasurableSet[f i] s
  rw [IsStoppingTime.measurableSet]
  constructor <;> intro h
  · specialize h i
    simpa only [le_refl, Set.setOf_true, Set.inter_univ] using h
  · intro j
    by_cases hij : i ≤ j
    · simp only [hij, Set.setOf_true, Set.inter_univ]
      

Proof state:
case pos
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : Preorder ι
f✝ : Filtration ι m
τ π : Ω → ι
f : Filtration ι m
i : ι
s : Set Ω
h : MeasurableSet s
j : ι
hij : i ≤ j
⊢ MeasurableSet s

Next tactic:
exact f.mono hij _ h
@[simp]
theorem measurableSpace_const (f : Filtration ι m) (i : ι) :
    (isStoppingTime_const f i).measurableSpace = f i := by
  ext1 s
  change MeasurableSet[(isStoppingTime_const f i).measurableSpace] s ↔ MeasurableSet[f i] s
  rw [IsStoppingTime.measurableSet]
  constructor <;> intro h
  · specialize h i
    simpa only [le_refl, Set.setOf_true, Set.inter_univ] using h
  · intro j
    by_cases hij : i ≤ j
    · simp only [hij, Set.setOf_true, Set.inter_univ]
      exact f.mono hij _ h
    · 

Proof state:
case neg
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : Preorder ι
f✝ : Filtration ι m
τ π : Ω → ι
f : Filtration ι m
i : ι
s : Set Ω
h : MeasurableSet s
j : ι
hij : ¬i ≤ j
⊢ MeasurableSet (s ∩ {ω | i ≤ j})

Next tactic:
simp only [hij, Set.setOf_false, Set.inter_empty, @MeasurableSet.empty _ (f.1 j)]