l3lab/ntp-mathlib huggingface dataset:
/-- At each step of the inductive construction, the cardinality bound `≤ (max #s 2) ^ ℵ₀` holds.
-/
theorem cardinal_generateMeasurableRec_le (s : Set (Set α)) (i : ω₁) :
    #(generateMeasurableRec s i) ≤ max #s 2 ^ aleph0.{u} := by
  apply (aleph 1).ord.out.wo.wf.induction i
  intro i IH
  have A := aleph0_le_aleph 1
  have B : aleph 1 ≤ max #s 2 ^ aleph0.{u} :=
    aleph_one_le_continuum.trans (power_le_power_right (le_max_right _ _))
  have C : ℵ₀ ≤ max #s 2 ^ aleph0.{u} := A.trans B
  have J : #(⋃ j : Iio i, generateMeasurableRec s j.1) ≤ max #s 2 ^ aleph0.{u} := by
    refine (mk_iUnion_le _).trans ?_
    have D : ⨆ j : Iio i, #(generateMeasurableRec s j) ≤ _ := ciSup_le' fun ⟨j, hj⟩ => IH j hj
    apply (mul_le_mul' ((mk_subtype_le _).trans (aleph 1).mk_ord_out.le) D).trans
    rw [mul_eq_max A C]
    exact max_le B le_rfl
  

Proof state:
α : Type u
s : Set (Set α)
i✝ i : (Quotient.out (ord (aleph 1))).α
IH :
  ∀ (y : (Quotient.out (ord (aleph 1))).α),
    WellOrder.r (Quotient.out (ord (aleph 1))) y i → #↑(generateMeasurableRec s y) ≤ max (#↑s) 2 ^ ℵ₀
A : ℵ₀ ≤ aleph 1
B : aleph 1 ≤ max (#↑s) 2 ^ ℵ₀
C : ℵ₀ ≤ max (#↑s) 2 ^ ℵ₀
J : #↑(⋃ j, generateMeasurableRec s ↑j) ≤ max (#↑s) 2 ^ ℵ₀
⊢ #↑(generateMeasurableRec s i) ≤ max (#↑s) 2 ^ ℵ₀

Next tactic:
rw [generateMeasurableRec]
/-- At each step of the inductive construction, the cardinality bound `≤ (max #s 2) ^ ℵ₀` holds.
-/
theorem cardinal_generateMeasurableRec_le (s : Set (Set α)) (i : ω₁) :
    #(generateMeasurableRec s i) ≤ max #s 2 ^ aleph0.{u} := by
  apply (aleph 1).ord.out.wo.wf.induction i
  intro i IH
  have A := aleph0_le_aleph 1
  have B : aleph 1 ≤ max #s 2 ^ aleph0.{u} :=
    aleph_one_le_continuum.trans (power_le_power_right (le_max_right _ _))
  have C : ℵ₀ ≤ max #s 2 ^ aleph0.{u} := A.trans B
  have J : #(⋃ j : Iio i, generateMeasurableRec s j.1) ≤ max #s 2 ^ aleph0.{u} := by
    refine (mk_iUnion_le _).trans ?_
    have D : ⨆ j : Iio i, #(generateMeasurableRec s j) ≤ _ := ciSup_le' fun ⟨j, hj⟩ => IH j hj
    apply (mul_le_mul' ((mk_subtype_le _).trans (aleph 1).mk_ord_out.le) D).trans
    rw [mul_eq_max A C]
    exact max_le B le_rfl
  rw [generateMeasurableRec]
  

Proof state:
α : Type u
s : Set (Set α)
i✝ i : (Quotient.out (ord (aleph 1))).α
IH :
  ∀ (y : (Quotient.out (ord (aleph 1))).α),
    WellOrder.r (Quotient.out (ord (aleph 1))) y i → #↑(generateMeasurableRec s y) ≤ max (#↑s) 2 ^ ℵ₀
A : ℵ₀ ≤ aleph 1
B : aleph 1 ≤ max (#↑s) 2 ^ ℵ₀
C : ℵ₀ ≤ max (#↑s) 2 ^ ℵ₀
J : #↑(⋃ j, generateMeasurableRec s ↑j) ≤ max (#↑s) 2 ^ ℵ₀
⊢ #↑((s ∪ {∅} ∪ compl '' ⋃ j, generateMeasurableRec s ↑j) ∪ range fun f => ⋃ n, ↑(f n)) ≤ max (#↑s) 2 ^ ℵ₀

Next tactic:
apply_rules [(mk_union_le _ _).trans, add_le_of_le C, mk_image_le.trans]
/-- At each step of the inductive construction, the cardinality bound `≤ (max #s 2) ^ ℵ₀` holds.
-/
theorem cardinal_generateMeasurableRec_le (s : Set (Set α)) (i : ω₁) :
    #(generateMeasurableRec s i) ≤ max #s 2 ^ aleph0.{u} := by
  apply (aleph 1).ord.out.wo.wf.induction i
  intro i IH
  have A := aleph0_le_aleph 1
  have B : aleph 1 ≤ max #s 2 ^ aleph0.{u} :=
    aleph_one_le_continuum.trans (power_le_power_right (le_max_right _ _))
  have C : ℵ₀ ≤ max #s 2 ^ aleph0.{u} := A.trans B
  have J : #(⋃ j : Iio i, generateMeasurableRec s j.1) ≤ max #s 2 ^ aleph0.{u} := by
    refine (mk_iUnion_le _).trans ?_
    have D : ⨆ j : Iio i, #(generateMeasurableRec s j) ≤ _ := ciSup_le' fun ⟨j, hj⟩ => IH j hj
    apply (mul_le_mul' ((mk_subtype_le _).trans (aleph 1).mk_ord_out.le) D).trans
    rw [mul_eq_max A C]
    exact max_le B le_rfl
  rw [generateMeasurableRec]
  apply_rules [(mk_union_le _ _).trans, add_le_of_le C, mk_image_le.trans]
  · 

Proof state:
case h1.h1.h1
α : Type u
s : Set (Set α)
i✝ i : (Quotient.out (ord (aleph 1))).α
IH :
  ∀ (y : (Quotient.out (ord (aleph 1))).α),
    WellOrder.r (Quotient.out (ord (aleph 1))) y i → #↑(generateMeasurableRec s y) ≤ max (#↑s) 2 ^ ℵ₀
A : ℵ₀ ≤ aleph 1
B : aleph 1 ≤ max (#↑s) 2 ^ ℵ₀
C : ℵ₀ ≤ max (#↑s) 2 ^ ℵ₀
J : #↑(⋃ j, generateMeasurableRec s ↑j) ≤ max (#↑s) 2 ^ ℵ₀
⊢ #↑s ≤ max (#↑s) 2 ^ ℵ₀

Next tactic:
exact (le_max_left _ _).trans (self_le_power _ one_lt_aleph0.le)
/-- At each step of the inductive construction, the cardinality bound `≤ (max #s 2) ^ ℵ₀` holds.
-/
theorem cardinal_generateMeasurableRec_le (s : Set (Set α)) (i : ω₁) :
    #(generateMeasurableRec s i) ≤ max #s 2 ^ aleph0.{u} := by
  apply (aleph 1).ord.out.wo.wf.induction i
  intro i IH
  have A := aleph0_le_aleph 1
  have B : aleph 1 ≤ max #s 2 ^ aleph0.{u} :=
    aleph_one_le_continuum.trans (power_le_power_right (le_max_right _ _))
  have C : ℵ₀ ≤ max #s 2 ^ aleph0.{u} := A.trans B
  have J : #(⋃ j : Iio i, generateMeasurableRec s j.1) ≤ max #s 2 ^ aleph0.{u} := by
    refine (mk_iUnion_le _).trans ?_
    have D : ⨆ j : Iio i, #(generateMeasurableRec s j) ≤ _ := ciSup_le' fun ⟨j, hj⟩ => IH j hj
    apply (mul_le_mul' ((mk_subtype_le _).trans (aleph 1).mk_ord_out.le) D).trans
    rw [mul_eq_max A C]
    exact max_le B le_rfl
  rw [generateMeasurableRec]
  apply_rules [(mk_union_le _ _).trans, add_le_of_le C, mk_image_le.trans]
  · exact (le_max_left _ _).trans (self_le_power _ one_lt_aleph0.le)
  · 

Proof state:
case h1.h1.h2
α : Type u
s : Set (Set α)
i✝ i : (Quotient.out (ord (aleph 1))).α
IH :
  ∀ (y : (Quotient.out (ord (aleph 1))).α),
    WellOrder.r (Quotient.out (ord (aleph 1))) y i → #↑(generateMeasurableRec s y) ≤ max (#↑s) 2 ^ ℵ₀
A : ℵ₀ ≤ aleph 1
B : aleph 1 ≤ max (#↑s) 2 ^ ℵ₀
C : ℵ₀ ≤ max (#↑s) 2 ^ ℵ₀
J : #↑(⋃ j, generateMeasurableRec s ↑j) ≤ max (#↑s) 2 ^ ℵ₀
⊢ #↑{∅} ≤ max (#↑s) 2 ^ ℵ₀

Next tactic:
rw [mk_singleton]
/-- At each step of the inductive construction, the cardinality bound `≤ (max #s 2) ^ ℵ₀` holds.
-/
theorem cardinal_generateMeasurableRec_le (s : Set (Set α)) (i : ω₁) :
    #(generateMeasurableRec s i) ≤ max #s 2 ^ aleph0.{u} := by
  apply (aleph 1).ord.out.wo.wf.induction i
  intro i IH
  have A := aleph0_le_aleph 1
  have B : aleph 1 ≤ max #s 2 ^ aleph0.{u} :=
    aleph_one_le_continuum.trans (power_le_power_right (le_max_right _ _))
  have C : ℵ₀ ≤ max #s 2 ^ aleph0.{u} := A.trans B
  have J : #(⋃ j : Iio i, generateMeasurableRec s j.1) ≤ max #s 2 ^ aleph0.{u} := by
    refine (mk_iUnion_le _).trans ?_
    have D : ⨆ j : Iio i, #(generateMeasurableRec s j) ≤ _ := ciSup_le' fun ⟨j, hj⟩ => IH j hj
    apply (mul_le_mul' ((mk_subtype_le _).trans (aleph 1).mk_ord_out.le) D).trans
    rw [mul_eq_max A C]
    exact max_le B le_rfl
  rw [generateMeasurableRec]
  apply_rules [(mk_union_le _ _).trans, add_le_of_le C, mk_image_le.trans]
  · exact (le_max_left _ _).trans (self_le_power _ one_lt_aleph0.le)
  · rw [mk_singleton]
    

Proof state:
case h1.h1.h2
α : Type u
s : Set (Set α)
i✝ i : (Quotient.out (ord (aleph 1))).α
IH :
  ∀ (y : (Quotient.out (ord (aleph 1))).α),
    WellOrder.r (Quotient.out (ord (aleph 1))) y i → #↑(generateMeasurableRec s y) ≤ max (#↑s) 2 ^ ℵ₀
A : ℵ₀ ≤ aleph 1
B : aleph 1 ≤ max (#↑s) 2 ^ ℵ₀
C : ℵ₀ ≤ max (#↑s) 2 ^ ℵ₀
J : #↑(⋃ j, generateMeasurableRec s ↑j) ≤ max (#↑s) 2 ^ ℵ₀
⊢ 1 ≤ max (#↑s) 2 ^ ℵ₀

Next tactic:
exact one_lt_aleph0.le.trans C
/-- At each step of the inductive construction, the cardinality bound `≤ (max #s 2) ^ ℵ₀` holds.
-/
theorem cardinal_generateMeasurableRec_le (s : Set (Set α)) (i : ω₁) :
    #(generateMeasurableRec s i) ≤ max #s 2 ^ aleph0.{u} := by
  apply (aleph 1).ord.out.wo.wf.induction i
  intro i IH
  have A := aleph0_le_aleph 1
  have B : aleph 1 ≤ max #s 2 ^ aleph0.{u} :=
    aleph_one_le_continuum.trans (power_le_power_right (le_max_right _ _))
  have C : ℵ₀ ≤ max #s 2 ^ aleph0.{u} := A.trans B
  have J : #(⋃ j : Iio i, generateMeasurableRec s j.1) ≤ max #s 2 ^ aleph0.{u} := by
    refine (mk_iUnion_le _).trans ?_
    have D : ⨆ j : Iio i, #(generateMeasurableRec s j) ≤ _ := ciSup_le' fun ⟨j, hj⟩ => IH j hj
    apply (mul_le_mul' ((mk_subtype_le _).trans (aleph 1).mk_ord_out.le) D).trans
    rw [mul_eq_max A C]
    exact max_le B le_rfl
  rw [generateMeasurableRec]
  apply_rules [(mk_union_le _ _).trans, add_le_of_le C, mk_image_le.trans]
  · exact (le_max_left _ _).trans (self_le_power _ one_lt_aleph0.le)
  · rw [mk_singleton]
    exact one_lt_aleph0.le.trans C
  · 

Proof state:
case h2
α : Type u
s : Set (Set α)
i✝ i : (Quotient.out (ord (aleph 1))).α
IH :
  ∀ (y : (Quotient.out (ord (aleph 1))).α),
    WellOrder.r (Quotient.out (ord (aleph 1))) y i → #↑(generateMeasurableRec s y) ≤ max (#↑s) 2 ^ ℵ₀
A : ℵ₀ ≤ aleph 1
B : aleph 1 ≤ max (#↑s) 2 ^ ℵ₀
C : ℵ₀ ≤ max (#↑s) 2 ^ ℵ₀
J : #↑(⋃ j, generateMeasurableRec s ↑j) ≤ max (#↑s) 2 ^ ℵ₀
⊢ #↑(range fun f => ⋃ n, ↑(f n)) ≤ max (#↑s) 2 ^ ℵ₀

Next tactic:
apply mk_range_le.trans
/-- At each step of the inductive construction, the cardinality bound `≤ (max #s 2) ^ ℵ₀` holds.
-/
theorem cardinal_generateMeasurableRec_le (s : Set (Set α)) (i : ω₁) :
    #(generateMeasurableRec s i) ≤ max #s 2 ^ aleph0.{u} := by
  apply (aleph 1).ord.out.wo.wf.induction i
  intro i IH
  have A := aleph0_le_aleph 1
  have B : aleph 1 ≤ max #s 2 ^ aleph0.{u} :=
    aleph_one_le_continuum.trans (power_le_power_right (le_max_right _ _))
  have C : ℵ₀ ≤ max #s 2 ^ aleph0.{u} := A.trans B
  have J : #(⋃ j : Iio i, generateMeasurableRec s j.1) ≤ max #s 2 ^ aleph0.{u} := by
    refine (mk_iUnion_le _).trans ?_
    have D : ⨆ j : Iio i, #(generateMeasurableRec s j) ≤ _ := ciSup_le' fun ⟨j, hj⟩ => IH j hj
    apply (mul_le_mul' ((mk_subtype_le _).trans (aleph 1).mk_ord_out.le) D).trans
    rw [mul_eq_max A C]
    exact max_le B le_rfl
  rw [generateMeasurableRec]
  apply_rules [(mk_union_le _ _).trans, add_le_of_le C, mk_image_le.trans]
  · exact (le_max_left _ _).trans (self_le_power _ one_lt_aleph0.le)
  · rw [mk_singleton]
    exact one_lt_aleph0.le.trans C
  · apply mk_range_le.trans
    

Proof state:
case h2
α : Type u
s : Set (Set α)
i✝ i : (Quotient.out (ord (aleph 1))).α
IH :
  ∀ (y : (Quotient.out (ord (aleph 1))).α),
    WellOrder.r (Quotient.out (ord (aleph 1))) y i → #↑(generateMeasurableRec s y) ≤ max (#↑s) 2 ^ ℵ₀
A : ℵ₀ ≤ aleph 1
B : aleph 1 ≤ max (#↑s) 2 ^ ℵ₀
C : ℵ₀ ≤ max (#↑s) 2 ^ ℵ₀
J : #↑(⋃ j, generateMeasurableRec s ↑j) ≤ max (#↑s) 2 ^ ℵ₀
⊢ #(ℕ → ↑(⋃ j, generateMeasurableRec s ↑j)) ≤ max (#↑s) 2 ^ ℵ₀

Next tactic:
simp only [mk_pi, prod_const, lift_uzero, mk_denumerable, lift_aleph0]
/-- At each step of the inductive construction, the cardinality bound `≤ (max #s 2) ^ ℵ₀` holds.
-/
theorem cardinal_generateMeasurableRec_le (s : Set (Set α)) (i : ω₁) :
    #(generateMeasurableRec s i) ≤ max #s 2 ^ aleph0.{u} := by
  apply (aleph 1).ord.out.wo.wf.induction i
  intro i IH
  have A := aleph0_le_aleph 1
  have B : aleph 1 ≤ max #s 2 ^ aleph0.{u} :=
    aleph_one_le_continuum.trans (power_le_power_right (le_max_right _ _))
  have C : ℵ₀ ≤ max #s 2 ^ aleph0.{u} := A.trans B
  have J : #(⋃ j : Iio i, generateMeasurableRec s j.1) ≤ max #s 2 ^ aleph0.{u} := by
    refine (mk_iUnion_le _).trans ?_
    have D : ⨆ j : Iio i, #(generateMeasurableRec s j) ≤ _ := ciSup_le' fun ⟨j, hj⟩ => IH j hj
    apply (mul_le_mul' ((mk_subtype_le _).trans (aleph 1).mk_ord_out.le) D).trans
    rw [mul_eq_max A C]
    exact max_le B le_rfl
  rw [generateMeasurableRec]
  apply_rules [(mk_union_le _ _).trans, add_le_of_le C, mk_image_le.trans]
  · exact (le_max_left _ _).trans (self_le_power _ one_lt_aleph0.le)
  · rw [mk_singleton]
    exact one_lt_aleph0.le.trans C
  · apply mk_range_le.trans
    simp only [mk_pi, prod_const, lift_uzero, mk_denumerable, lift_aleph0]
    

Proof state:
case h2
α : Type u
s : Set (Set α)
i✝ i : (Quotient.out (ord (aleph 1))).α
IH :
  ∀ (y : (Quotient.out (ord (aleph 1))).α),
    WellOrder.r (Quotient.out (ord (aleph 1))) y i → #↑(generateMeasurableRec s y) ≤ max (#↑s) 2 ^ ℵ₀
A : ℵ₀ ≤ aleph 1
B : aleph 1 ≤ max (#↑s) 2 ^ ℵ₀
C : ℵ₀ ≤ max (#↑s) 2 ^ ℵ₀
J : #↑(⋃ j, generateMeasurableRec s ↑j) ≤ max (#↑s) 2 ^ ℵ₀
⊢ #↑(⋃ j, generateMeasurableRec s ↑j) ^ ℵ₀ ≤ max (#↑s) 2 ^ ℵ₀

Next tactic:
have := @power_le_power_right _ _ ℵ₀ J
/-- At each step of the inductive construction, the cardinality bound `≤ (max #s 2) ^ ℵ₀` holds.
-/
theorem cardinal_generateMeasurableRec_le (s : Set (Set α)) (i : ω₁) :
    #(generateMeasurableRec s i) ≤ max #s 2 ^ aleph0.{u} := by
  apply (aleph 1).ord.out.wo.wf.induction i
  intro i IH
  have A := aleph0_le_aleph 1
  have B : aleph 1 ≤ max #s 2 ^ aleph0.{u} :=
    aleph_one_le_continuum.trans (power_le_power_right (le_max_right _ _))
  have C : ℵ₀ ≤ max #s 2 ^ aleph0.{u} := A.trans B
  have J : #(⋃ j : Iio i, generateMeasurableRec s j.1) ≤ max #s 2 ^ aleph0.{u} := by
    refine (mk_iUnion_le _).trans ?_
    have D : ⨆ j : Iio i, #(generateMeasurableRec s j) ≤ _ := ciSup_le' fun ⟨j, hj⟩ => IH j hj
    apply (mul_le_mul' ((mk_subtype_le _).trans (aleph 1).mk_ord_out.le) D).trans
    rw [mul_eq_max A C]
    exact max_le B le_rfl
  rw [generateMeasurableRec]
  apply_rules [(mk_union_le _ _).trans, add_le_of_le C, mk_image_le.trans]
  · exact (le_max_left _ _).trans (self_le_power _ one_lt_aleph0.le)
  · rw [mk_singleton]
    exact one_lt_aleph0.le.trans C
  · apply mk_range_le.trans
    simp only [mk_pi, prod_const, lift_uzero, mk_denumerable, lift_aleph0]
    have := @power_le_power_right _ _ ℵ₀ J
    

Proof state:
case h2
α : Type u
s : Set (Set α)
i✝ i : (Quotient.out (ord (aleph 1))).α
IH :
  ∀ (y : (Quotient.out (ord (aleph 1))).α),
    WellOrder.r (Quotient.out (ord (aleph 1))) y i → #↑(generateMeasurableRec s y) ≤ max (#↑s) 2 ^ ℵ₀
A : ℵ₀ ≤ aleph 1
B : aleph 1 ≤ max (#↑s) 2 ^ ℵ₀
C : ℵ₀ ≤ max (#↑s) 2 ^ ℵ₀
J : #↑(⋃ j, generateMeasurableRec s ↑j) ≤ max (#↑s) 2 ^ ℵ₀
this : #↑(⋃ j, generateMeasurableRec s ↑j) ^ ℵ₀ ≤ (max (#↑s) 2 ^ ℵ₀) ^ ℵ₀
⊢ #↑(⋃ j, generateMeasurableRec s ↑j) ^ ℵ₀ ≤ max (#↑s) 2 ^ ℵ₀

Next tactic:
rwa [← power_mul, aleph0_mul_aleph0] at this
/-- `generateMeasurableRec s` generates precisely the smallest sigma-algebra containing `s`. -/
theorem generateMeasurable_eq_rec (s : Set (Set α)) :
    { t | GenerateMeasurable s t } =
        ⋃ (i : (Quotient.out (aleph 1).ord).α), generateMeasurableRec s i := by
  

Proof state:
α : Type u
s : Set (Set α)
⊢ {t | GenerateMeasurable s t} = ⋃ i, generateMeasurableRec s i

Next tactic:
ext t
/-- `generateMeasurableRec s` generates precisely the smallest sigma-algebra containing `s`. -/
theorem generateMeasurable_eq_rec (s : Set (Set α)) :
    { t | GenerateMeasurable s t } =
        ⋃ (i : (Quotient.out (aleph 1).ord).α), generateMeasurableRec s i := by
  ext t; 

Proof state:
case h
α : Type u
s : Set (Set α)
t : Set α
⊢ t ∈ {t | GenerateMeasurable s t} ↔ t ∈ ⋃ i, generateMeasurableRec s i

Next tactic:
refine' ⟨fun ht => _, fun ht => _⟩
/-- `generateMeasurableRec s` generates precisely the smallest sigma-algebra containing `s`. -/
theorem generateMeasurable_eq_rec (s : Set (Set α)) :
    { t | GenerateMeasurable s t } =
        ⋃ (i : (Quotient.out (aleph 1).ord).α), generateMeasurableRec s i := by
  ext t; refine' ⟨fun ht => _, fun ht => _⟩
  · 

Proof state:
case h.refine'_1
α : Type u
s : Set (Set α)
t : Set α
ht : t ∈ {t | GenerateMeasurable s t}
⊢ t ∈ ⋃ i, generateMeasurableRec s i

Next tactic:
inhabit ω₁
/-- `generateMeasurableRec s` generates precisely the smallest sigma-algebra containing `s`. -/
theorem generateMeasurable_eq_rec (s : Set (Set α)) :
    { t | GenerateMeasurable s t } =
        ⋃ (i : (Quotient.out (aleph 1).ord).α), generateMeasurableRec s i := by
  ext t; refine' ⟨fun ht => _, fun ht => _⟩
  · inhabit ω₁
    

Proof state:
case h.refine'_1
α : Type u
s : Set (Set α)
t : Set α
ht : t ∈ {t | GenerateMeasurable s t}
inhabited_h : Inhabited (Quotient.out (ord (aleph 1))).α
⊢ t ∈ ⋃ i, generateMeasurableRec s i

Next tactic:
induction' ht with u hu u _ IH f _ IH
/-- `generateMeasurableRec s` generates precisely the smallest sigma-algebra containing `s`. -/
theorem generateMeasurable_eq_rec (s : Set (Set α)) :
    { t | GenerateMeasurable s t } =
        ⋃ (i : (Quotient.out (aleph 1).ord).α), generateMeasurableRec s i := by
  ext t; refine' ⟨fun ht => _, fun ht => _⟩
  · inhabit ω₁
    induction' ht with u hu u _ IH f _ IH
    · 

Proof state:
case h.refine'_1.basic
α : Type u
s : Set (Set α)
t : Set α
inhabited_h : Inhabited (Quotient.out (ord (aleph 1))).α
u : Set α
hu : u ∈ s
⊢ u ∈ ⋃ i, generateMeasurableRec s i

Next tactic:
exact mem_iUnion.2 ⟨default, self_subset_generateMeasurableRec s _ hu⟩
/-- `generateMeasurableRec s` generates precisely the smallest sigma-algebra containing `s`. -/
theorem generateMeasurable_eq_rec (s : Set (Set α)) :
    { t | GenerateMeasurable s t } =
        ⋃ (i : (Quotient.out (aleph 1).ord).α), generateMeasurableRec s i := by
  ext t; refine' ⟨fun ht => _, fun ht => _⟩
  · inhabit ω₁
    induction' ht with u hu u _ IH f _ IH
    · exact mem_iUnion.2 ⟨default, self_subset_generateMeasurableRec s _ hu⟩
    · 

Proof state:
case h.refine'_1.empty
α : Type u
s : Set (Set α)
t : Set α
inhabited_h : Inhabited (Quotient.out (ord (aleph 1))).α
⊢ ∅ ∈ ⋃ i, generateMeasurableRec s i

Next tactic:
exact mem_iUnion.2 ⟨default, empty_mem_generateMeasurableRec s _⟩
/-- `generateMeasurableRec s` generates precisely the smallest sigma-algebra containing `s`. -/
theorem generateMeasurable_eq_rec (s : Set (Set α)) :
    { t | GenerateMeasurable s t } =
        ⋃ (i : (Quotient.out (aleph 1).ord).α), generateMeasurableRec s i := by
  ext t; refine' ⟨fun ht => _, fun ht => _⟩
  · inhabit ω₁
    induction' ht with u hu u _ IH f _ IH
    · exact mem_iUnion.2 ⟨default, self_subset_generateMeasurableRec s _ hu⟩
    · exact mem_iUnion.2 ⟨default, empty_mem_generateMeasurableRec s _⟩
    · 

Proof state:
case h.refine'_1.compl
α : Type u
s : Set (Set α)
t : Set α
inhabited_h : Inhabited (Quotient.out (ord (aleph 1))).α
u : Set α
a✝ : GenerateMeasurable s u
IH : u ∈ ⋃ i, generateMeasurableRec s i
⊢ uᶜ ∈ ⋃ i, generateMeasurableRec s i

Next tactic:
rcases mem_iUnion.1 IH with ⟨i, hi⟩
/-- `generateMeasurableRec s` generates precisely the smallest sigma-algebra containing `s`. -/
theorem generateMeasurable_eq_rec (s : Set (Set α)) :
    { t | GenerateMeasurable s t } =
        ⋃ (i : (Quotient.out (aleph 1).ord).α), generateMeasurableRec s i := by
  ext t; refine' ⟨fun ht => _, fun ht => _⟩
  · inhabit ω₁
    induction' ht with u hu u _ IH f _ IH
    · exact mem_iUnion.2 ⟨default, self_subset_generateMeasurableRec s _ hu⟩
    · exact mem_iUnion.2 ⟨default, empty_mem_generateMeasurableRec s _⟩
    · rcases mem_iUnion.1 IH with ⟨i, hi⟩
      

Proof state:
case h.refine'_1.compl.intro
α : Type u
s : Set (Set α)
t : Set α
inhabited_h : Inhabited (Quotient.out (ord (aleph 1))).α
u : Set α
a✝ : GenerateMeasurable s u
IH : u ∈ ⋃ i, generateMeasurableRec s i
i : (Quotient.out (ord (aleph 1))).α
hi : u ∈ generateMeasurableRec s i
⊢ uᶜ ∈ ⋃ i, generateMeasurableRec s i

Next tactic:
obtain ⟨j, hj⟩ := exists_gt i
/-- `generateMeasurableRec s` generates precisely the smallest sigma-algebra containing `s`. -/
theorem generateMeasurable_eq_rec (s : Set (Set α)) :
    { t | GenerateMeasurable s t } =
        ⋃ (i : (Quotient.out (aleph 1).ord).α), generateMeasurableRec s i := by
  ext t; refine' ⟨fun ht => _, fun ht => _⟩
  · inhabit ω₁
    induction' ht with u hu u _ IH f _ IH
    · exact mem_iUnion.2 ⟨default, self_subset_generateMeasurableRec s _ hu⟩
    · exact mem_iUnion.2 ⟨default, empty_mem_generateMeasurableRec s _⟩
    · rcases mem_iUnion.1 IH with ⟨i, hi⟩
      obtain ⟨j, hj⟩ := exists_gt i
      

Proof state:
case h.refine'_1.compl.intro.intro
α : Type u
s : Set (Set α)
t : Set α
inhabited_h : Inhabited (Quotient.out (ord (aleph 1))).α
u : Set α
a✝ : GenerateMeasurable s u
IH : u ∈ ⋃ i, generateMeasurableRec s i
i : (Quotient.out (ord (aleph 1))).α
hi : u ∈ generateMeasurableRec s i
j : (Quotient.out (ord (aleph 1))).α
hj : i < j
⊢ uᶜ ∈ ⋃ i, generateMeasurableRec s i

Next tactic:
exact mem_iUnion.2 ⟨j, compl_mem_generateMeasurableRec hj hi⟩
/-- `generateMeasurableRec s` generates precisely the smallest sigma-algebra containing `s`. -/
theorem generateMeasurable_eq_rec (s : Set (Set α)) :
    { t | GenerateMeasurable s t } =
        ⋃ (i : (Quotient.out (aleph 1).ord).α), generateMeasurableRec s i := by
  ext t; refine' ⟨fun ht => _, fun ht => _⟩
  · inhabit ω₁
    induction' ht with u hu u _ IH f _ IH
    · exact mem_iUnion.2 ⟨default, self_subset_generateMeasurableRec s _ hu⟩
    · exact mem_iUnion.2 ⟨default, empty_mem_generateMeasurableRec s _⟩
    · rcases mem_iUnion.1 IH with ⟨i, hi⟩
      obtain ⟨j, hj⟩ := exists_gt i
      exact mem_iUnion.2 ⟨j, compl_mem_generateMeasurableRec hj hi⟩
    · 

Proof state:
case h.refine'_1.iUnion
α : Type u
s : Set (Set α)
t : Set α
inhabited_h : Inhabited (Quotient.out (ord (aleph 1))).α
f : ℕ → Set α
a✝ : ∀ (n : ℕ), GenerateMeasurable s (f n)
IH : ∀ (n : ℕ), f n ∈ ⋃ i, generateMeasurableRec s i
⊢ ⋃ i, f i ∈ ⋃ i, generateMeasurableRec s i

Next tactic:
have : ∀ n, ∃ i, f n ∈ generateMeasurableRec s i := fun n => by simpa using IH n
/-- `generateMeasurableRec s` generates precisely the smallest sigma-algebra containing `s`. -/
theorem generateMeasurable_eq_rec (s : Set (Set α)) :
    { t | GenerateMeasurable s t } =
        ⋃ (i : (Quotient.out (aleph 1).ord).α), generateMeasurableRec s i := by
  ext t; refine' ⟨fun ht => _, fun ht => _⟩
  · inhabit ω₁
    induction' ht with u hu u _ IH f _ IH
    · exact mem_iUnion.2 ⟨default, self_subset_generateMeasurableRec s _ hu⟩
    · exact mem_iUnion.2 ⟨default, empty_mem_generateMeasurableRec s _⟩
    · rcases mem_iUnion.1 IH with ⟨i, hi⟩
      obtain ⟨j, hj⟩ := exists_gt i
      exact mem_iUnion.2 ⟨j, compl_mem_generateMeasurableRec hj hi⟩
    · have : ∀ n, ∃ i, f n ∈ generateMeasurableRec s i := fun n => by 

Proof state:
α : Type u
s : Set (Set α)
t : Set α
inhabited_h : Inhabited (Quotient.out (ord (aleph 1))).α
f : ℕ → Set α
a✝ : ∀ (n : ℕ), GenerateMeasurable s (f n)
IH : ∀ (n : ℕ), f n ∈ ⋃ i, generateMeasurableRec s i
n : ℕ
⊢ ∃ i, f n ∈ generateMeasurableRec s i

Next tactic:
simpa using IH n
/-- `generateMeasurableRec s` generates precisely the smallest sigma-algebra containing `s`. -/
theorem generateMeasurable_eq_rec (s : Set (Set α)) :
    { t | GenerateMeasurable s t } =
        ⋃ (i : (Quotient.out (aleph 1).ord).α), generateMeasurableRec s i := by
  ext t; refine' ⟨fun ht => _, fun ht => _⟩
  · inhabit ω₁
    induction' ht with u hu u _ IH f _ IH
    · exact mem_iUnion.2 ⟨default, self_subset_generateMeasurableRec s _ hu⟩
    · exact mem_iUnion.2 ⟨default, empty_mem_generateMeasurableRec s _⟩
    · rcases mem_iUnion.1 IH with ⟨i, hi⟩
      obtain ⟨j, hj⟩ := exists_gt i
      exact mem_iUnion.2 ⟨j, compl_mem_generateMeasurableRec hj hi⟩
    · have : ∀ n, ∃ i, f n ∈ generateMeasurableRec s i := fun n => by simpa using IH n
      

Proof state:
case h.refine'_1.iUnion
α : Type u
s : Set (Set α)
t : Set α
inhabited_h : Inhabited (Quotient.out (ord (aleph 1))).α
f : ℕ → Set α
a✝ : ∀ (n : ℕ), GenerateMeasurable s (f n)
IH : ∀ (n : ℕ), f n ∈ ⋃ i, generateMeasurableRec s i
this : ∀ (n : ℕ), ∃ i, f n ∈ generateMeasurableRec s i
⊢ ⋃ i, f i ∈ ⋃ i, generateMeasurableRec s i

Next tactic:
choose I hI using this
/-- `generateMeasurableRec s` generates precisely the smallest sigma-algebra containing `s`. -/
theorem generateMeasurable_eq_rec (s : Set (Set α)) :
    { t | GenerateMeasurable s t } =
        ⋃ (i : (Quotient.out (aleph 1).ord).α), generateMeasurableRec s i := by
  ext t; refine' ⟨fun ht => _, fun ht => _⟩
  · inhabit ω₁
    induction' ht with u hu u _ IH f _ IH
    · exact mem_iUnion.2 ⟨default, self_subset_generateMeasurableRec s _ hu⟩
    · exact mem_iUnion.2 ⟨default, empty_mem_generateMeasurableRec s _⟩
    · rcases mem_iUnion.1 IH with ⟨i, hi⟩
      obtain ⟨j, hj⟩ := exists_gt i
      exact mem_iUnion.2 ⟨j, compl_mem_generateMeasurableRec hj hi⟩
    · have : ∀ n, ∃ i, f n ∈ generateMeasurableRec s i := fun n => by simpa using IH n
      choose I hI using this
      

Proof state:
case h.refine'_1.iUnion
α : Type u
s : Set (Set α)
t : Set α
inhabited_h : Inhabited (Quotient.out (ord (aleph 1))).α
f : ℕ → Set α
a✝ : ∀ (n : ℕ), GenerateMeasurable s (f n)
IH : ∀ (n : ℕ), f n ∈ ⋃ i, generateMeasurableRec s i
I : ℕ → (Quotient.out (ord (aleph 1))).α
hI : ∀ (n : ℕ), f n ∈ generateMeasurableRec s (I n)
⊢ ⋃ i, f i ∈ ⋃ i, generateMeasurableRec s i

Next tactic:
have : IsWellOrder (ω₁ : Type u) (· < ·) := isWellOrder_out_lt _