measure_theory.measurable_space_def ⟷ Mathlib.MeasureTheory.MeasurableSpace.Defs

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -696,10 +696,10 @@ theorem Measurable.le {α} {m m0 : MeasurableSpace α} {mb : MeasurableSpace β}
 #align measurable.le Measurable.le
 -/
 
-#print MeasurableSpace.Top.measurable /-
-theorem MeasurableSpace.Top.measurable {α β : Type _} [MeasurableSpace β] (f : α → β) :
+#print measurable_discrete /-
+theorem measurable_discrete {α β : Type _} [MeasurableSpace β] (f : α → β) :
     @Measurable α β ⊤ _ f := fun s hs => MeasurableSpace.measurableSet_top
-#align measurable_space.top.measurable MeasurableSpace.Top.measurable
+#align measurable_space.top.measurable measurable_discrete
 -/
 
 end MeasurableFunctions

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

@@ -3,9 +3,9 @@ Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Mario Carneiro
 -/
-import Mathbin.Data.Set.Countable
-import Mathbin.Logic.Encodable.Lattice
-import Mathbin.Order.Disjointed
+import Data.Set.Countable
+import Logic.Encodable.Lattice
+import Order.Disjointed
 
 #align_import measure_theory.measurable_space_def from "leanprover-community/mathlib"@"001ffdc42920050657fd45bd2b8bfbec8eaaeb29"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/001ffdc42920050657fd45bd2b8bfbec8eaaeb29

@@ -7,7 +7,7 @@ import Mathbin.Data.Set.Countable
 import Mathbin.Logic.Encodable.Lattice
 import Mathbin.Order.Disjointed
 
-#align_import measure_theory.measurable_space_def from "leanprover-community/mathlib"@"50832daea47b195a48b5b33b1c8b2162c48c3afc"
+#align_import measure_theory.measurable_space_def from "leanprover-community/mathlib"@"001ffdc42920050657fd45bd2b8bfbec8eaaeb29"
 
 /-!
 # Measurable spaces and measurable functions
@@ -281,7 +281,6 @@ theorem MeasurableSet.disjointed {f : ℕ → Set α} (h : ∀ i, MeasurableSet
 -/
 
 #print MeasurableSet.const /-
-@[simp]
 theorem MeasurableSet.const (p : Prop) : MeasurableSet {a : α | p} := by
   by_cases p <;> simp [h, MeasurableSet.empty] <;> apply MeasurableSet.univ
 #align measurable_set.const MeasurableSet.const
@@ -544,14 +543,12 @@ theorem generateFrom_insert_empty (S : Set (Set α)) : generateFrom (insert ∅
 -/
 
 #print MeasurableSpace.generateFrom_singleton_empty /-
-@[simp]
 theorem generateFrom_singleton_empty : generateFrom {∅} = (⊥ : MeasurableSpace α) := by
   rw [eq_bot_iff, generate_from_le_iff]; simp
 #align measurable_space.generate_from_singleton_empty MeasurableSpace.generateFrom_singleton_empty
 -/
 
 #print MeasurableSpace.generateFrom_singleton_univ /-
-@[simp]
 theorem generateFrom_singleton_univ : generateFrom {Set.univ} = (⊥ : MeasurableSpace α) := by
   rw [eq_bot_iff, generate_from_le_iff]; simp
 #align measurable_space.generate_from_singleton_univ MeasurableSpace.generateFrom_singleton_univ

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

@@ -2,16 +2,13 @@
 Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Mario Carneiro
-
-! This file was ported from Lean 3 source module measure_theory.measurable_space_def
-! leanprover-community/mathlib commit 50832daea47b195a48b5b33b1c8b2162c48c3afc
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Set.Countable
 import Mathbin.Logic.Encodable.Lattice
 import Mathbin.Order.Disjointed
 
+#align_import measure_theory.measurable_space_def from "leanprover-community/mathlib"@"50832daea47b195a48b5b33b1c8b2162c48c3afc"
+
 /-!
 # Measurable spaces and measurable functions
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

@@ -77,7 +77,6 @@ def MeasurableSet [MeasurableSpace α] : Set α → Prop :=
 #align measurable_set MeasurableSet
 -/
 
--- mathport name: measurable_set_of
 scoped[MeasureTheory] notation "measurable_set[" m "]" => @MeasurableSet hole! m
 
 #print MeasurableSet.empty /-
@@ -89,20 +88,24 @@ theorem MeasurableSet.empty [MeasurableSpace α] : MeasurableSet (∅ : Set α)
 
 variable {m : MeasurableSpace α}
 
-include m
-
+#print MeasurableSet.compl /-
 theorem MeasurableSet.compl : MeasurableSet s → MeasurableSet (sᶜ) :=
   ‹MeasurableSpace α›.measurable_set_compl s
 #align measurable_set.compl MeasurableSet.compl
+-/
 
+#print MeasurableSet.of_compl /-
 theorem MeasurableSet.of_compl (h : MeasurableSet (sᶜ)) : MeasurableSet s :=
   compl_compl s ▸ h.compl
 #align measurable_set.of_compl MeasurableSet.of_compl
+-/
 
+#print MeasurableSet.compl_iff /-
 @[simp]
 theorem MeasurableSet.compl_iff : MeasurableSet (sᶜ) ↔ MeasurableSet s :=
   ⟨MeasurableSet.of_compl, MeasurableSet.compl⟩
 #align measurable_set.compl_iff MeasurableSet.compl_iff
+-/
 
 #print MeasurableSet.univ /-
 @[simp]
@@ -140,6 +143,7 @@ theorem MeasurableSet.iUnion [Countable ι] ⦃f : ι → Set α⦄ (h : ∀ b,
 #align measurable_set.Union MeasurableSet.iUnion
 -/
 
+#print MeasurableSet.biUnion /-
 theorem MeasurableSet.biUnion {f : β → Set α} {s : Set β} (hs : s.Countable)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋃ b ∈ s, f b) :=
   by
@@ -147,16 +151,21 @@ theorem MeasurableSet.biUnion {f : β → Set α} {s : Set β} (hs : s.Countable
   haveI := hs.to_encodable
   exact MeasurableSet.iUnion (by simpa using h)
 #align measurable_set.bUnion MeasurableSet.biUnion
+-/
 
+#print Set.Finite.measurableSet_biUnion /-
 theorem Set.Finite.measurableSet_biUnion {f : β → Set α} {s : Set β} (hs : s.Finite)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋃ b ∈ s, f b) :=
   MeasurableSet.biUnion hs.Countable h
 #align set.finite.measurable_set_bUnion Set.Finite.measurableSet_biUnion
+-/
 
+#print Finset.measurableSet_biUnion /-
 theorem Finset.measurableSet_biUnion {f : β → Set α} (s : Finset β)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋃ b ∈ s, f b) :=
   s.finite_toSet.measurableSet_biUnion h
 #align finset.measurable_set_bUnion Finset.measurableSet_biUnion
+-/
 
 #print MeasurableSet.sUnion /-
 theorem MeasurableSet.sUnion {s : Set (Set α)} (hs : s.Countable) (h : ∀ t ∈ s, MeasurableSet t) :
@@ -178,21 +187,27 @@ theorem MeasurableSet.iInter [Countable ι] {f : ι → Set α} (h : ∀ b, Meas
 #align measurable_set.Inter MeasurableSet.iInter
 -/
 
+#print MeasurableSet.biInter /-
 theorem MeasurableSet.biInter {f : β → Set α} {s : Set β} (hs : s.Countable)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋂ b ∈ s, f b) :=
   MeasurableSet.compl_iff.1 <| by rw [compl_Inter₂];
     exact MeasurableSet.biUnion hs fun b hb => (h b hb).compl
 #align measurable_set.bInter MeasurableSet.biInter
+-/
 
+#print Set.Finite.measurableSet_biInter /-
 theorem Set.Finite.measurableSet_biInter {f : β → Set α} {s : Set β} (hs : s.Finite)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋂ b ∈ s, f b) :=
   MeasurableSet.biInter hs.Countable h
 #align set.finite.measurable_set_bInter Set.Finite.measurableSet_biInter
+-/
 
+#print Finset.measurableSet_biInter /-
 theorem Finset.measurableSet_biInter {f : β → Set α} (s : Finset β)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋂ b ∈ s, f b) :=
   s.finite_toSet.measurableSet_biInter h
 #align finset.measurable_set_bInter Finset.measurableSet_biInter
+-/
 
 #print MeasurableSet.sInter /-
 theorem MeasurableSet.sInter {s : Set (Set α)} (hs : s.Countable) (h : ∀ t ∈ s, MeasurableSet t) :
@@ -207,29 +222,37 @@ theorem Set.Finite.measurableSet_sInter {s : Set (Set α)} (hs : s.Finite)
 #align set.finite.measurable_set_sInter Set.Finite.measurableSet_sInter
 -/
 
+#print MeasurableSet.union /-
 @[simp]
 theorem MeasurableSet.union {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (h₂ : MeasurableSet s₂) :
     MeasurableSet (s₁ ∪ s₂) := by rw [union_eq_Union];
   exact MeasurableSet.iUnion (Bool.forall_bool.2 ⟨h₂, h₁⟩)
 #align measurable_set.union MeasurableSet.union
+-/
 
+#print MeasurableSet.inter /-
 @[simp]
 theorem MeasurableSet.inter {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (h₂ : MeasurableSet s₂) :
     MeasurableSet (s₁ ∩ s₂) := by rw [inter_eq_compl_compl_union_compl];
   exact (h₁.compl.union h₂.compl).compl
 #align measurable_set.inter MeasurableSet.inter
+-/
 
+#print MeasurableSet.diff /-
 @[simp]
 theorem MeasurableSet.diff {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (h₂ : MeasurableSet s₂) :
     MeasurableSet (s₁ \ s₂) :=
   h₁.inter h₂.compl
 #align measurable_set.diff MeasurableSet.diff
+-/
 
+#print MeasurableSet.symmDiff /-
 @[simp]
 theorem MeasurableSet.symmDiff {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (h₂ : MeasurableSet s₂) :
     MeasurableSet (s₁ ∆ s₂) :=
   (h₁.diffₓ h₂).union (h₂.diffₓ h₁)
 #align measurable_set.symm_diff MeasurableSet.symmDiff
+-/
 
 #print MeasurableSet.ite /-
 @[simp]
@@ -252,11 +275,13 @@ theorem MeasurableSet.cond {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (h
 #align measurable_set.cond MeasurableSet.cond
 -/
 
+#print MeasurableSet.disjointed /-
 @[simp]
 theorem MeasurableSet.disjointed {f : ℕ → Set α} (h : ∀ i, MeasurableSet (f i)) (n) :
     MeasurableSet (disjointed f n) :=
   disjointedRec (fun t i ht => MeasurableSet.diff ht <| h _) (h n)
 #align measurable_set.disjointed MeasurableSet.disjointed
+-/
 
 #print MeasurableSet.const /-
 @[simp]
@@ -407,6 +432,7 @@ theorem measurableSet_generateFrom {s : Set (Set α)} {t : Set α} (ht : t ∈ s
 #align measurable_space.measurable_set_generate_from MeasurableSpace.measurableSet_generateFrom
 -/
 
+#print MeasurableSpace.generateFrom_induction /-
 @[elab_as_elim]
 theorem generateFrom_induction (p : Set α → Prop) (C : Set (Set α)) (hC : ∀ t ∈ C, p t)
     (h_empty : p ∅) (h_compl : ∀ t, p t → p (tᶜ))
@@ -414,6 +440,7 @@ theorem generateFrom_induction (p : Set α → Prop) (C : Set (Set α)) (hC : 
     (hs : measurable_set[generateFrom C] s) : p s := by induction hs;
   exacts [hC _ hs_H, h_empty, h_compl _ hs_ih, h_Union hs_f hs_ih]
 #align measurable_space.generate_from_induction MeasurableSpace.generateFrom_induction
+-/
 
 #print MeasurableSpace.generateFrom_le /-
 theorem generateFrom_le {s : Set (Set α)} {m : MeasurableSpace α}
@@ -458,6 +485,7 @@ theorem mkOfClosure_sets {s : Set (Set α)} {hs : {t | measurable_set[generateFr
 #align measurable_space.mk_of_closure_sets MeasurableSpace.mkOfClosure_sets
 -/
 
+#print MeasurableSpace.giGenerateFrom /-
 /-- We get a Galois insertion between `σ`-algebras on `α` and `set (set α)` by using `generate_from`
   on one side and the collection of measurable sets on the other side. -/
 def giGenerateFrom : GaloisInsertion (@generateFrom α) fun m => {t | @MeasurableSet α m t}
@@ -467,6 +495,7 @@ def giGenerateFrom : GaloisInsertion (@generateFrom α) fun m => {t | @Measurabl
   choice g hg := MeasurableSpace.mkOfClosure g <| le_antisymm hg <| (generateFrom_le_iff _).1 le_rfl
   choice_eq g hg := mkOfClosure_sets
 #align measurable_space.gi_generate_from MeasurableSpace.giGenerateFrom
+-/
 
 instance : CompleteLattice (MeasurableSpace α) :=
   giGenerateFrom.liftCompleteLattice
@@ -481,10 +510,12 @@ theorem generateFrom_mono {s t : Set (Set α)} (h : s ⊆ t) : generateFrom s 
 #align measurable_space.generate_from_mono MeasurableSpace.generateFrom_mono
 -/
 
+#print MeasurableSpace.generateFrom_sup_generateFrom /-
 theorem generateFrom_sup_generateFrom {s t : Set (Set α)} :
     generateFrom s ⊔ generateFrom t = generateFrom (s ∪ t) :=
   (@giGenerateFrom α).gc.l_sup.symm
 #align measurable_space.generate_from_sup_generate_from MeasurableSpace.generateFrom_sup_generateFrom
+-/
 
 #print MeasurableSpace.generateFrom_insert_univ /-
 @[simp]
@@ -515,16 +546,21 @@ theorem generateFrom_insert_empty (S : Set (Set α)) : generateFrom (insert ∅
 #align measurable_space.generate_from_insert_empty MeasurableSpace.generateFrom_insert_empty
 -/
 
+#print MeasurableSpace.generateFrom_singleton_empty /-
 @[simp]
 theorem generateFrom_singleton_empty : generateFrom {∅} = (⊥ : MeasurableSpace α) := by
   rw [eq_bot_iff, generate_from_le_iff]; simp
 #align measurable_space.generate_from_singleton_empty MeasurableSpace.generateFrom_singleton_empty
+-/
 
+#print MeasurableSpace.generateFrom_singleton_univ /-
 @[simp]
 theorem generateFrom_singleton_univ : generateFrom {Set.univ} = (⊥ : MeasurableSpace α) := by
   rw [eq_bot_iff, generate_from_le_iff]; simp
 #align measurable_space.generate_from_singleton_univ MeasurableSpace.generateFrom_singleton_univ
+-/
 
+#print MeasurableSpace.measurableSet_bot_iff /-
 theorem measurableSet_bot_iff {s : Set α} : @MeasurableSet α ⊥ s ↔ s = ∅ ∨ s = univ :=
   let b : MeasurableSpace α :=
     { MeasurableSet' := fun s => s = ∅ ∨ s = univ
@@ -547,56 +583,75 @@ theorem measurableSet_bot_iff {s : Set α} : @MeasurableSet α ⊥ s ↔ s = ∅
         s.symm ▸ @MeasurableSet.univ _ ⊥
   this ▸ Iff.rfl
 #align measurable_space.measurable_set_bot_iff MeasurableSpace.measurableSet_bot_iff
+-/
 
+#print MeasurableSpace.measurableSet_top /-
 @[simp]
 theorem measurableSet_top {s : Set α} : @MeasurableSet _ ⊤ s :=
   trivial
 #align measurable_space.measurable_set_top MeasurableSpace.measurableSet_top
+-/
 
+#print MeasurableSpace.measurableSet_inf /-
 @[simp]
 theorem measurableSet_inf {m₁ m₂ : MeasurableSpace α} {s : Set α} :
     @MeasurableSet _ (m₁ ⊓ m₂) s ↔ @MeasurableSet _ m₁ s ∧ @MeasurableSet _ m₂ s :=
   Iff.rfl
 #align measurable_space.measurable_set_inf MeasurableSpace.measurableSet_inf
+-/
 
+#print MeasurableSpace.measurableSet_sInf /-
 @[simp]
 theorem measurableSet_sInf {ms : Set (MeasurableSpace α)} {s : Set α} :
     @MeasurableSet _ (sInf ms) s ↔ ∀ m ∈ ms, @MeasurableSet _ m s :=
   show s ∈ ⋂₀ _ ↔ _ by simp
 #align measurable_space.measurable_set_Inf MeasurableSpace.measurableSet_sInf
+-/
 
+#print MeasurableSpace.measurableSet_iInf /-
 @[simp]
 theorem measurableSet_iInf {ι} {m : ι → MeasurableSpace α} {s : Set α} :
     @MeasurableSet _ (iInf m) s ↔ ∀ i, @MeasurableSet _ (m i) s := by
   rw [iInf, measurable_set_Inf, forall_range_iff]
 #align measurable_space.measurable_set_infi MeasurableSpace.measurableSet_iInf
+-/
 
+#print MeasurableSpace.measurableSet_sup /-
 theorem measurableSet_sup {m₁ m₂ : MeasurableSpace α} {s : Set α} :
     measurable_set[m₁ ⊔ m₂] s ↔ GenerateMeasurable (measurable_set[m₁] ∪ measurable_set[m₂]) s :=
   Iff.refl _
 #align measurable_space.measurable_set_sup MeasurableSpace.measurableSet_sup
+-/
 
+#print MeasurableSpace.measurableSet_sSup /-
 theorem measurableSet_sSup {ms : Set (MeasurableSpace α)} {s : Set α} :
     measurable_set[sSup ms] s ↔ GenerateMeasurable {s : Set α | ∃ m ∈ ms, measurable_set[m] s} s :=
   by
   change @measurable_set' _ (generate_from <| ⋃₀ _) _ ↔ _
   simp [generate_from, ← set_of_exists]
 #align measurable_space.measurable_set_Sup MeasurableSpace.measurableSet_sSup
+-/
 
+#print MeasurableSpace.measurableSet_iSup /-
 theorem measurableSet_iSup {ι} {m : ι → MeasurableSpace α} {s : Set α} :
     @MeasurableSet _ (iSup m) s ↔ GenerateMeasurable {s : Set α | ∃ i, measurable_set[m i] s} s :=
   by simp only [iSup, measurable_set_Sup, exists_range_iff]
 #align measurable_space.measurable_set_supr MeasurableSpace.measurableSet_iSup
+-/
 
+#print MeasurableSpace.measurableSpace_iSup_eq /-
 theorem measurableSpace_iSup_eq (m : ι → MeasurableSpace α) :
     (⨆ n, m n) = generateFrom {s | ∃ n, measurable_set[m n] s} := by ext s;
   rw [measurable_set_supr]; rfl
 #align measurable_space.measurable_space_supr_eq MeasurableSpace.measurableSpace_iSup_eq
+-/
 
+#print MeasurableSpace.generateFrom_iUnion_measurableSet /-
 theorem generateFrom_iUnion_measurableSet (m : ι → MeasurableSpace α) :
     generateFrom (⋃ n, {t | measurable_set[m n] t}) = ⨆ n, m n :=
   (@giGenerateFrom α).l_iSup_u m
 #align measurable_space.generate_from_Union_measurable_set MeasurableSpace.generateFrom_iUnion_measurableSet
+-/
 
 end CompleteLattice
 
@@ -614,7 +669,6 @@ def Measurable [MeasurableSpace α] [MeasurableSpace β] (f : α → β) : Prop
 #align measurable Measurable
 -/
 
--- mathport name: measurable_of
 scoped[MeasureTheory] notation "measurable[" m "]" => @Measurable hole! hole! m hole!
 
 #print measurable_id /-
@@ -628,15 +682,19 @@ theorem measurable_id' {ma : MeasurableSpace α} : Measurable fun a : α => a :=
 #align measurable_id' measurable_id'
 -/
 
+#print Measurable.comp /-
 theorem Measurable.comp {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ}
     {g : β → γ} {f : α → β} (hg : Measurable g) (hf : Measurable f) : Measurable (g ∘ f) :=
   fun t ht => hf (hg ht)
 #align measurable.comp Measurable.comp
+-/
 
+#print measurable_const /-
 @[simp]
 theorem measurable_const {ma : MeasurableSpace α} {mb : MeasurableSpace β} {a : α} :
     Measurable fun b : β => a := fun s hs => MeasurableSet.const (a ∈ s)
 #align measurable_const measurable_const
+-/
 
 #print Measurable.le /-
 theorem Measurable.le {α} {m m0 : MeasurableSpace α} {mb : MeasurableSpace β} (hm : m ≤ m0)
@@ -644,9 +702,11 @@ theorem Measurable.le {α} {m m0 : MeasurableSpace α} {mb : MeasurableSpace β}
 #align measurable.le Measurable.le
 -/
 
+#print MeasurableSpace.Top.measurable /-
 theorem MeasurableSpace.Top.measurable {α β : Type _} [MeasurableSpace β] (f : α → β) :
     @Measurable α β ⊤ _ f := fun s hs => MeasurableSpace.measurableSet_top
 #align measurable_space.top.measurable MeasurableSpace.Top.measurable
+-/
 
 end MeasurableFunctions
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

@@ -260,7 +260,7 @@ theorem MeasurableSet.disjointed {f : ℕ → Set α} (h : ∀ i, MeasurableSet
 
 #print MeasurableSet.const /-
 @[simp]
-theorem MeasurableSet.const (p : Prop) : MeasurableSet { a : α | p } := by
+theorem MeasurableSet.const (p : Prop) : MeasurableSet {a : α | p} := by
   by_cases p <;> simp [h, MeasurableSet.empty] <;> apply MeasurableSet.univ
 #align measurable_set.const MeasurableSet.const
 -/
@@ -312,7 +312,7 @@ section MeasurableSingletonClass
 variable [MeasurableSpace α] [MeasurableSingletonClass α]
 
 #print measurableSet_eq /-
-theorem measurableSet_eq {a : α} : MeasurableSet { x | x = a } :=
+theorem measurableSet_eq {a : α} : MeasurableSet {x | x = a} :=
   measurableSet_singleton a
 #align measurable_set_eq measurableSet_eq
 -/
@@ -426,7 +426,7 @@ theorem generateFrom_le {s : Set (Set α)} {m : MeasurableSpace α}
 
 #print MeasurableSpace.generateFrom_le_iff /-
 theorem generateFrom_le_iff {s : Set (Set α)} (m : MeasurableSpace α) :
-    generateFrom s ≤ m ↔ s ⊆ { t | measurable_set[m] t } :=
+    generateFrom s ≤ m ↔ s ⊆ {t | measurable_set[m] t} :=
   Iff.intro (fun h u hu => h _ <| measurableSet_generateFrom hu) fun h => generateFrom_le h
 #align measurable_space.generate_from_le_iff MeasurableSpace.generateFrom_le_iff
 -/
@@ -434,7 +434,7 @@ theorem generateFrom_le_iff {s : Set (Set α)} (m : MeasurableSpace α) :
 #print MeasurableSpace.generateFrom_measurableSet /-
 @[simp]
 theorem generateFrom_measurableSet [MeasurableSpace α] :
-    generateFrom { s : Set α | MeasurableSet s } = ‹_› :=
+    generateFrom {s : Set α | MeasurableSet s} = ‹_› :=
   le_antisymm (generateFrom_le fun _ => id) fun s => measurableSet_generateFrom
 #align measurable_space.generate_from_measurable_set MeasurableSpace.generateFrom_measurableSet
 -/
@@ -442,7 +442,7 @@ theorem generateFrom_measurableSet [MeasurableSpace α] :
 #print MeasurableSpace.mkOfClosure /-
 /-- If `g` is a collection of subsets of `α` such that the `σ`-algebra generated from `g` contains
 the same sets as `g`, then `g` was already a `σ`-algebra. -/
-protected def mkOfClosure (g : Set (Set α)) (hg : { t | measurable_set[generateFrom g] t } = g) :
+protected def mkOfClosure (g : Set (Set α)) (hg : {t | measurable_set[generateFrom g] t} = g) :
     MeasurableSpace α where
   MeasurableSet' s := s ∈ g
   measurable_set_empty := hg ▸ measurable_set_empty _
@@ -452,7 +452,7 @@ protected def mkOfClosure (g : Set (Set α)) (hg : { t | measurable_set[generate
 -/
 
 #print MeasurableSpace.mkOfClosure_sets /-
-theorem mkOfClosure_sets {s : Set (Set α)} {hs : { t | measurable_set[generateFrom s] t } = s} :
+theorem mkOfClosure_sets {s : Set (Set α)} {hs : {t | measurable_set[generateFrom s] t} = s} :
     MeasurableSpace.mkOfClosure s hs = generateFrom s :=
   MeasurableSpace.ext fun t => show t ∈ s ↔ _ by conv_lhs => rw [← hs]; rfl
 #align measurable_space.mk_of_closure_sets MeasurableSpace.mkOfClosure_sets
@@ -460,7 +460,7 @@ theorem mkOfClosure_sets {s : Set (Set α)} {hs : { t | measurable_set[generateF
 
 /-- We get a Galois insertion between `σ`-algebras on `α` and `set (set α)` by using `generate_from`
   on one side and the collection of measurable sets on the other side. -/
-def giGenerateFrom : GaloisInsertion (@generateFrom α) fun m => { t | @MeasurableSet α m t }
+def giGenerateFrom : GaloisInsertion (@generateFrom α) fun m => {t | @MeasurableSet α m t}
     where
   gc s := generateFrom_le_iff
   le_l_u m s := measurableSet_generateFrom
@@ -577,25 +577,24 @@ theorem measurableSet_sup {m₁ m₂ : MeasurableSpace α} {s : Set α} :
 #align measurable_space.measurable_set_sup MeasurableSpace.measurableSet_sup
 
 theorem measurableSet_sSup {ms : Set (MeasurableSpace α)} {s : Set α} :
-    measurable_set[sSup ms] s ↔
-      GenerateMeasurable { s : Set α | ∃ m ∈ ms, measurable_set[m] s } s :=
+    measurable_set[sSup ms] s ↔ GenerateMeasurable {s : Set α | ∃ m ∈ ms, measurable_set[m] s} s :=
   by
   change @measurable_set' _ (generate_from <| ⋃₀ _) _ ↔ _
   simp [generate_from, ← set_of_exists]
 #align measurable_space.measurable_set_Sup MeasurableSpace.measurableSet_sSup
 
 theorem measurableSet_iSup {ι} {m : ι → MeasurableSpace α} {s : Set α} :
-    @MeasurableSet _ (iSup m) s ↔ GenerateMeasurable { s : Set α | ∃ i, measurable_set[m i] s } s :=
+    @MeasurableSet _ (iSup m) s ↔ GenerateMeasurable {s : Set α | ∃ i, measurable_set[m i] s} s :=
   by simp only [iSup, measurable_set_Sup, exists_range_iff]
 #align measurable_space.measurable_set_supr MeasurableSpace.measurableSet_iSup
 
 theorem measurableSpace_iSup_eq (m : ι → MeasurableSpace α) :
-    (⨆ n, m n) = generateFrom { s | ∃ n, measurable_set[m n] s } := by ext s;
+    (⨆ n, m n) = generateFrom {s | ∃ n, measurable_set[m n] s} := by ext s;
   rw [measurable_set_supr]; rfl
 #align measurable_space.measurable_space_supr_eq MeasurableSpace.measurableSpace_iSup_eq
 
 theorem generateFrom_iUnion_measurableSet (m : ι → MeasurableSpace α) :
-    generateFrom (⋃ n, { t | measurable_set[m n] t }) = ⨆ n, m n :=
+    generateFrom (⋃ n, {t | measurable_set[m n] t}) = ⨆ n, m n :=
   (@giGenerateFrom α).l_iSup_u m
 #align measurable_space.generate_from_Union_measurable_set MeasurableSpace.generateFrom_iUnion_measurableSet
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

@@ -241,14 +241,14 @@ theorem MeasurableSet.ite {t s₁ s₂ : Set α} (ht : MeasurableSet t) (h₁ :
 
 #print MeasurableSet.ite' /-
 theorem MeasurableSet.ite' {s t : Set α} {p : Prop} (hs : p → MeasurableSet s)
-    (ht : ¬p → MeasurableSet t) : MeasurableSet (ite p s t) := by split_ifs; exacts[hs h, ht h]
+    (ht : ¬p → MeasurableSet t) : MeasurableSet (ite p s t) := by split_ifs; exacts [hs h, ht h]
 #align measurable_set.ite' MeasurableSet.ite'
 -/
 
 #print MeasurableSet.cond /-
 @[simp]
 theorem MeasurableSet.cond {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (h₂ : MeasurableSet s₂)
-    {i : Bool} : MeasurableSet (cond i s₁ s₂) := by cases i; exacts[h₂, h₁]
+    {i : Bool} : MeasurableSet (cond i s₁ s₂) := by cases i; exacts [h₂, h₁]
 #align measurable_set.cond MeasurableSet.cond
 -/
 
@@ -412,7 +412,7 @@ theorem generateFrom_induction (p : Set α → Prop) (C : Set (Set α)) (hC : 
     (h_empty : p ∅) (h_compl : ∀ t, p t → p (tᶜ))
     (h_Union : ∀ f : ℕ → Set α, (∀ n, p (f n)) → p (⋃ i, f i)) {s : Set α}
     (hs : measurable_set[generateFrom C] s) : p s := by induction hs;
-  exacts[hC _ hs_H, h_empty, h_compl _ hs_ih, h_Union hs_f hs_ih]
+  exacts [hC _ hs_H, h_empty, h_compl _ hs_ih, h_Union hs_f hs_ih]
 #align measurable_space.generate_from_induction MeasurableSpace.generateFrom_induction
 
 #print MeasurableSpace.generateFrom_le /-

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -49,7 +49,7 @@ measurable space, σ-algebra, measurable function
 
 open Set Encodable Function Equiv
 
-open Classical
+open scoped Classical
 
 variable {α β γ δ δ' : Type _} {ι : Sort _} {s t u : Set α}
 
@@ -274,7 +274,7 @@ theorem nonempty_measurable_superset (s : Set α) : Nonempty { t // s ⊆ t ∧
 
 end
 
-open MeasureTheory
+open scoped MeasureTheory
 
 #print MeasurableSpace.ext /-
 @[ext]

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -91,32 +91,14 @@ variable {m : MeasurableSpace α}
 
 include m
 
-/- warning: measurable_set.compl -> MeasurableSet.compl is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {m : MeasurableSpace.{u1} α}, (MeasurableSet.{u1} α m s) -> (MeasurableSet.{u1} α m (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {m : MeasurableSpace.{u1} α}, (MeasurableSet.{u1} α m s) -> (MeasurableSet.{u1} α m (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s))
-Case conversion may be inaccurate. Consider using '#align measurable_set.compl MeasurableSet.complₓ'. -/
 theorem MeasurableSet.compl : MeasurableSet s → MeasurableSet (sᶜ) :=
   ‹MeasurableSpace α›.measurable_set_compl s
 #align measurable_set.compl MeasurableSet.compl
 
-/- warning: measurable_set.of_compl -> MeasurableSet.of_compl is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {m : MeasurableSpace.{u1} α}, (MeasurableSet.{u1} α m (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s)) -> (MeasurableSet.{u1} α m s)
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {m : MeasurableSpace.{u1} α}, (MeasurableSet.{u1} α m (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s)) -> (MeasurableSet.{u1} α m s)
-Case conversion may be inaccurate. Consider using '#align measurable_set.of_compl MeasurableSet.of_complₓ'. -/
 theorem MeasurableSet.of_compl (h : MeasurableSet (sᶜ)) : MeasurableSet s :=
   compl_compl s ▸ h.compl
 #align measurable_set.of_compl MeasurableSet.of_compl
 
-/- warning: measurable_set.compl_iff -> MeasurableSet.compl_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {m : MeasurableSpace.{u1} α}, Iff (MeasurableSet.{u1} α m (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s)) (MeasurableSet.{u1} α m s)
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {m : MeasurableSpace.{u1} α}, Iff (MeasurableSet.{u1} α m (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s)) (MeasurableSet.{u1} α m s)
-Case conversion may be inaccurate. Consider using '#align measurable_set.compl_iff MeasurableSet.compl_iffₓ'. -/
 @[simp]
 theorem MeasurableSet.compl_iff : MeasurableSet (sᶜ) ↔ MeasurableSet s :=
   ⟨MeasurableSet.of_compl, MeasurableSet.compl⟩
@@ -158,12 +140,6 @@ theorem MeasurableSet.iUnion [Countable ι] ⦃f : ι → Set α⦄ (h : ∀ b,
 #align measurable_set.Union MeasurableSet.iUnion
 -/
 
-/- warning: measurable_set.bUnion -> MeasurableSet.biUnion is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {f : β -> (Set.{u1} α)} {s : Set.{u2} β}, (Set.Countable.{u2} β s) -> (forall (b : β), (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) -> (MeasurableSet.{u1} α m (f b))) -> (MeasurableSet.{u1} α m (Set.iUnion.{u1, succ u2} α β (fun (b : β) => Set.iUnion.{u1, 0} α (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) => f b))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {f : β -> (Set.{u2} α)} {s : Set.{u1} β}, (Set.Countable.{u1} β s) -> (forall (b : β), (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) -> (MeasurableSet.{u2} α m (f b))) -> (MeasurableSet.{u2} α m (Set.iUnion.{u2, succ u1} α β (fun (b : β) => Set.iUnion.{u2, 0} α (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) (fun (H : Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) => f b))))
-Case conversion may be inaccurate. Consider using '#align measurable_set.bUnion MeasurableSet.biUnionₓ'. -/
 theorem MeasurableSet.biUnion {f : β → Set α} {s : Set β} (hs : s.Countable)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋃ b ∈ s, f b) :=
   by
@@ -172,23 +148,11 @@ theorem MeasurableSet.biUnion {f : β → Set α} {s : Set β} (hs : s.Countable
   exact MeasurableSet.iUnion (by simpa using h)
 #align measurable_set.bUnion MeasurableSet.biUnion
 
-/- warning: set.finite.measurable_set_bUnion -> Set.Finite.measurableSet_biUnion is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {f : β -> (Set.{u1} α)} {s : Set.{u2} β}, (Set.Finite.{u2} β s) -> (forall (b : β), (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) -> (MeasurableSet.{u1} α m (f b))) -> (MeasurableSet.{u1} α m (Set.iUnion.{u1, succ u2} α β (fun (b : β) => Set.iUnion.{u1, 0} α (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) => f b))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {f : β -> (Set.{u2} α)} {s : Set.{u1} β}, (Set.Finite.{u1} β s) -> (forall (b : β), (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) -> (MeasurableSet.{u2} α m (f b))) -> (MeasurableSet.{u2} α m (Set.iUnion.{u2, succ u1} α β (fun (b : β) => Set.iUnion.{u2, 0} α (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) (fun (H : Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) => f b))))
-Case conversion may be inaccurate. Consider using '#align set.finite.measurable_set_bUnion Set.Finite.measurableSet_biUnionₓ'. -/
 theorem Set.Finite.measurableSet_biUnion {f : β → Set α} {s : Set β} (hs : s.Finite)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋃ b ∈ s, f b) :=
   MeasurableSet.biUnion hs.Countable h
 #align set.finite.measurable_set_bUnion Set.Finite.measurableSet_biUnion
 
-/- warning: finset.measurable_set_bUnion -> Finset.measurableSet_biUnion is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {f : β -> (Set.{u1} α)} (s : Finset.{u2} β), (forall (b : β), (Membership.Mem.{u2, u2} β (Finset.{u2} β) (Finset.hasMem.{u2} β) b s) -> (MeasurableSet.{u1} α m (f b))) -> (MeasurableSet.{u1} α m (Set.iUnion.{u1, succ u2} α β (fun (b : β) => Set.iUnion.{u1, 0} α (Membership.Mem.{u2, u2} β (Finset.{u2} β) (Finset.hasMem.{u2} β) b s) (fun (H : Membership.Mem.{u2, u2} β (Finset.{u2} β) (Finset.hasMem.{u2} β) b s) => f b))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {f : β -> (Set.{u2} α)} (s : Finset.{u1} β), (forall (b : β), (Membership.mem.{u1, u1} β (Finset.{u1} β) (Finset.instMembershipFinset.{u1} β) b s) -> (MeasurableSet.{u2} α m (f b))) -> (MeasurableSet.{u2} α m (Set.iUnion.{u2, succ u1} α β (fun (b : β) => Set.iUnion.{u2, 0} α (Membership.mem.{u1, u1} β (Finset.{u1} β) (Finset.instMembershipFinset.{u1} β) b s) (fun (H : Membership.mem.{u1, u1} β (Finset.{u1} β) (Finset.instMembershipFinset.{u1} β) b s) => f b))))
-Case conversion may be inaccurate. Consider using '#align finset.measurable_set_bUnion Finset.measurableSet_biUnionₓ'. -/
 theorem Finset.measurableSet_biUnion {f : β → Set α} (s : Finset β)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋃ b ∈ s, f b) :=
   s.finite_toSet.measurableSet_biUnion h
@@ -214,35 +178,17 @@ theorem MeasurableSet.iInter [Countable ι] {f : ι → Set α} (h : ∀ b, Meas
 #align measurable_set.Inter MeasurableSet.iInter
 -/
 
-/- warning: measurable_set.bInter -> MeasurableSet.biInter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {f : β -> (Set.{u1} α)} {s : Set.{u2} β}, (Set.Countable.{u2} β s) -> (forall (b : β), (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) -> (MeasurableSet.{u1} α m (f b))) -> (MeasurableSet.{u1} α m (Set.iInter.{u1, succ u2} α β (fun (b : β) => Set.iInter.{u1, 0} α (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) => f b))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {f : β -> (Set.{u2} α)} {s : Set.{u1} β}, (Set.Countable.{u1} β s) -> (forall (b : β), (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) -> (MeasurableSet.{u2} α m (f b))) -> (MeasurableSet.{u2} α m (Set.iInter.{u2, succ u1} α β (fun (b : β) => Set.iInter.{u2, 0} α (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) (fun (H : Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) => f b))))
-Case conversion may be inaccurate. Consider using '#align measurable_set.bInter MeasurableSet.biInterₓ'. -/
 theorem MeasurableSet.biInter {f : β → Set α} {s : Set β} (hs : s.Countable)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋂ b ∈ s, f b) :=
   MeasurableSet.compl_iff.1 <| by rw [compl_Inter₂];
     exact MeasurableSet.biUnion hs fun b hb => (h b hb).compl
 #align measurable_set.bInter MeasurableSet.biInter
 
-/- warning: set.finite.measurable_set_bInter -> Set.Finite.measurableSet_biInter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {f : β -> (Set.{u1} α)} {s : Set.{u2} β}, (Set.Finite.{u2} β s) -> (forall (b : β), (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) -> (MeasurableSet.{u1} α m (f b))) -> (MeasurableSet.{u1} α m (Set.iInter.{u1, succ u2} α β (fun (b : β) => Set.iInter.{u1, 0} α (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) => f b))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {f : β -> (Set.{u2} α)} {s : Set.{u1} β}, (Set.Finite.{u1} β s) -> (forall (b : β), (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) -> (MeasurableSet.{u2} α m (f b))) -> (MeasurableSet.{u2} α m (Set.iInter.{u2, succ u1} α β (fun (b : β) => Set.iInter.{u2, 0} α (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) (fun (H : Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) => f b))))
-Case conversion may be inaccurate. Consider using '#align set.finite.measurable_set_bInter Set.Finite.measurableSet_biInterₓ'. -/
 theorem Set.Finite.measurableSet_biInter {f : β → Set α} {s : Set β} (hs : s.Finite)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋂ b ∈ s, f b) :=
   MeasurableSet.biInter hs.Countable h
 #align set.finite.measurable_set_bInter Set.Finite.measurableSet_biInter
 
-/- warning: finset.measurable_set_bInter -> Finset.measurableSet_biInter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {f : β -> (Set.{u1} α)} (s : Finset.{u2} β), (forall (b : β), (Membership.Mem.{u2, u2} β (Finset.{u2} β) (Finset.hasMem.{u2} β) b s) -> (MeasurableSet.{u1} α m (f b))) -> (MeasurableSet.{u1} α m (Set.iInter.{u1, succ u2} α β (fun (b : β) => Set.iInter.{u1, 0} α (Membership.Mem.{u2, u2} β (Finset.{u2} β) (Finset.hasMem.{u2} β) b s) (fun (H : Membership.Mem.{u2, u2} β (Finset.{u2} β) (Finset.hasMem.{u2} β) b s) => f b))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {f : β -> (Set.{u2} α)} (s : Finset.{u1} β), (forall (b : β), (Membership.mem.{u1, u1} β (Finset.{u1} β) (Finset.instMembershipFinset.{u1} β) b s) -> (MeasurableSet.{u2} α m (f b))) -> (MeasurableSet.{u2} α m (Set.iInter.{u2, succ u1} α β (fun (b : β) => Set.iInter.{u2, 0} α (Membership.mem.{u1, u1} β (Finset.{u1} β) (Finset.instMembershipFinset.{u1} β) b s) (fun (H : Membership.mem.{u1, u1} β (Finset.{u1} β) (Finset.instMembershipFinset.{u1} β) b s) => f b))))
-Case conversion may be inaccurate. Consider using '#align finset.measurable_set_bInter Finset.measurableSet_biInterₓ'. -/
 theorem Finset.measurableSet_biInter {f : β → Set α} (s : Finset β)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋂ b ∈ s, f b) :=
   s.finite_toSet.measurableSet_biInter h
@@ -261,48 +207,24 @@ theorem Set.Finite.measurableSet_sInter {s : Set (Set α)} (hs : s.Finite)
 #align set.finite.measurable_set_sInter Set.Finite.measurableSet_sInter
 -/
 
-/- warning: measurable_set.union -> MeasurableSet.union is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α}, (MeasurableSet.{u1} α m s₁) -> (MeasurableSet.{u1} α m s₂) -> (MeasurableSet.{u1} α m (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s₁ s₂))
-but is expected to have type
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α}, (MeasurableSet.{u1} α m s₁) -> (MeasurableSet.{u1} α m s₂) -> (MeasurableSet.{u1} α m (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s₁ s₂))
-Case conversion may be inaccurate. Consider using '#align measurable_set.union MeasurableSet.unionₓ'. -/
 @[simp]
 theorem MeasurableSet.union {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (h₂ : MeasurableSet s₂) :
     MeasurableSet (s₁ ∪ s₂) := by rw [union_eq_Union];
   exact MeasurableSet.iUnion (Bool.forall_bool.2 ⟨h₂, h₁⟩)
 #align measurable_set.union MeasurableSet.union
 
-/- warning: measurable_set.inter -> MeasurableSet.inter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α}, (MeasurableSet.{u1} α m s₁) -> (MeasurableSet.{u1} α m s₂) -> (MeasurableSet.{u1} α m (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s₁ s₂))
-but is expected to have type
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α}, (MeasurableSet.{u1} α m s₁) -> (MeasurableSet.{u1} α m s₂) -> (MeasurableSet.{u1} α m (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s₁ s₂))
-Case conversion may be inaccurate. Consider using '#align measurable_set.inter MeasurableSet.interₓ'. -/
 @[simp]
 theorem MeasurableSet.inter {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (h₂ : MeasurableSet s₂) :
     MeasurableSet (s₁ ∩ s₂) := by rw [inter_eq_compl_compl_union_compl];
   exact (h₁.compl.union h₂.compl).compl
 #align measurable_set.inter MeasurableSet.inter
 
-/- warning: measurable_set.diff -> MeasurableSet.diff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α}, (MeasurableSet.{u1} α m s₁) -> (MeasurableSet.{u1} α m s₂) -> (MeasurableSet.{u1} α m (SDiff.sdiff.{u1} (Set.{u1} α) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s₁ s₂))
-but is expected to have type
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α}, (MeasurableSet.{u1} α m s₁) -> (MeasurableSet.{u1} α m s₂) -> (MeasurableSet.{u1} α m (SDiff.sdiff.{u1} (Set.{u1} α) (Set.instSDiffSet.{u1} α) s₁ s₂))
-Case conversion may be inaccurate. Consider using '#align measurable_set.diff MeasurableSet.diffₓ'. -/
 @[simp]
 theorem MeasurableSet.diff {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (h₂ : MeasurableSet s₂) :
     MeasurableSet (s₁ \ s₂) :=
   h₁.inter h₂.compl
 #align measurable_set.diff MeasurableSet.diff
 
-/- warning: measurable_set.symm_diff -> MeasurableSet.symmDiff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α}, (MeasurableSet.{u1} α m s₁) -> (MeasurableSet.{u1} α m s₂) -> (MeasurableSet.{u1} α m (symmDiff.{u1} (Set.{u1} α) (SemilatticeSup.toHasSup.{u1} (Set.{u1} α) (Lattice.toSemilatticeSup.{u1} (Set.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Set.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α)))))))) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s₁ s₂))
-but is expected to have type
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α}, (MeasurableSet.{u1} α m s₁) -> (MeasurableSet.{u1} α m s₂) -> (MeasurableSet.{u1} α m (symmDiff.{u1} (Set.{u1} α) (SemilatticeSup.toSup.{u1} (Set.{u1} α) (Lattice.toSemilatticeSup.{u1} (Set.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Set.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))))) (Set.instSDiffSet.{u1} α) s₁ s₂))
-Case conversion may be inaccurate. Consider using '#align measurable_set.symm_diff MeasurableSet.symmDiffₓ'. -/
 @[simp]
 theorem MeasurableSet.symmDiff {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (h₂ : MeasurableSet s₂) :
     MeasurableSet (s₁ ∆ s₂) :=
@@ -330,12 +252,6 @@ theorem MeasurableSet.cond {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (h
 #align measurable_set.cond MeasurableSet.cond
 -/
 
-/- warning: measurable_set.disjointed -> MeasurableSet.disjointed is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {f : Nat -> (Set.{u1} α)}, (forall (i : Nat), MeasurableSet.{u1} α m (f i)) -> (forall (n : Nat), MeasurableSet.{u1} α m (disjointed.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) f n))
-but is expected to have type
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {f : Nat -> (Set.{u1} α)}, (forall (i : Nat), MeasurableSet.{u1} α m (f i)) -> (forall (n : Nat), MeasurableSet.{u1} α m (disjointed.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) f n))
-Case conversion may be inaccurate. Consider using '#align measurable_set.disjointed MeasurableSet.disjointedₓ'. -/
 @[simp]
 theorem MeasurableSet.disjointed {f : ℕ → Set α} (h : ∀ i, MeasurableSet (f i)) (n) :
     MeasurableSet (disjointed f n) :=
@@ -491,12 +407,6 @@ theorem measurableSet_generateFrom {s : Set (Set α)} {t : Set α} (ht : t ∈ s
 #align measurable_space.measurable_set_generate_from MeasurableSpace.measurableSet_generateFrom
 -/
 
-/- warning: measurable_space.generate_from_induction -> MeasurableSpace.generateFrom_induction is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (p : (Set.{u1} α) -> Prop) (C : Set.{u1} (Set.{u1} α)), (forall (t : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) t C) -> (p t)) -> (p (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α))) -> (forall (t : Set.{u1} α), (p t) -> (p (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) t))) -> (forall (f : Nat -> (Set.{u1} α)), (forall (n : Nat), p (f n)) -> (p (Set.iUnion.{u1, 1} α Nat (fun (i : Nat) => f i)))) -> (forall {s : Set.{u1} α}, (MeasurableSet.{u1} α (MeasurableSpace.generateFrom.{u1} α C) s) -> (p s))
-but is expected to have type
-  forall {α : Type.{u1}} (p : (Set.{u1} α) -> Prop) (C : Set.{u1} (Set.{u1} α)), (forall (t : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) t C) -> (p t)) -> (p (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α))) -> (forall (t : Set.{u1} α), (p t) -> (p (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) t))) -> (forall (f : Nat -> (Set.{u1} α)), (forall (n : Nat), p (f n)) -> (p (Set.iUnion.{u1, 1} α Nat (fun (i : Nat) => f i)))) -> (forall {s : Set.{u1} α}, (MeasurableSet.{u1} α (MeasurableSpace.generateFrom.{u1} α C) s) -> (p s))
-Case conversion may be inaccurate. Consider using '#align measurable_space.generate_from_induction MeasurableSpace.generateFrom_inductionₓ'. -/
 @[elab_as_elim]
 theorem generateFrom_induction (p : Set α → Prop) (C : Set (Set α)) (hC : ∀ t ∈ C, p t)
     (h_empty : p ∅) (h_compl : ∀ t, p t → p (tᶜ))
@@ -548,12 +458,6 @@ theorem mkOfClosure_sets {s : Set (Set α)} {hs : { t | measurable_set[generateF
 #align measurable_space.mk_of_closure_sets MeasurableSpace.mkOfClosure_sets
 -/
 
-/- warning: measurable_space.gi_generate_from -> MeasurableSpace.giGenerateFrom is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, GaloisInsertion.{u1, u1} (Set.{u1} (Set.{u1} α)) (MeasurableSpace.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} (Set.{u1} α)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} (Set.{u1} α)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} (Set.{u1} α)) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} (Set.{u1} α)) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} (Set.{u1} α)) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} (Set.{u1} α)) (Set.completeBooleanAlgebra.{u1} (Set.{u1} α)))))))) (PartialOrder.toPreorder.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.partialOrder.{u1} α)) (MeasurableSpace.generateFrom.{u1} α) (fun (m : MeasurableSpace.{u1} α) => setOf.{u1} (Set.{u1} α) (fun (t : Set.{u1} α) => MeasurableSet.{u1} α m t))
-but is expected to have type
-  forall {α : Type.{u1}}, GaloisInsertion.{u1, u1} (Set.{u1} (Set.{u1} α)) (MeasurableSpace.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} (Set.{u1} α)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} (Set.{u1} α)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} (Set.{u1} α)) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} (Set.{u1} α)) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} (Set.{u1} α)) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} (Set.{u1} α)) (Set.instCompleteBooleanAlgebraSet.{u1} (Set.{u1} α)))))))) (PartialOrder.toPreorder.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instPartialOrderMeasurableSpace.{u1} α)) (MeasurableSpace.generateFrom.{u1} α) (fun (m : MeasurableSpace.{u1} α) => setOf.{u1} (Set.{u1} α) (fun (t : Set.{u1} α) => MeasurableSet.{u1} α m t))
-Case conversion may be inaccurate. Consider using '#align measurable_space.gi_generate_from MeasurableSpace.giGenerateFromₓ'. -/
 /-- We get a Galois insertion between `σ`-algebras on `α` and `set (set α)` by using `generate_from`
   on one side and the collection of measurable sets on the other side. -/
 def giGenerateFrom : GaloisInsertion (@generateFrom α) fun m => { t | @MeasurableSet α m t }
@@ -577,12 +481,6 @@ theorem generateFrom_mono {s t : Set (Set α)} (h : s ⊆ t) : generateFrom s 
 #align measurable_space.generate_from_mono MeasurableSpace.generateFrom_mono
 -/
 
-/- warning: measurable_space.generate_from_sup_generate_from -> MeasurableSpace.generateFrom_sup_generateFrom is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} (Set.{u1} α)} {t : Set.{u1} (Set.{u1} α)}, Eq.{succ u1} (MeasurableSpace.{u1} α) (Sup.sup.{u1} (MeasurableSpace.{u1} α) (SemilatticeSup.toHasSup.{u1} (MeasurableSpace.{u1} α) (Lattice.toSemilatticeSup.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))))) (MeasurableSpace.generateFrom.{u1} α s) (MeasurableSpace.generateFrom.{u1} α t)) (MeasurableSpace.generateFrom.{u1} α (Union.union.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasUnion.{u1} (Set.{u1} α)) s t))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} (Set.{u1} α)} {t : Set.{u1} (Set.{u1} α)}, Eq.{succ u1} (MeasurableSpace.{u1} α) (Sup.sup.{u1} (MeasurableSpace.{u1} α) (SemilatticeSup.toSup.{u1} (MeasurableSpace.{u1} α) (Lattice.toSemilatticeSup.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))))) (MeasurableSpace.generateFrom.{u1} α s) (MeasurableSpace.generateFrom.{u1} α t)) (MeasurableSpace.generateFrom.{u1} α (Union.union.{u1} (Set.{u1} (Set.{u1} α)) (Set.instUnionSet.{u1} (Set.{u1} α)) s t))
-Case conversion may be inaccurate. Consider using '#align measurable_space.generate_from_sup_generate_from MeasurableSpace.generateFrom_sup_generateFromₓ'. -/
 theorem generateFrom_sup_generateFrom {s t : Set (Set α)} :
     generateFrom s ⊔ generateFrom t = generateFrom (s ∪ t) :=
   (@giGenerateFrom α).gc.l_sup.symm
@@ -617,34 +515,16 @@ theorem generateFrom_insert_empty (S : Set (Set α)) : generateFrom (insert ∅
 #align measurable_space.generate_from_insert_empty MeasurableSpace.generateFrom_insert_empty
 -/
 
-/- warning: measurable_space.generate_from_singleton_empty -> MeasurableSpace.generateFrom_singleton_empty is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, Eq.{succ u1} (MeasurableSpace.{u1} α) (MeasurableSpace.generateFrom.{u1} α (Singleton.singleton.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasSingleton.{u1} (Set.{u1} α)) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α)))) (Bot.bot.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toHasBot.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}}, Eq.{succ u1} (MeasurableSpace.{u1} α) (MeasurableSpace.generateFrom.{u1} α (Singleton.singleton.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instSingletonSet.{u1} (Set.{u1} α)) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α)))) (Bot.bot.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toBot.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align measurable_space.generate_from_singleton_empty MeasurableSpace.generateFrom_singleton_emptyₓ'. -/
 @[simp]
 theorem generateFrom_singleton_empty : generateFrom {∅} = (⊥ : MeasurableSpace α) := by
   rw [eq_bot_iff, generate_from_le_iff]; simp
 #align measurable_space.generate_from_singleton_empty MeasurableSpace.generateFrom_singleton_empty
 
-/- warning: measurable_space.generate_from_singleton_univ -> MeasurableSpace.generateFrom_singleton_univ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, Eq.{succ u1} (MeasurableSpace.{u1} α) (MeasurableSpace.generateFrom.{u1} α (Singleton.singleton.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasSingleton.{u1} (Set.{u1} α)) (Set.univ.{u1} α))) (Bot.bot.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toHasBot.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}}, Eq.{succ u1} (MeasurableSpace.{u1} α) (MeasurableSpace.generateFrom.{u1} α (Singleton.singleton.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instSingletonSet.{u1} (Set.{u1} α)) (Set.univ.{u1} α))) (Bot.bot.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toBot.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align measurable_space.generate_from_singleton_univ MeasurableSpace.generateFrom_singleton_univₓ'. -/
 @[simp]
 theorem generateFrom_singleton_univ : generateFrom {Set.univ} = (⊥ : MeasurableSpace α) := by
   rw [eq_bot_iff, generate_from_le_iff]; simp
 #align measurable_space.generate_from_singleton_univ MeasurableSpace.generateFrom_singleton_univ
 
-/- warning: measurable_space.measurable_set_bot_iff -> MeasurableSpace.measurableSet_bot_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (Bot.bot.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toHasBot.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) s) (Or (Eq.{succ u1} (Set.{u1} α) s (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α))) (Eq.{succ u1} (Set.{u1} α) s (Set.univ.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (Bot.bot.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toBot.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))) s) (Or (Eq.{succ u1} (Set.{u1} α) s (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α))) (Eq.{succ u1} (Set.{u1} α) s (Set.univ.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_set_bot_iff MeasurableSpace.measurableSet_bot_iffₓ'. -/
 theorem measurableSet_bot_iff {s : Set α} : @MeasurableSet α ⊥ s ↔ s = ∅ ∨ s = univ :=
   let b : MeasurableSpace α :=
     { MeasurableSet' := fun s => s = ∅ ∨ s = univ
@@ -668,70 +548,34 @@ theorem measurableSet_bot_iff {s : Set α} : @MeasurableSet α ⊥ s ↔ s = ∅
   this ▸ Iff.rfl
 #align measurable_space.measurable_set_bot_iff MeasurableSpace.measurableSet_bot_iff
 
-/- warning: measurable_space.measurable_set_top -> MeasurableSpace.measurableSet_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α}, MeasurableSet.{u1} α (Top.top.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toHasTop.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) s
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α}, MeasurableSet.{u1} α (Top.top.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toTop.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))) s
-Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_set_top MeasurableSpace.measurableSet_topₓ'. -/
 @[simp]
 theorem measurableSet_top {s : Set α} : @MeasurableSet _ ⊤ s :=
   trivial
 #align measurable_space.measurable_set_top MeasurableSpace.measurableSet_top
 
-/- warning: measurable_space.measurable_set_inf -> MeasurableSpace.measurableSet_inf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {m₁ : MeasurableSpace.{u1} α} {m₂ : MeasurableSpace.{u1} α} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (Inf.inf.{u1} (MeasurableSpace.{u1} α) (SemilatticeInf.toHasInf.{u1} (MeasurableSpace.{u1} α) (Lattice.toSemilatticeInf.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))))) m₁ m₂) s) (And (MeasurableSet.{u1} α m₁ s) (MeasurableSet.{u1} α m₂ s))
-but is expected to have type
-  forall {α : Type.{u1}} {m₁ : MeasurableSpace.{u1} α} {m₂ : MeasurableSpace.{u1} α} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (Inf.inf.{u1} (MeasurableSpace.{u1} α) (Lattice.toInf.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α)))) m₁ m₂) s) (And (MeasurableSet.{u1} α m₁ s) (MeasurableSet.{u1} α m₂ s))
-Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_set_inf MeasurableSpace.measurableSet_infₓ'. -/
 @[simp]
 theorem measurableSet_inf {m₁ m₂ : MeasurableSpace α} {s : Set α} :
     @MeasurableSet _ (m₁ ⊓ m₂) s ↔ @MeasurableSet _ m₁ s ∧ @MeasurableSet _ m₂ s :=
   Iff.rfl
 #align measurable_space.measurable_set_inf MeasurableSpace.measurableSet_inf
 
-/- warning: measurable_space.measurable_set_Inf -> MeasurableSpace.measurableSet_sInf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ms : Set.{u1} (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (InfSet.sInf.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) ms) s) (forall (m : MeasurableSpace.{u1} α), (Membership.Mem.{u1, u1} (MeasurableSpace.{u1} α) (Set.{u1} (MeasurableSpace.{u1} α)) (Set.hasMem.{u1} (MeasurableSpace.{u1} α)) m ms) -> (MeasurableSet.{u1} α m s))
-but is expected to have type
-  forall {α : Type.{u1}} {ms : Set.{u1} (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (InfSet.sInf.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))) ms) s) (forall (m : MeasurableSpace.{u1} α), (Membership.mem.{u1, u1} (MeasurableSpace.{u1} α) (Set.{u1} (MeasurableSpace.{u1} α)) (Set.instMembershipSet.{u1} (MeasurableSpace.{u1} α)) m ms) -> (MeasurableSet.{u1} α m s))
-Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_set_Inf MeasurableSpace.measurableSet_sInfₓ'. -/
 @[simp]
 theorem measurableSet_sInf {ms : Set (MeasurableSpace α)} {s : Set α} :
     @MeasurableSet _ (sInf ms) s ↔ ∀ m ∈ ms, @MeasurableSet _ m s :=
   show s ∈ ⋂₀ _ ↔ _ by simp
 #align measurable_space.measurable_set_Inf MeasurableSpace.measurableSet_sInf
 
-/- warning: measurable_space.measurable_set_infi -> MeasurableSpace.measurableSet_iInf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {m : ι -> (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (iInf.{u1, u2} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) ι m) s) (forall (i : ι), MeasurableSet.{u1} α (m i) s)
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {m : ι -> (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (iInf.{u1, u2} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))) ι m) s) (forall (i : ι), MeasurableSet.{u1} α (m i) s)
-Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_set_infi MeasurableSpace.measurableSet_iInfₓ'. -/
 @[simp]
 theorem measurableSet_iInf {ι} {m : ι → MeasurableSpace α} {s : Set α} :
     @MeasurableSet _ (iInf m) s ↔ ∀ i, @MeasurableSet _ (m i) s := by
   rw [iInf, measurable_set_Inf, forall_range_iff]
 #align measurable_space.measurable_set_infi MeasurableSpace.measurableSet_iInf
 
-/- warning: measurable_space.measurable_set_sup -> MeasurableSpace.measurableSet_sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {m₁ : MeasurableSpace.{u1} α} {m₂ : MeasurableSpace.{u1} α} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (Sup.sup.{u1} (MeasurableSpace.{u1} α) (SemilatticeSup.toHasSup.{u1} (MeasurableSpace.{u1} α) (Lattice.toSemilatticeSup.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))))) m₁ m₂) s) (MeasurableSpace.GenerateMeasurable.{u1} α (Union.union.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasUnion.{u1} (Set.{u1} α)) (MeasurableSet.{u1} α m₁) (MeasurableSet.{u1} α m₂)) s)
-but is expected to have type
-  forall {α : Type.{u1}} {m₁ : MeasurableSpace.{u1} α} {m₂ : MeasurableSpace.{u1} α} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (Sup.sup.{u1} (MeasurableSpace.{u1} α) (SemilatticeSup.toSup.{u1} (MeasurableSpace.{u1} α) (Lattice.toSemilatticeSup.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))))) m₁ m₂) s) (MeasurableSpace.GenerateMeasurable.{u1} α (Union.union.{u1} (Set.{u1} (Set.{u1} α)) (Set.instUnionSet.{u1} (Set.{u1} α)) (MeasurableSet.{u1} α m₁) (MeasurableSet.{u1} α m₂)) s)
-Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_set_sup MeasurableSpace.measurableSet_supₓ'. -/
 theorem measurableSet_sup {m₁ m₂ : MeasurableSpace α} {s : Set α} :
     measurable_set[m₁ ⊔ m₂] s ↔ GenerateMeasurable (measurable_set[m₁] ∪ measurable_set[m₂]) s :=
   Iff.refl _
 #align measurable_space.measurable_set_sup MeasurableSpace.measurableSet_sup
 
-/- warning: measurable_space.measurable_set_Sup -> MeasurableSpace.measurableSet_sSup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ms : Set.{u1} (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (SupSet.sSup.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) ms) s) (MeasurableSpace.GenerateMeasurable.{u1} α (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{succ u1} (MeasurableSpace.{u1} α) (fun (m : MeasurableSpace.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (MeasurableSpace.{u1} α) (Set.{u1} (MeasurableSpace.{u1} α)) (Set.hasMem.{u1} (MeasurableSpace.{u1} α)) m ms) (fun (H : Membership.Mem.{u1, u1} (MeasurableSpace.{u1} α) (Set.{u1} (MeasurableSpace.{u1} α)) (Set.hasMem.{u1} (MeasurableSpace.{u1} α)) m ms) => MeasurableSet.{u1} α m s)))) s)
-but is expected to have type
-  forall {α : Type.{u1}} {ms : Set.{u1} (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (SupSet.sSup.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))) ms) s) (MeasurableSpace.GenerateMeasurable.{u1} α (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{succ u1} (MeasurableSpace.{u1} α) (fun (m : MeasurableSpace.{u1} α) => And (Membership.mem.{u1, u1} (MeasurableSpace.{u1} α) (Set.{u1} (MeasurableSpace.{u1} α)) (Set.instMembershipSet.{u1} (MeasurableSpace.{u1} α)) m ms) (MeasurableSet.{u1} α m s)))) s)
-Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_set_Sup MeasurableSpace.measurableSet_sSupₓ'. -/
 theorem measurableSet_sSup {ms : Set (MeasurableSpace α)} {s : Set α} :
     measurable_set[sSup ms] s ↔
       GenerateMeasurable { s : Set α | ∃ m ∈ ms, measurable_set[m] s } s :=
@@ -740,34 +584,16 @@ theorem measurableSet_sSup {ms : Set (MeasurableSpace α)} {s : Set α} :
   simp [generate_from, ← set_of_exists]
 #align measurable_space.measurable_set_Sup MeasurableSpace.measurableSet_sSup
 
-/- warning: measurable_space.measurable_set_supr -> MeasurableSpace.measurableSet_iSup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {m : ι -> (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (iSup.{u1, u2} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) ι m) s) (MeasurableSpace.GenerateMeasurable.{u1} α (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{u2} ι (fun (i : ι) => MeasurableSet.{u1} α (m i) s))) s)
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {m : ι -> (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (iSup.{u1, u2} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))) ι m) s) (MeasurableSpace.GenerateMeasurable.{u1} α (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{u2} ι (fun (i : ι) => MeasurableSet.{u1} α (m i) s))) s)
-Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_set_supr MeasurableSpace.measurableSet_iSupₓ'. -/
 theorem measurableSet_iSup {ι} {m : ι → MeasurableSpace α} {s : Set α} :
     @MeasurableSet _ (iSup m) s ↔ GenerateMeasurable { s : Set α | ∃ i, measurable_set[m i] s } s :=
   by simp only [iSup, measurable_set_Sup, exists_range_iff]
 #align measurable_space.measurable_set_supr MeasurableSpace.measurableSet_iSup
 
-/- warning: measurable_space.measurable_space_supr_eq -> MeasurableSpace.measurableSpace_iSup_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} (m : ι -> (MeasurableSpace.{u1} α)), Eq.{succ u1} (MeasurableSpace.{u1} α) (iSup.{u1, u2} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) ι (fun (n : ι) => m n)) (MeasurableSpace.generateFrom.{u1} α (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{u2} ι (fun (n : ι) => MeasurableSet.{u1} α (m n) s))))
-but is expected to have type
-  forall {α : Type.{u2}} {ι : Sort.{u1}} (m : ι -> (MeasurableSpace.{u2} α)), Eq.{succ u2} (MeasurableSpace.{u2} α) (iSup.{u2, u1} (MeasurableSpace.{u2} α) (ConditionallyCompleteLattice.toSupSet.{u2} (MeasurableSpace.{u2} α) (CompleteLattice.toConditionallyCompleteLattice.{u2} (MeasurableSpace.{u2} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u2} α))) ι (fun (n : ι) => m n)) (MeasurableSpace.generateFrom.{u2} α (setOf.{u2} (Set.{u2} α) (fun (s : Set.{u2} α) => Exists.{u1} ι (fun (n : ι) => MeasurableSet.{u2} α (m n) s))))
-Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_space_supr_eq MeasurableSpace.measurableSpace_iSup_eqₓ'. -/
 theorem measurableSpace_iSup_eq (m : ι → MeasurableSpace α) :
     (⨆ n, m n) = generateFrom { s | ∃ n, measurable_set[m n] s } := by ext s;
   rw [measurable_set_supr]; rfl
 #align measurable_space.measurable_space_supr_eq MeasurableSpace.measurableSpace_iSup_eq
 
-/- warning: measurable_space.generate_from_Union_measurable_set -> MeasurableSpace.generateFrom_iUnion_measurableSet is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} (m : ι -> (MeasurableSpace.{u1} α)), Eq.{succ u1} (MeasurableSpace.{u1} α) (MeasurableSpace.generateFrom.{u1} α (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (n : ι) => setOf.{u1} (Set.{u1} α) (fun (t : Set.{u1} α) => MeasurableSet.{u1} α (m n) t)))) (iSup.{u1, u2} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) ι (fun (n : ι) => m n))
-but is expected to have type
-  forall {α : Type.{u2}} {ι : Sort.{u1}} (m : ι -> (MeasurableSpace.{u2} α)), Eq.{succ u2} (MeasurableSpace.{u2} α) (MeasurableSpace.generateFrom.{u2} α (Set.iUnion.{u2, u1} (Set.{u2} α) ι (fun (n : ι) => setOf.{u2} (Set.{u2} α) (fun (t : Set.{u2} α) => MeasurableSet.{u2} α (m n) t)))) (iSup.{u2, u1} (MeasurableSpace.{u2} α) (ConditionallyCompleteLattice.toSupSet.{u2} (MeasurableSpace.{u2} α) (CompleteLattice.toConditionallyCompleteLattice.{u2} (MeasurableSpace.{u2} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u2} α))) ι (fun (n : ι) => m n))
-Case conversion may be inaccurate. Consider using '#align measurable_space.generate_from_Union_measurable_set MeasurableSpace.generateFrom_iUnion_measurableSetₓ'. -/
 theorem generateFrom_iUnion_measurableSet (m : ι → MeasurableSpace α) :
     generateFrom (⋃ n, { t | measurable_set[m n] t }) = ⨆ n, m n :=
   (@giGenerateFrom α).l_iSup_u m
@@ -803,23 +629,11 @@ theorem measurable_id' {ma : MeasurableSpace α} : Measurable fun a : α => a :=
 #align measurable_id' measurable_id'
 -/
 
-/- warning: measurable.comp -> Measurable.comp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {mα : MeasurableSpace.{u1} α} {mβ : MeasurableSpace.{u2} β} {mγ : MeasurableSpace.{u3} γ} {g : β -> γ} {f : α -> β}, (Measurable.{u2, u3} β γ mβ mγ g) -> (Measurable.{u1, u2} α β mα mβ f) -> (Measurable.{u1, u3} α γ mα mγ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} {mα : MeasurableSpace.{u3} α} {mβ : MeasurableSpace.{u2} β} {mγ : MeasurableSpace.{u1} γ} {g : β -> γ} {f : α -> β}, (Measurable.{u2, u1} β γ mβ mγ g) -> (Measurable.{u3, u2} α β mα mβ f) -> (Measurable.{u3, u1} α γ mα mγ (Function.comp.{succ u3, succ u2, succ u1} α β γ g f))
-Case conversion may be inaccurate. Consider using '#align measurable.comp Measurable.compₓ'. -/
 theorem Measurable.comp {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ}
     {g : β → γ} {f : α → β} (hg : Measurable g) (hf : Measurable f) : Measurable (g ∘ f) :=
   fun t ht => hf (hg ht)
 #align measurable.comp Measurable.comp
 
-/- warning: measurable_const -> measurable_const is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ma : MeasurableSpace.{u1} α} {mb : MeasurableSpace.{u2} β} {a : α}, Measurable.{u2, u1} β α mb ma (fun (b : β) => a)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {ma : MeasurableSpace.{u2} α} {mb : MeasurableSpace.{u1} β} {a : α}, Measurable.{u1, u2} β α mb ma (fun (b : β) => a)
-Case conversion may be inaccurate. Consider using '#align measurable_const measurable_constₓ'. -/
 @[simp]
 theorem measurable_const {ma : MeasurableSpace α} {mb : MeasurableSpace β} {a : α} :
     Measurable fun b : β => a := fun s hs => MeasurableSet.const (a ∈ s)
@@ -831,12 +645,6 @@ theorem Measurable.le {α} {m m0 : MeasurableSpace α} {mb : MeasurableSpace β}
 #align measurable.le Measurable.le
 -/
 
-/- warning: measurable_space.top.measurable -> MeasurableSpace.Top.measurable is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : MeasurableSpace.{u2} β] (f : α -> β), Measurable.{u1, u2} α β (Top.top.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toHasTop.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) _inst_1 f
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : MeasurableSpace.{u1} β] (f : α -> β), Measurable.{u2, u1} α β (Top.top.{u2} (MeasurableSpace.{u2} α) (CompleteLattice.toTop.{u2} (MeasurableSpace.{u2} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u2} α))) _inst_1 f
-Case conversion may be inaccurate. Consider using '#align measurable_space.top.measurable MeasurableSpace.Top.measurableₓ'. -/
 theorem MeasurableSpace.Top.measurable {α β : Type _} [MeasurableSpace β] (f : α → β) :
     @Measurable α β ⊤ _ f := fun s hs => MeasurableSpace.measurableSet_top
 #align measurable_space.top.measurable MeasurableSpace.Top.measurable

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -196,9 +196,7 @@ theorem Finset.measurableSet_biUnion {f : β → Set α} (s : Finset β)
 
 #print MeasurableSet.sUnion /-
 theorem MeasurableSet.sUnion {s : Set (Set α)} (hs : s.Countable) (h : ∀ t ∈ s, MeasurableSet t) :
-    MeasurableSet (⋃₀ s) := by
-  rw [sUnion_eq_bUnion]
-  exact MeasurableSet.biUnion hs h
+    MeasurableSet (⋃₀ s) := by rw [sUnion_eq_bUnion]; exact MeasurableSet.biUnion hs h
 #align measurable_set.sUnion MeasurableSet.sUnion
 -/
 
@@ -212,9 +210,7 @@ theorem Set.Finite.measurableSet_sUnion {s : Set (Set α)} (hs : s.Finite)
 #print MeasurableSet.iInter /-
 theorem MeasurableSet.iInter [Countable ι] {f : ι → Set α} (h : ∀ b, MeasurableSet (f b)) :
     MeasurableSet (⋂ b, f b) :=
-  MeasurableSet.compl_iff.1 <| by
-    rw [compl_Inter]
-    exact MeasurableSet.iUnion fun b => (h b).compl
+  MeasurableSet.compl_iff.1 <| by rw [compl_Inter]; exact MeasurableSet.iUnion fun b => (h b).compl
 #align measurable_set.Inter MeasurableSet.iInter
 -/
 
@@ -226,8 +222,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align measurable_set.bInter MeasurableSet.biInterₓ'. -/
 theorem MeasurableSet.biInter {f : β → Set α} {s : Set β} (hs : s.Countable)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋂ b ∈ s, f b) :=
-  MeasurableSet.compl_iff.1 <| by
-    rw [compl_Inter₂]
+  MeasurableSet.compl_iff.1 <| by rw [compl_Inter₂];
     exact MeasurableSet.biUnion hs fun b hb => (h b hb).compl
 #align measurable_set.bInter MeasurableSet.biInter
 
@@ -255,9 +250,7 @@ theorem Finset.measurableSet_biInter {f : β → Set α} (s : Finset β)
 
 #print MeasurableSet.sInter /-
 theorem MeasurableSet.sInter {s : Set (Set α)} (hs : s.Countable) (h : ∀ t ∈ s, MeasurableSet t) :
-    MeasurableSet (⋂₀ s) := by
-  rw [sInter_eq_bInter]
-  exact MeasurableSet.biInter hs h
+    MeasurableSet (⋂₀ s) := by rw [sInter_eq_bInter]; exact MeasurableSet.biInter hs h
 #align measurable_set.sInter MeasurableSet.sInter
 -/
 
@@ -276,8 +269,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align measurable_set.union MeasurableSet.unionₓ'. -/
 @[simp]
 theorem MeasurableSet.union {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (h₂ : MeasurableSet s₂) :
-    MeasurableSet (s₁ ∪ s₂) := by
-  rw [union_eq_Union]
+    MeasurableSet (s₁ ∪ s₂) := by rw [union_eq_Union];
   exact MeasurableSet.iUnion (Bool.forall_bool.2 ⟨h₂, h₁⟩)
 #align measurable_set.union MeasurableSet.union
 
@@ -289,8 +281,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align measurable_set.inter MeasurableSet.interₓ'. -/
 @[simp]
 theorem MeasurableSet.inter {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (h₂ : MeasurableSet s₂) :
-    MeasurableSet (s₁ ∩ s₂) := by
-  rw [inter_eq_compl_compl_union_compl]
+    MeasurableSet (s₁ ∩ s₂) := by rw [inter_eq_compl_compl_union_compl];
   exact (h₁.compl.union h₂.compl).compl
 #align measurable_set.inter MeasurableSet.inter
 
@@ -328,20 +319,14 @@ theorem MeasurableSet.ite {t s₁ s₂ : Set α} (ht : MeasurableSet t) (h₁ :
 
 #print MeasurableSet.ite' /-
 theorem MeasurableSet.ite' {s t : Set α} {p : Prop} (hs : p → MeasurableSet s)
-    (ht : ¬p → MeasurableSet t) : MeasurableSet (ite p s t) :=
-  by
-  split_ifs
-  exacts[hs h, ht h]
+    (ht : ¬p → MeasurableSet t) : MeasurableSet (ite p s t) := by split_ifs; exacts[hs h, ht h]
 #align measurable_set.ite' MeasurableSet.ite'
 -/
 
 #print MeasurableSet.cond /-
 @[simp]
 theorem MeasurableSet.cond {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (h₂ : MeasurableSet s₂)
-    {i : Bool} : MeasurableSet (cond i s₁ s₂) :=
-  by
-  cases i
-  exacts[h₂, h₁]
+    {i : Bool} : MeasurableSet (cond i s₁ s₂) := by cases i; exacts[h₂, h₁]
 #align measurable_set.cond MeasurableSet.cond
 -/
 
@@ -391,10 +376,7 @@ theorem MeasurableSpace.ext :
 @[ext]
 theorem MeasurableSpace.ext_iff {m₁ m₂ : MeasurableSpace α} :
     m₁ = m₂ ↔ ∀ s : Set α, measurable_set[m₁] s ↔ measurable_set[m₂] s :=
-  ⟨by
-    rintro rfl
-    intro s
-    rfl, MeasurableSpace.ext⟩
+  ⟨by rintro rfl; intro s; rfl, MeasurableSpace.ext⟩
 #align measurable_space.ext_iff MeasurableSpace.ext_iff
 -/
 
@@ -519,9 +501,7 @@ Case conversion may be inaccurate. Consider using '#align measurable_space.gener
 theorem generateFrom_induction (p : Set α → Prop) (C : Set (Set α)) (hC : ∀ t ∈ C, p t)
     (h_empty : p ∅) (h_compl : ∀ t, p t → p (tᶜ))
     (h_Union : ∀ f : ℕ → Set α, (∀ n, p (f n)) → p (⋃ i, f i)) {s : Set α}
-    (hs : measurable_set[generateFrom C] s) : p s :=
-  by
-  induction hs
+    (hs : measurable_set[generateFrom C] s) : p s := by induction hs;
   exacts[hC _ hs_H, h_empty, h_compl _ hs_ih, h_Union hs_f hs_ih]
 #align measurable_space.generate_from_induction MeasurableSpace.generateFrom_induction
 
@@ -564,10 +544,7 @@ protected def mkOfClosure (g : Set (Set α)) (hg : { t | measurable_set[generate
 #print MeasurableSpace.mkOfClosure_sets /-
 theorem mkOfClosure_sets {s : Set (Set α)} {hs : { t | measurable_set[generateFrom s] t } = s} :
     MeasurableSpace.mkOfClosure s hs = generateFrom s :=
-  MeasurableSpace.ext fun t =>
-    show t ∈ s ↔ _ by
-      conv_lhs => rw [← hs]
-      rfl
+  MeasurableSpace.ext fun t => show t ∈ s ↔ _ by conv_lhs => rw [← hs]; rfl
 #align measurable_space.mk_of_closure_sets MeasurableSpace.mkOfClosure_sets
 -/
 
@@ -647,10 +624,8 @@ but is expected to have type
   forall {α : Type.{u1}}, Eq.{succ u1} (MeasurableSpace.{u1} α) (MeasurableSpace.generateFrom.{u1} α (Singleton.singleton.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instSingletonSet.{u1} (Set.{u1} α)) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α)))) (Bot.bot.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toBot.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α)))
 Case conversion may be inaccurate. Consider using '#align measurable_space.generate_from_singleton_empty MeasurableSpace.generateFrom_singleton_emptyₓ'. -/
 @[simp]
-theorem generateFrom_singleton_empty : generateFrom {∅} = (⊥ : MeasurableSpace α) :=
-  by
-  rw [eq_bot_iff, generate_from_le_iff]
-  simp
+theorem generateFrom_singleton_empty : generateFrom {∅} = (⊥ : MeasurableSpace α) := by
+  rw [eq_bot_iff, generate_from_le_iff]; simp
 #align measurable_space.generate_from_singleton_empty MeasurableSpace.generateFrom_singleton_empty
 
 /- warning: measurable_space.generate_from_singleton_univ -> MeasurableSpace.generateFrom_singleton_univ is a dubious translation:
@@ -660,10 +635,8 @@ but is expected to have type
   forall {α : Type.{u1}}, Eq.{succ u1} (MeasurableSpace.{u1} α) (MeasurableSpace.generateFrom.{u1} α (Singleton.singleton.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instSingletonSet.{u1} (Set.{u1} α)) (Set.univ.{u1} α))) (Bot.bot.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toBot.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α)))
 Case conversion may be inaccurate. Consider using '#align measurable_space.generate_from_singleton_univ MeasurableSpace.generateFrom_singleton_univₓ'. -/
 @[simp]
-theorem generateFrom_singleton_univ : generateFrom {Set.univ} = (⊥ : MeasurableSpace α) :=
-  by
-  rw [eq_bot_iff, generate_from_le_iff]
-  simp
+theorem generateFrom_singleton_univ : generateFrom {Set.univ} = (⊥ : MeasurableSpace α) := by
+  rw [eq_bot_iff, generate_from_le_iff]; simp
 #align measurable_space.generate_from_singleton_univ MeasurableSpace.generateFrom_singleton_univ
 
 /- warning: measurable_space.measurable_set_bot_iff -> MeasurableSpace.measurableSet_bot_iff is a dubious translation:
@@ -785,11 +758,8 @@ but is expected to have type
   forall {α : Type.{u2}} {ι : Sort.{u1}} (m : ι -> (MeasurableSpace.{u2} α)), Eq.{succ u2} (MeasurableSpace.{u2} α) (iSup.{u2, u1} (MeasurableSpace.{u2} α) (ConditionallyCompleteLattice.toSupSet.{u2} (MeasurableSpace.{u2} α) (CompleteLattice.toConditionallyCompleteLattice.{u2} (MeasurableSpace.{u2} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u2} α))) ι (fun (n : ι) => m n)) (MeasurableSpace.generateFrom.{u2} α (setOf.{u2} (Set.{u2} α) (fun (s : Set.{u2} α) => Exists.{u1} ι (fun (n : ι) => MeasurableSet.{u2} α (m n) s))))
 Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_space_supr_eq MeasurableSpace.measurableSpace_iSup_eqₓ'. -/
 theorem measurableSpace_iSup_eq (m : ι → MeasurableSpace α) :
-    (⨆ n, m n) = generateFrom { s | ∃ n, measurable_set[m n] s } :=
-  by
-  ext s
-  rw [measurable_set_supr]
-  rfl
+    (⨆ n, m n) = generateFrom { s | ∃ n, measurable_set[m n] s } := by ext s;
+  rw [measurable_set_supr]; rfl
 #align measurable_space.measurable_space_supr_eq MeasurableSpace.measurableSpace_iSup_eq
 
 /- warning: measurable_space.generate_from_Union_measurable_set -> MeasurableSpace.generateFrom_iUnion_measurableSet is a dubious translation:

mathlib commit https://github.com/leanprover-community/mathlib/commit/e3fb84046afd187b710170887195d50bada934ee

@@ -59,7 +59,7 @@ structure MeasurableSpace (α : Type _) where
   MeasurableSet' : Set α → Prop
   measurable_set_empty : measurable_set' ∅
   measurable_set_compl : ∀ s, measurable_set' s → measurable_set' (sᶜ)
-  measurable_set_unionᵢ : ∀ f : ℕ → Set α, (∀ i, measurable_set' (f i)) → measurable_set' (⋃ i, f i)
+  measurable_set_iUnion : ∀ f : ℕ → Set α, (∀ i, measurable_set' (f i)) → measurable_set' (⋃ i, f i)
 #align measurable_space MeasurableSpace
 -/
 
@@ -142,130 +142,130 @@ theorem MeasurableSet.congr {s t : Set α} (hs : MeasurableSet s) (h : s = t) :
 #align measurable_set.congr MeasurableSet.congr
 -/
 
-#print MeasurableSet.bunionᵢ_decode₂ /-
-theorem MeasurableSet.bunionᵢ_decode₂ [Encodable β] ⦃f : β → Set α⦄ (h : ∀ b, MeasurableSet (f b))
+#print MeasurableSet.biUnion_decode₂ /-
+theorem MeasurableSet.biUnion_decode₂ [Encodable β] ⦃f : β → Set α⦄ (h : ∀ b, MeasurableSet (f b))
     (n : ℕ) : MeasurableSet (⋃ b ∈ decode₂ β n, f b) :=
-  Encodable.unionᵢ_decode₂_cases MeasurableSet.empty h
-#align measurable_set.bUnion_decode₂ MeasurableSet.bunionᵢ_decode₂
+  Encodable.iUnion_decode₂_cases MeasurableSet.empty h
+#align measurable_set.bUnion_decode₂ MeasurableSet.biUnion_decode₂
 -/
 
-#print MeasurableSet.unionᵢ /-
-theorem MeasurableSet.unionᵢ [Countable ι] ⦃f : ι → Set α⦄ (h : ∀ b, MeasurableSet (f b)) :
+#print MeasurableSet.iUnion /-
+theorem MeasurableSet.iUnion [Countable ι] ⦃f : ι → Set α⦄ (h : ∀ b, MeasurableSet (f b)) :
     MeasurableSet (⋃ b, f b) := by
   cases nonempty_encodable (PLift ι)
-  rw [← Union_plift_down, ← Encodable.unionᵢ_decode₂]
-  exact ‹MeasurableSpace α›.measurable_set_unionᵢ _ (MeasurableSet.bunionᵢ_decode₂ fun _ => h _)
-#align measurable_set.Union MeasurableSet.unionᵢ
+  rw [← Union_plift_down, ← Encodable.iUnion_decode₂]
+  exact ‹MeasurableSpace α›.measurable_set_iUnion _ (MeasurableSet.biUnion_decode₂ fun _ => h _)
+#align measurable_set.Union MeasurableSet.iUnion
 -/
 
-/- warning: measurable_set.bUnion -> MeasurableSet.bunionᵢ is a dubious translation:
+/- warning: measurable_set.bUnion -> MeasurableSet.biUnion is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {f : β -> (Set.{u1} α)} {s : Set.{u2} β}, (Set.Countable.{u2} β s) -> (forall (b : β), (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) -> (MeasurableSet.{u1} α m (f b))) -> (MeasurableSet.{u1} α m (Set.unionᵢ.{u1, succ u2} α β (fun (b : β) => Set.unionᵢ.{u1, 0} α (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) => f b))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {f : β -> (Set.{u1} α)} {s : Set.{u2} β}, (Set.Countable.{u2} β s) -> (forall (b : β), (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) -> (MeasurableSet.{u1} α m (f b))) -> (MeasurableSet.{u1} α m (Set.iUnion.{u1, succ u2} α β (fun (b : β) => Set.iUnion.{u1, 0} α (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) => f b))))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {f : β -> (Set.{u2} α)} {s : Set.{u1} β}, (Set.Countable.{u1} β s) -> (forall (b : β), (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) -> (MeasurableSet.{u2} α m (f b))) -> (MeasurableSet.{u2} α m (Set.unionᵢ.{u2, succ u1} α β (fun (b : β) => Set.unionᵢ.{u2, 0} α (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) (fun (H : Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) => f b))))
-Case conversion may be inaccurate. Consider using '#align measurable_set.bUnion MeasurableSet.bunionᵢₓ'. -/
-theorem MeasurableSet.bunionᵢ {f : β → Set α} {s : Set β} (hs : s.Countable)
+  forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {f : β -> (Set.{u2} α)} {s : Set.{u1} β}, (Set.Countable.{u1} β s) -> (forall (b : β), (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) -> (MeasurableSet.{u2} α m (f b))) -> (MeasurableSet.{u2} α m (Set.iUnion.{u2, succ u1} α β (fun (b : β) => Set.iUnion.{u2, 0} α (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) (fun (H : Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) => f b))))
+Case conversion may be inaccurate. Consider using '#align measurable_set.bUnion MeasurableSet.biUnionₓ'. -/
+theorem MeasurableSet.biUnion {f : β → Set α} {s : Set β} (hs : s.Countable)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋃ b ∈ s, f b) :=
   by
   rw [bUnion_eq_Union]
   haveI := hs.to_encodable
-  exact MeasurableSet.unionᵢ (by simpa using h)
-#align measurable_set.bUnion MeasurableSet.bunionᵢ
+  exact MeasurableSet.iUnion (by simpa using h)
+#align measurable_set.bUnion MeasurableSet.biUnion
 
-/- warning: set.finite.measurable_set_bUnion -> Set.Finite.measurableSet_bunionᵢ is a dubious translation:
+/- warning: set.finite.measurable_set_bUnion -> Set.Finite.measurableSet_biUnion is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {f : β -> (Set.{u1} α)} {s : Set.{u2} β}, (Set.Finite.{u2} β s) -> (forall (b : β), (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) -> (MeasurableSet.{u1} α m (f b))) -> (MeasurableSet.{u1} α m (Set.unionᵢ.{u1, succ u2} α β (fun (b : β) => Set.unionᵢ.{u1, 0} α (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) => f b))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {f : β -> (Set.{u1} α)} {s : Set.{u2} β}, (Set.Finite.{u2} β s) -> (forall (b : β), (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) -> (MeasurableSet.{u1} α m (f b))) -> (MeasurableSet.{u1} α m (Set.iUnion.{u1, succ u2} α β (fun (b : β) => Set.iUnion.{u1, 0} α (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) => f b))))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {f : β -> (Set.{u2} α)} {s : Set.{u1} β}, (Set.Finite.{u1} β s) -> (forall (b : β), (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) -> (MeasurableSet.{u2} α m (f b))) -> (MeasurableSet.{u2} α m (Set.unionᵢ.{u2, succ u1} α β (fun (b : β) => Set.unionᵢ.{u2, 0} α (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) (fun (H : Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) => f b))))
-Case conversion may be inaccurate. Consider using '#align set.finite.measurable_set_bUnion Set.Finite.measurableSet_bunionᵢₓ'. -/
-theorem Set.Finite.measurableSet_bunionᵢ {f : β → Set α} {s : Set β} (hs : s.Finite)
+  forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {f : β -> (Set.{u2} α)} {s : Set.{u1} β}, (Set.Finite.{u1} β s) -> (forall (b : β), (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) -> (MeasurableSet.{u2} α m (f b))) -> (MeasurableSet.{u2} α m (Set.iUnion.{u2, succ u1} α β (fun (b : β) => Set.iUnion.{u2, 0} α (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) (fun (H : Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) => f b))))
+Case conversion may be inaccurate. Consider using '#align set.finite.measurable_set_bUnion Set.Finite.measurableSet_biUnionₓ'. -/
+theorem Set.Finite.measurableSet_biUnion {f : β → Set α} {s : Set β} (hs : s.Finite)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋃ b ∈ s, f b) :=
-  MeasurableSet.bunionᵢ hs.Countable h
-#align set.finite.measurable_set_bUnion Set.Finite.measurableSet_bunionᵢ
+  MeasurableSet.biUnion hs.Countable h
+#align set.finite.measurable_set_bUnion Set.Finite.measurableSet_biUnion
 
-/- warning: finset.measurable_set_bUnion -> Finset.measurableSet_bunionᵢ is a dubious translation:
+/- warning: finset.measurable_set_bUnion -> Finset.measurableSet_biUnion is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {f : β -> (Set.{u1} α)} (s : Finset.{u2} β), (forall (b : β), (Membership.Mem.{u2, u2} β (Finset.{u2} β) (Finset.hasMem.{u2} β) b s) -> (MeasurableSet.{u1} α m (f b))) -> (MeasurableSet.{u1} α m (Set.unionᵢ.{u1, succ u2} α β (fun (b : β) => Set.unionᵢ.{u1, 0} α (Membership.Mem.{u2, u2} β (Finset.{u2} β) (Finset.hasMem.{u2} β) b s) (fun (H : Membership.Mem.{u2, u2} β (Finset.{u2} β) (Finset.hasMem.{u2} β) b s) => f b))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {f : β -> (Set.{u1} α)} (s : Finset.{u2} β), (forall (b : β), (Membership.Mem.{u2, u2} β (Finset.{u2} β) (Finset.hasMem.{u2} β) b s) -> (MeasurableSet.{u1} α m (f b))) -> (MeasurableSet.{u1} α m (Set.iUnion.{u1, succ u2} α β (fun (b : β) => Set.iUnion.{u1, 0} α (Membership.Mem.{u2, u2} β (Finset.{u2} β) (Finset.hasMem.{u2} β) b s) (fun (H : Membership.Mem.{u2, u2} β (Finset.{u2} β) (Finset.hasMem.{u2} β) b s) => f b))))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {f : β -> (Set.{u2} α)} (s : Finset.{u1} β), (forall (b : β), (Membership.mem.{u1, u1} β (Finset.{u1} β) (Finset.instMembershipFinset.{u1} β) b s) -> (MeasurableSet.{u2} α m (f b))) -> (MeasurableSet.{u2} α m (Set.unionᵢ.{u2, succ u1} α β (fun (b : β) => Set.unionᵢ.{u2, 0} α (Membership.mem.{u1, u1} β (Finset.{u1} β) (Finset.instMembershipFinset.{u1} β) b s) (fun (H : Membership.mem.{u1, u1} β (Finset.{u1} β) (Finset.instMembershipFinset.{u1} β) b s) => f b))))
-Case conversion may be inaccurate. Consider using '#align finset.measurable_set_bUnion Finset.measurableSet_bunionᵢₓ'. -/
-theorem Finset.measurableSet_bunionᵢ {f : β → Set α} (s : Finset β)
+  forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {f : β -> (Set.{u2} α)} (s : Finset.{u1} β), (forall (b : β), (Membership.mem.{u1, u1} β (Finset.{u1} β) (Finset.instMembershipFinset.{u1} β) b s) -> (MeasurableSet.{u2} α m (f b))) -> (MeasurableSet.{u2} α m (Set.iUnion.{u2, succ u1} α β (fun (b : β) => Set.iUnion.{u2, 0} α (Membership.mem.{u1, u1} β (Finset.{u1} β) (Finset.instMembershipFinset.{u1} β) b s) (fun (H : Membership.mem.{u1, u1} β (Finset.{u1} β) (Finset.instMembershipFinset.{u1} β) b s) => f b))))
+Case conversion may be inaccurate. Consider using '#align finset.measurable_set_bUnion Finset.measurableSet_biUnionₓ'. -/
+theorem Finset.measurableSet_biUnion {f : β → Set α} (s : Finset β)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋃ b ∈ s, f b) :=
-  s.finite_toSet.measurableSet_bunionᵢ h
-#align finset.measurable_set_bUnion Finset.measurableSet_bunionᵢ
+  s.finite_toSet.measurableSet_biUnion h
+#align finset.measurable_set_bUnion Finset.measurableSet_biUnion
 
-#print MeasurableSet.unionₛ /-
-theorem MeasurableSet.unionₛ {s : Set (Set α)} (hs : s.Countable) (h : ∀ t ∈ s, MeasurableSet t) :
+#print MeasurableSet.sUnion /-
+theorem MeasurableSet.sUnion {s : Set (Set α)} (hs : s.Countable) (h : ∀ t ∈ s, MeasurableSet t) :
     MeasurableSet (⋃₀ s) := by
   rw [sUnion_eq_bUnion]
-  exact MeasurableSet.bunionᵢ hs h
-#align measurable_set.sUnion MeasurableSet.unionₛ
+  exact MeasurableSet.biUnion hs h
+#align measurable_set.sUnion MeasurableSet.sUnion
 -/
 
-#print Set.Finite.measurableSet_unionₛ /-
-theorem Set.Finite.measurableSet_unionₛ {s : Set (Set α)} (hs : s.Finite)
+#print Set.Finite.measurableSet_sUnion /-
+theorem Set.Finite.measurableSet_sUnion {s : Set (Set α)} (hs : s.Finite)
     (h : ∀ t ∈ s, MeasurableSet t) : MeasurableSet (⋃₀ s) :=
-  MeasurableSet.unionₛ hs.Countable h
-#align set.finite.measurable_set_sUnion Set.Finite.measurableSet_unionₛ
+  MeasurableSet.sUnion hs.Countable h
+#align set.finite.measurable_set_sUnion Set.Finite.measurableSet_sUnion
 -/
 
-#print MeasurableSet.interᵢ /-
-theorem MeasurableSet.interᵢ [Countable ι] {f : ι → Set α} (h : ∀ b, MeasurableSet (f b)) :
+#print MeasurableSet.iInter /-
+theorem MeasurableSet.iInter [Countable ι] {f : ι → Set α} (h : ∀ b, MeasurableSet (f b)) :
     MeasurableSet (⋂ b, f b) :=
   MeasurableSet.compl_iff.1 <| by
     rw [compl_Inter]
-    exact MeasurableSet.unionᵢ fun b => (h b).compl
-#align measurable_set.Inter MeasurableSet.interᵢ
+    exact MeasurableSet.iUnion fun b => (h b).compl
+#align measurable_set.Inter MeasurableSet.iInter
 -/
 
-/- warning: measurable_set.bInter -> MeasurableSet.binterᵢ is a dubious translation:
+/- warning: measurable_set.bInter -> MeasurableSet.biInter is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {f : β -> (Set.{u1} α)} {s : Set.{u2} β}, (Set.Countable.{u2} β s) -> (forall (b : β), (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) -> (MeasurableSet.{u1} α m (f b))) -> (MeasurableSet.{u1} α m (Set.interᵢ.{u1, succ u2} α β (fun (b : β) => Set.interᵢ.{u1, 0} α (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) => f b))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {f : β -> (Set.{u1} α)} {s : Set.{u2} β}, (Set.Countable.{u2} β s) -> (forall (b : β), (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) -> (MeasurableSet.{u1} α m (f b))) -> (MeasurableSet.{u1} α m (Set.iInter.{u1, succ u2} α β (fun (b : β) => Set.iInter.{u1, 0} α (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) => f b))))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {f : β -> (Set.{u2} α)} {s : Set.{u1} β}, (Set.Countable.{u1} β s) -> (forall (b : β), (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) -> (MeasurableSet.{u2} α m (f b))) -> (MeasurableSet.{u2} α m (Set.interᵢ.{u2, succ u1} α β (fun (b : β) => Set.interᵢ.{u2, 0} α (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) (fun (H : Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) => f b))))
-Case conversion may be inaccurate. Consider using '#align measurable_set.bInter MeasurableSet.binterᵢₓ'. -/
-theorem MeasurableSet.binterᵢ {f : β → Set α} {s : Set β} (hs : s.Countable)
+  forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {f : β -> (Set.{u2} α)} {s : Set.{u1} β}, (Set.Countable.{u1} β s) -> (forall (b : β), (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) -> (MeasurableSet.{u2} α m (f b))) -> (MeasurableSet.{u2} α m (Set.iInter.{u2, succ u1} α β (fun (b : β) => Set.iInter.{u2, 0} α (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) (fun (H : Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) => f b))))
+Case conversion may be inaccurate. Consider using '#align measurable_set.bInter MeasurableSet.biInterₓ'. -/
+theorem MeasurableSet.biInter {f : β → Set α} {s : Set β} (hs : s.Countable)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋂ b ∈ s, f b) :=
   MeasurableSet.compl_iff.1 <| by
     rw [compl_Inter₂]
-    exact MeasurableSet.bunionᵢ hs fun b hb => (h b hb).compl
-#align measurable_set.bInter MeasurableSet.binterᵢ
+    exact MeasurableSet.biUnion hs fun b hb => (h b hb).compl
+#align measurable_set.bInter MeasurableSet.biInter
 
-/- warning: set.finite.measurable_set_bInter -> Set.Finite.measurableSet_binterᵢ is a dubious translation:
+/- warning: set.finite.measurable_set_bInter -> Set.Finite.measurableSet_biInter is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {f : β -> (Set.{u1} α)} {s : Set.{u2} β}, (Set.Finite.{u2} β s) -> (forall (b : β), (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) -> (MeasurableSet.{u1} α m (f b))) -> (MeasurableSet.{u1} α m (Set.interᵢ.{u1, succ u2} α β (fun (b : β) => Set.interᵢ.{u1, 0} α (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) => f b))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {f : β -> (Set.{u1} α)} {s : Set.{u2} β}, (Set.Finite.{u2} β s) -> (forall (b : β), (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) -> (MeasurableSet.{u1} α m (f b))) -> (MeasurableSet.{u1} α m (Set.iInter.{u1, succ u2} α β (fun (b : β) => Set.iInter.{u1, 0} α (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b s) => f b))))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {f : β -> (Set.{u2} α)} {s : Set.{u1} β}, (Set.Finite.{u1} β s) -> (forall (b : β), (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) -> (MeasurableSet.{u2} α m (f b))) -> (MeasurableSet.{u2} α m (Set.interᵢ.{u2, succ u1} α β (fun (b : β) => Set.interᵢ.{u2, 0} α (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) (fun (H : Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) => f b))))
-Case conversion may be inaccurate. Consider using '#align set.finite.measurable_set_bInter Set.Finite.measurableSet_binterᵢₓ'. -/
-theorem Set.Finite.measurableSet_binterᵢ {f : β → Set α} {s : Set β} (hs : s.Finite)
+  forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {f : β -> (Set.{u2} α)} {s : Set.{u1} β}, (Set.Finite.{u1} β s) -> (forall (b : β), (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) -> (MeasurableSet.{u2} α m (f b))) -> (MeasurableSet.{u2} α m (Set.iInter.{u2, succ u1} α β (fun (b : β) => Set.iInter.{u2, 0} α (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) (fun (H : Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b s) => f b))))
+Case conversion may be inaccurate. Consider using '#align set.finite.measurable_set_bInter Set.Finite.measurableSet_biInterₓ'. -/
+theorem Set.Finite.measurableSet_biInter {f : β → Set α} {s : Set β} (hs : s.Finite)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋂ b ∈ s, f b) :=
-  MeasurableSet.binterᵢ hs.Countable h
-#align set.finite.measurable_set_bInter Set.Finite.measurableSet_binterᵢ
+  MeasurableSet.biInter hs.Countable h
+#align set.finite.measurable_set_bInter Set.Finite.measurableSet_biInter
 
-/- warning: finset.measurable_set_bInter -> Finset.measurableSet_binterᵢ is a dubious translation:
+/- warning: finset.measurable_set_bInter -> Finset.measurableSet_biInter is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {f : β -> (Set.{u1} α)} (s : Finset.{u2} β), (forall (b : β), (Membership.Mem.{u2, u2} β (Finset.{u2} β) (Finset.hasMem.{u2} β) b s) -> (MeasurableSet.{u1} α m (f b))) -> (MeasurableSet.{u1} α m (Set.interᵢ.{u1, succ u2} α β (fun (b : β) => Set.interᵢ.{u1, 0} α (Membership.Mem.{u2, u2} β (Finset.{u2} β) (Finset.hasMem.{u2} β) b s) (fun (H : Membership.Mem.{u2, u2} β (Finset.{u2} β) (Finset.hasMem.{u2} β) b s) => f b))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {m : MeasurableSpace.{u1} α} {f : β -> (Set.{u1} α)} (s : Finset.{u2} β), (forall (b : β), (Membership.Mem.{u2, u2} β (Finset.{u2} β) (Finset.hasMem.{u2} β) b s) -> (MeasurableSet.{u1} α m (f b))) -> (MeasurableSet.{u1} α m (Set.iInter.{u1, succ u2} α β (fun (b : β) => Set.iInter.{u1, 0} α (Membership.Mem.{u2, u2} β (Finset.{u2} β) (Finset.hasMem.{u2} β) b s) (fun (H : Membership.Mem.{u2, u2} β (Finset.{u2} β) (Finset.hasMem.{u2} β) b s) => f b))))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {f : β -> (Set.{u2} α)} (s : Finset.{u1} β), (forall (b : β), (Membership.mem.{u1, u1} β (Finset.{u1} β) (Finset.instMembershipFinset.{u1} β) b s) -> (MeasurableSet.{u2} α m (f b))) -> (MeasurableSet.{u2} α m (Set.interᵢ.{u2, succ u1} α β (fun (b : β) => Set.interᵢ.{u2, 0} α (Membership.mem.{u1, u1} β (Finset.{u1} β) (Finset.instMembershipFinset.{u1} β) b s) (fun (H : Membership.mem.{u1, u1} β (Finset.{u1} β) (Finset.instMembershipFinset.{u1} β) b s) => f b))))
-Case conversion may be inaccurate. Consider using '#align finset.measurable_set_bInter Finset.measurableSet_binterᵢₓ'. -/
-theorem Finset.measurableSet_binterᵢ {f : β → Set α} (s : Finset β)
+  forall {α : Type.{u2}} {β : Type.{u1}} {m : MeasurableSpace.{u2} α} {f : β -> (Set.{u2} α)} (s : Finset.{u1} β), (forall (b : β), (Membership.mem.{u1, u1} β (Finset.{u1} β) (Finset.instMembershipFinset.{u1} β) b s) -> (MeasurableSet.{u2} α m (f b))) -> (MeasurableSet.{u2} α m (Set.iInter.{u2, succ u1} α β (fun (b : β) => Set.iInter.{u2, 0} α (Membership.mem.{u1, u1} β (Finset.{u1} β) (Finset.instMembershipFinset.{u1} β) b s) (fun (H : Membership.mem.{u1, u1} β (Finset.{u1} β) (Finset.instMembershipFinset.{u1} β) b s) => f b))))
+Case conversion may be inaccurate. Consider using '#align finset.measurable_set_bInter Finset.measurableSet_biInterₓ'. -/
+theorem Finset.measurableSet_biInter {f : β → Set α} (s : Finset β)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋂ b ∈ s, f b) :=
-  s.finite_toSet.measurableSet_binterᵢ h
-#align finset.measurable_set_bInter Finset.measurableSet_binterᵢ
+  s.finite_toSet.measurableSet_biInter h
+#align finset.measurable_set_bInter Finset.measurableSet_biInter
 
-#print MeasurableSet.interₛ /-
-theorem MeasurableSet.interₛ {s : Set (Set α)} (hs : s.Countable) (h : ∀ t ∈ s, MeasurableSet t) :
+#print MeasurableSet.sInter /-
+theorem MeasurableSet.sInter {s : Set (Set α)} (hs : s.Countable) (h : ∀ t ∈ s, MeasurableSet t) :
     MeasurableSet (⋂₀ s) := by
   rw [sInter_eq_bInter]
-  exact MeasurableSet.binterᵢ hs h
-#align measurable_set.sInter MeasurableSet.interₛ
+  exact MeasurableSet.biInter hs h
+#align measurable_set.sInter MeasurableSet.sInter
 -/
 
-#print Set.Finite.measurableSet_interₛ /-
-theorem Set.Finite.measurableSet_interₛ {s : Set (Set α)} (hs : s.Finite)
+#print Set.Finite.measurableSet_sInter /-
+theorem Set.Finite.measurableSet_sInter {s : Set (Set α)} (hs : s.Finite)
     (h : ∀ t ∈ s, MeasurableSet t) : MeasurableSet (⋂₀ s) :=
-  MeasurableSet.interₛ hs.Countable h
-#align set.finite.measurable_set_sInter Set.Finite.measurableSet_interₛ
+  MeasurableSet.sInter hs.Countable h
+#align set.finite.measurable_set_sInter Set.Finite.measurableSet_sInter
 -/
 
 /- warning: measurable_set.union -> MeasurableSet.union is a dubious translation:
@@ -278,7 +278,7 @@ Case conversion may be inaccurate. Consider using '#align measurable_set.union M
 theorem MeasurableSet.union {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (h₂ : MeasurableSet s₂) :
     MeasurableSet (s₁ ∪ s₂) := by
   rw [union_eq_Union]
-  exact MeasurableSet.unionᵢ (Bool.forall_bool.2 ⟨h₂, h₁⟩)
+  exact MeasurableSet.iUnion (Bool.forall_bool.2 ⟨h₂, h₁⟩)
 #align measurable_set.union MeasurableSet.union
 
 /- warning: measurable_set.inter -> MeasurableSet.inter is a dubious translation:
@@ -458,7 +458,7 @@ protected theorem Finset.measurableSet (s : Finset α) : MeasurableSet (↑s : S
 theorem Set.Countable.measurableSet {s : Set α} (hs : s.Countable) : MeasurableSet s :=
   by
   rw [← bUnion_of_singleton s]
-  exact MeasurableSet.bunionᵢ hs fun b hb => measurable_set_singleton b
+  exact MeasurableSet.biUnion hs fun b hb => measurable_set_singleton b
 #align set.countable.measurable_set Set.Countable.measurableSet
 -/
 
@@ -498,7 +498,7 @@ def generateFrom (s : Set (Set α)) : MeasurableSpace α
   MeasurableSet' := GenerateMeasurable s
   measurable_set_empty := GenerateMeasurable.empty
   measurable_set_compl := GenerateMeasurable.compl
-  measurable_set_unionᵢ := GenerateMeasurable.unionᵢ
+  measurable_set_iUnion := GenerateMeasurable.iUnion
 #align measurable_space.generate_from MeasurableSpace.generateFrom
 -/
 
@@ -511,9 +511,9 @@ theorem measurableSet_generateFrom {s : Set (Set α)} {t : Set α} (ht : t ∈ s
 
 /- warning: measurable_space.generate_from_induction -> MeasurableSpace.generateFrom_induction is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} (p : (Set.{u1} α) -> Prop) (C : Set.{u1} (Set.{u1} α)), (forall (t : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) t C) -> (p t)) -> (p (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α))) -> (forall (t : Set.{u1} α), (p t) -> (p (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) t))) -> (forall (f : Nat -> (Set.{u1} α)), (forall (n : Nat), p (f n)) -> (p (Set.unionᵢ.{u1, 1} α Nat (fun (i : Nat) => f i)))) -> (forall {s : Set.{u1} α}, (MeasurableSet.{u1} α (MeasurableSpace.generateFrom.{u1} α C) s) -> (p s))
+  forall {α : Type.{u1}} (p : (Set.{u1} α) -> Prop) (C : Set.{u1} (Set.{u1} α)), (forall (t : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) t C) -> (p t)) -> (p (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α))) -> (forall (t : Set.{u1} α), (p t) -> (p (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) t))) -> (forall (f : Nat -> (Set.{u1} α)), (forall (n : Nat), p (f n)) -> (p (Set.iUnion.{u1, 1} α Nat (fun (i : Nat) => f i)))) -> (forall {s : Set.{u1} α}, (MeasurableSet.{u1} α (MeasurableSpace.generateFrom.{u1} α C) s) -> (p s))
 but is expected to have type
-  forall {α : Type.{u1}} (p : (Set.{u1} α) -> Prop) (C : Set.{u1} (Set.{u1} α)), (forall (t : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) t C) -> (p t)) -> (p (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α))) -> (forall (t : Set.{u1} α), (p t) -> (p (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) t))) -> (forall (f : Nat -> (Set.{u1} α)), (forall (n : Nat), p (f n)) -> (p (Set.unionᵢ.{u1, 1} α Nat (fun (i : Nat) => f i)))) -> (forall {s : Set.{u1} α}, (MeasurableSet.{u1} α (MeasurableSpace.generateFrom.{u1} α C) s) -> (p s))
+  forall {α : Type.{u1}} (p : (Set.{u1} α) -> Prop) (C : Set.{u1} (Set.{u1} α)), (forall (t : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) t C) -> (p t)) -> (p (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α))) -> (forall (t : Set.{u1} α), (p t) -> (p (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) t))) -> (forall (f : Nat -> (Set.{u1} α)), (forall (n : Nat), p (f n)) -> (p (Set.iUnion.{u1, 1} α Nat (fun (i : Nat) => f i)))) -> (forall {s : Set.{u1} α}, (MeasurableSet.{u1} α (MeasurableSpace.generateFrom.{u1} α C) s) -> (p s))
 Case conversion may be inaccurate. Consider using '#align measurable_space.generate_from_induction MeasurableSpace.generateFrom_inductionₓ'. -/
 @[elab_as_elim]
 theorem generateFrom_induction (p : Set α → Prop) (C : Set (Set α)) (hC : ∀ t ∈ C, p t)
@@ -530,7 +530,7 @@ theorem generateFrom_le {s : Set (Set α)} {m : MeasurableSpace α}
     (h : ∀ t ∈ s, measurable_set[m] t) : generateFrom s ≤ m :=
   fun t (ht : GenerateMeasurable s t) =>
   ht.recOn h (measurable_set_empty m) (fun s _ hs => measurable_set_compl m s hs) fun f _ hf =>
-    measurable_set_unionᵢ m f hf
+    measurable_set_iUnion m f hf
 #align measurable_space.generate_from_le MeasurableSpace.generateFrom_le
 -/
 
@@ -557,7 +557,7 @@ protected def mkOfClosure (g : Set (Set α)) (hg : { t | measurable_set[generate
   MeasurableSet' s := s ∈ g
   measurable_set_empty := hg ▸ measurable_set_empty _
   measurable_set_compl := hg ▸ measurable_set_compl _
-  measurable_set_unionᵢ := hg ▸ measurable_set_unionᵢ _
+  measurable_set_iUnion := hg ▸ measurable_set_iUnion _
 #align measurable_space.mk_of_closure MeasurableSpace.mkOfClosure
 -/
 
@@ -677,15 +677,15 @@ theorem measurableSet_bot_iff {s : Set α} : @MeasurableSet α ⊥ s ↔ s = ∅
     { MeasurableSet' := fun s => s = ∅ ∨ s = univ
       measurable_set_empty := Or.inl rfl
       measurable_set_compl := by simp (config := { contextual := true }) [or_imp]
-      measurable_set_unionᵢ := fun f hf =>
+      measurable_set_iUnion := fun f hf =>
         by_cases
           (fun h : ∃ i, f i = univ =>
             let ⟨i, hi⟩ := h
-            Or.inr <| eq_univ_of_univ_subset <| hi ▸ le_supᵢ f i)
+            Or.inr <| eq_univ_of_univ_subset <| hi ▸ le_iSup f i)
           fun h : ¬∃ i, f i = univ =>
           Or.inl <|
             eq_empty_of_subset_empty <|
-              unionᵢ_subset fun i =>
+              iUnion_subset fun i =>
                 (hf i).elim (by simp (config := { contextual := true })) fun hi =>
                   False.elim <| h ⟨i, hi⟩ }
   have : b = ⊥ :=
@@ -718,29 +718,29 @@ theorem measurableSet_inf {m₁ m₂ : MeasurableSpace α} {s : Set α} :
   Iff.rfl
 #align measurable_space.measurable_set_inf MeasurableSpace.measurableSet_inf
 
-/- warning: measurable_space.measurable_set_Inf -> MeasurableSpace.measurableSet_infₛ is a dubious translation:
+/- warning: measurable_space.measurable_set_Inf -> MeasurableSpace.measurableSet_sInf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ms : Set.{u1} (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (InfSet.infₛ.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) ms) s) (forall (m : MeasurableSpace.{u1} α), (Membership.Mem.{u1, u1} (MeasurableSpace.{u1} α) (Set.{u1} (MeasurableSpace.{u1} α)) (Set.hasMem.{u1} (MeasurableSpace.{u1} α)) m ms) -> (MeasurableSet.{u1} α m s))
+  forall {α : Type.{u1}} {ms : Set.{u1} (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (InfSet.sInf.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) ms) s) (forall (m : MeasurableSpace.{u1} α), (Membership.Mem.{u1, u1} (MeasurableSpace.{u1} α) (Set.{u1} (MeasurableSpace.{u1} α)) (Set.hasMem.{u1} (MeasurableSpace.{u1} α)) m ms) -> (MeasurableSet.{u1} α m s))
 but is expected to have type
-  forall {α : Type.{u1}} {ms : Set.{u1} (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (InfSet.infₛ.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))) ms) s) (forall (m : MeasurableSpace.{u1} α), (Membership.mem.{u1, u1} (MeasurableSpace.{u1} α) (Set.{u1} (MeasurableSpace.{u1} α)) (Set.instMembershipSet.{u1} (MeasurableSpace.{u1} α)) m ms) -> (MeasurableSet.{u1} α m s))
-Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_set_Inf MeasurableSpace.measurableSet_infₛₓ'. -/
+  forall {α : Type.{u1}} {ms : Set.{u1} (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (InfSet.sInf.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))) ms) s) (forall (m : MeasurableSpace.{u1} α), (Membership.mem.{u1, u1} (MeasurableSpace.{u1} α) (Set.{u1} (MeasurableSpace.{u1} α)) (Set.instMembershipSet.{u1} (MeasurableSpace.{u1} α)) m ms) -> (MeasurableSet.{u1} α m s))
+Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_set_Inf MeasurableSpace.measurableSet_sInfₓ'. -/
 @[simp]
-theorem measurableSet_infₛ {ms : Set (MeasurableSpace α)} {s : Set α} :
-    @MeasurableSet _ (infₛ ms) s ↔ ∀ m ∈ ms, @MeasurableSet _ m s :=
+theorem measurableSet_sInf {ms : Set (MeasurableSpace α)} {s : Set α} :
+    @MeasurableSet _ (sInf ms) s ↔ ∀ m ∈ ms, @MeasurableSet _ m s :=
   show s ∈ ⋂₀ _ ↔ _ by simp
-#align measurable_space.measurable_set_Inf MeasurableSpace.measurableSet_infₛ
+#align measurable_space.measurable_set_Inf MeasurableSpace.measurableSet_sInf
 
-/- warning: measurable_space.measurable_set_infi -> MeasurableSpace.measurableSet_infᵢ is a dubious translation:
+/- warning: measurable_space.measurable_set_infi -> MeasurableSpace.measurableSet_iInf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {m : ι -> (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (infᵢ.{u1, u2} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) ι m) s) (forall (i : ι), MeasurableSet.{u1} α (m i) s)
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {m : ι -> (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (iInf.{u1, u2} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) ι m) s) (forall (i : ι), MeasurableSet.{u1} α (m i) s)
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {m : ι -> (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (infᵢ.{u1, u2} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))) ι m) s) (forall (i : ι), MeasurableSet.{u1} α (m i) s)
-Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_set_infi MeasurableSpace.measurableSet_infᵢₓ'. -/
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {m : ι -> (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (iInf.{u1, u2} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toInfSet.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))) ι m) s) (forall (i : ι), MeasurableSet.{u1} α (m i) s)
+Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_set_infi MeasurableSpace.measurableSet_iInfₓ'. -/
 @[simp]
-theorem measurableSet_infᵢ {ι} {m : ι → MeasurableSpace α} {s : Set α} :
-    @MeasurableSet _ (infᵢ m) s ↔ ∀ i, @MeasurableSet _ (m i) s := by
-  rw [infᵢ, measurable_set_Inf, forall_range_iff]
-#align measurable_space.measurable_set_infi MeasurableSpace.measurableSet_infᵢ
+theorem measurableSet_iInf {ι} {m : ι → MeasurableSpace α} {s : Set α} :
+    @MeasurableSet _ (iInf m) s ↔ ∀ i, @MeasurableSet _ (m i) s := by
+  rw [iInf, measurable_set_Inf, forall_range_iff]
+#align measurable_space.measurable_set_infi MeasurableSpace.measurableSet_iInf
 
 /- warning: measurable_space.measurable_set_sup -> MeasurableSpace.measurableSet_sup is a dubious translation:
 lean 3 declaration is
@@ -753,55 +753,55 @@ theorem measurableSet_sup {m₁ m₂ : MeasurableSpace α} {s : Set α} :
   Iff.refl _
 #align measurable_space.measurable_set_sup MeasurableSpace.measurableSet_sup
 
-/- warning: measurable_space.measurable_set_Sup -> MeasurableSpace.measurableSet_supₛ is a dubious translation:
+/- warning: measurable_space.measurable_set_Sup -> MeasurableSpace.measurableSet_sSup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ms : Set.{u1} (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (SupSet.supₛ.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) ms) s) (MeasurableSpace.GenerateMeasurable.{u1} α (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{succ u1} (MeasurableSpace.{u1} α) (fun (m : MeasurableSpace.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (MeasurableSpace.{u1} α) (Set.{u1} (MeasurableSpace.{u1} α)) (Set.hasMem.{u1} (MeasurableSpace.{u1} α)) m ms) (fun (H : Membership.Mem.{u1, u1} (MeasurableSpace.{u1} α) (Set.{u1} (MeasurableSpace.{u1} α)) (Set.hasMem.{u1} (MeasurableSpace.{u1} α)) m ms) => MeasurableSet.{u1} α m s)))) s)
+  forall {α : Type.{u1}} {ms : Set.{u1} (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (SupSet.sSup.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) ms) s) (MeasurableSpace.GenerateMeasurable.{u1} α (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{succ u1} (MeasurableSpace.{u1} α) (fun (m : MeasurableSpace.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (MeasurableSpace.{u1} α) (Set.{u1} (MeasurableSpace.{u1} α)) (Set.hasMem.{u1} (MeasurableSpace.{u1} α)) m ms) (fun (H : Membership.Mem.{u1, u1} (MeasurableSpace.{u1} α) (Set.{u1} (MeasurableSpace.{u1} α)) (Set.hasMem.{u1} (MeasurableSpace.{u1} α)) m ms) => MeasurableSet.{u1} α m s)))) s)
 but is expected to have type
-  forall {α : Type.{u1}} {ms : Set.{u1} (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (SupSet.supₛ.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))) ms) s) (MeasurableSpace.GenerateMeasurable.{u1} α (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{succ u1} (MeasurableSpace.{u1} α) (fun (m : MeasurableSpace.{u1} α) => And (Membership.mem.{u1, u1} (MeasurableSpace.{u1} α) (Set.{u1} (MeasurableSpace.{u1} α)) (Set.instMembershipSet.{u1} (MeasurableSpace.{u1} α)) m ms) (MeasurableSet.{u1} α m s)))) s)
-Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_set_Sup MeasurableSpace.measurableSet_supₛₓ'. -/
-theorem measurableSet_supₛ {ms : Set (MeasurableSpace α)} {s : Set α} :
-    measurable_set[supₛ ms] s ↔
+  forall {α : Type.{u1}} {ms : Set.{u1} (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (SupSet.sSup.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))) ms) s) (MeasurableSpace.GenerateMeasurable.{u1} α (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{succ u1} (MeasurableSpace.{u1} α) (fun (m : MeasurableSpace.{u1} α) => And (Membership.mem.{u1, u1} (MeasurableSpace.{u1} α) (Set.{u1} (MeasurableSpace.{u1} α)) (Set.instMembershipSet.{u1} (MeasurableSpace.{u1} α)) m ms) (MeasurableSet.{u1} α m s)))) s)
+Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_set_Sup MeasurableSpace.measurableSet_sSupₓ'. -/
+theorem measurableSet_sSup {ms : Set (MeasurableSpace α)} {s : Set α} :
+    measurable_set[sSup ms] s ↔
       GenerateMeasurable { s : Set α | ∃ m ∈ ms, measurable_set[m] s } s :=
   by
   change @measurable_set' _ (generate_from <| ⋃₀ _) _ ↔ _
   simp [generate_from, ← set_of_exists]
-#align measurable_space.measurable_set_Sup MeasurableSpace.measurableSet_supₛ
+#align measurable_space.measurable_set_Sup MeasurableSpace.measurableSet_sSup
 
-/- warning: measurable_space.measurable_set_supr -> MeasurableSpace.measurableSet_supᵢ is a dubious translation:
+/- warning: measurable_space.measurable_set_supr -> MeasurableSpace.measurableSet_iSup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {m : ι -> (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (supᵢ.{u1, u2} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) ι m) s) (MeasurableSpace.GenerateMeasurable.{u1} α (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{u2} ι (fun (i : ι) => MeasurableSet.{u1} α (m i) s))) s)
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {m : ι -> (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (iSup.{u1, u2} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) ι m) s) (MeasurableSpace.GenerateMeasurable.{u1} α (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{u2} ι (fun (i : ι) => MeasurableSet.{u1} α (m i) s))) s)
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {m : ι -> (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (supᵢ.{u1, u2} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))) ι m) s) (MeasurableSpace.GenerateMeasurable.{u1} α (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{u2} ι (fun (i : ι) => MeasurableSet.{u1} α (m i) s))) s)
-Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_set_supr MeasurableSpace.measurableSet_supᵢₓ'. -/
-theorem measurableSet_supᵢ {ι} {m : ι → MeasurableSpace α} {s : Set α} :
-    @MeasurableSet _ (supᵢ m) s ↔ GenerateMeasurable { s : Set α | ∃ i, measurable_set[m i] s } s :=
-  by simp only [supᵢ, measurable_set_Sup, exists_range_iff]
-#align measurable_space.measurable_set_supr MeasurableSpace.measurableSet_supᵢ
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {m : ι -> (MeasurableSpace.{u1} α)} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (iSup.{u1, u2} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toSupSet.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))) ι m) s) (MeasurableSpace.GenerateMeasurable.{u1} α (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{u2} ι (fun (i : ι) => MeasurableSet.{u1} α (m i) s))) s)
+Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_set_supr MeasurableSpace.measurableSet_iSupₓ'. -/
+theorem measurableSet_iSup {ι} {m : ι → MeasurableSpace α} {s : Set α} :
+    @MeasurableSet _ (iSup m) s ↔ GenerateMeasurable { s : Set α | ∃ i, measurable_set[m i] s } s :=
+  by simp only [iSup, measurable_set_Sup, exists_range_iff]
+#align measurable_space.measurable_set_supr MeasurableSpace.measurableSet_iSup
 
-/- warning: measurable_space.measurable_space_supr_eq -> MeasurableSpace.measurableSpace_supᵢ_eq is a dubious translation:
+/- warning: measurable_space.measurable_space_supr_eq -> MeasurableSpace.measurableSpace_iSup_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} (m : ι -> (MeasurableSpace.{u1} α)), Eq.{succ u1} (MeasurableSpace.{u1} α) (supᵢ.{u1, u2} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) ι (fun (n : ι) => m n)) (MeasurableSpace.generateFrom.{u1} α (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{u2} ι (fun (n : ι) => MeasurableSet.{u1} α (m n) s))))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} (m : ι -> (MeasurableSpace.{u1} α)), Eq.{succ u1} (MeasurableSpace.{u1} α) (iSup.{u1, u2} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) ι (fun (n : ι) => m n)) (MeasurableSpace.generateFrom.{u1} α (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{u2} ι (fun (n : ι) => MeasurableSet.{u1} α (m n) s))))
 but is expected to have type
-  forall {α : Type.{u2}} {ι : Sort.{u1}} (m : ι -> (MeasurableSpace.{u2} α)), Eq.{succ u2} (MeasurableSpace.{u2} α) (supᵢ.{u2, u1} (MeasurableSpace.{u2} α) (ConditionallyCompleteLattice.toSupSet.{u2} (MeasurableSpace.{u2} α) (CompleteLattice.toConditionallyCompleteLattice.{u2} (MeasurableSpace.{u2} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u2} α))) ι (fun (n : ι) => m n)) (MeasurableSpace.generateFrom.{u2} α (setOf.{u2} (Set.{u2} α) (fun (s : Set.{u2} α) => Exists.{u1} ι (fun (n : ι) => MeasurableSet.{u2} α (m n) s))))
-Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_space_supr_eq MeasurableSpace.measurableSpace_supᵢ_eqₓ'. -/
-theorem measurableSpace_supᵢ_eq (m : ι → MeasurableSpace α) :
+  forall {α : Type.{u2}} {ι : Sort.{u1}} (m : ι -> (MeasurableSpace.{u2} α)), Eq.{succ u2} (MeasurableSpace.{u2} α) (iSup.{u2, u1} (MeasurableSpace.{u2} α) (ConditionallyCompleteLattice.toSupSet.{u2} (MeasurableSpace.{u2} α) (CompleteLattice.toConditionallyCompleteLattice.{u2} (MeasurableSpace.{u2} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u2} α))) ι (fun (n : ι) => m n)) (MeasurableSpace.generateFrom.{u2} α (setOf.{u2} (Set.{u2} α) (fun (s : Set.{u2} α) => Exists.{u1} ι (fun (n : ι) => MeasurableSet.{u2} α (m n) s))))
+Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_space_supr_eq MeasurableSpace.measurableSpace_iSup_eqₓ'. -/
+theorem measurableSpace_iSup_eq (m : ι → MeasurableSpace α) :
     (⨆ n, m n) = generateFrom { s | ∃ n, measurable_set[m n] s } :=
   by
   ext s
   rw [measurable_set_supr]
   rfl
-#align measurable_space.measurable_space_supr_eq MeasurableSpace.measurableSpace_supᵢ_eq
+#align measurable_space.measurable_space_supr_eq MeasurableSpace.measurableSpace_iSup_eq
 
-/- warning: measurable_space.generate_from_Union_measurable_set -> MeasurableSpace.generateFrom_unionᵢ_measurableSet is a dubious translation:
+/- warning: measurable_space.generate_from_Union_measurable_set -> MeasurableSpace.generateFrom_iUnion_measurableSet is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} (m : ι -> (MeasurableSpace.{u1} α)), Eq.{succ u1} (MeasurableSpace.{u1} α) (MeasurableSpace.generateFrom.{u1} α (Set.unionᵢ.{u1, u2} (Set.{u1} α) ι (fun (n : ι) => setOf.{u1} (Set.{u1} α) (fun (t : Set.{u1} α) => MeasurableSet.{u1} α (m n) t)))) (supᵢ.{u1, u2} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) ι (fun (n : ι) => m n))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} (m : ι -> (MeasurableSpace.{u1} α)), Eq.{succ u1} (MeasurableSpace.{u1} α) (MeasurableSpace.generateFrom.{u1} α (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (n : ι) => setOf.{u1} (Set.{u1} α) (fun (t : Set.{u1} α) => MeasurableSet.{u1} α (m n) t)))) (iSup.{u1, u2} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))) ι (fun (n : ι) => m n))
 but is expected to have type
-  forall {α : Type.{u2}} {ι : Sort.{u1}} (m : ι -> (MeasurableSpace.{u2} α)), Eq.{succ u2} (MeasurableSpace.{u2} α) (MeasurableSpace.generateFrom.{u2} α (Set.unionᵢ.{u2, u1} (Set.{u2} α) ι (fun (n : ι) => setOf.{u2} (Set.{u2} α) (fun (t : Set.{u2} α) => MeasurableSet.{u2} α (m n) t)))) (supᵢ.{u2, u1} (MeasurableSpace.{u2} α) (ConditionallyCompleteLattice.toSupSet.{u2} (MeasurableSpace.{u2} α) (CompleteLattice.toConditionallyCompleteLattice.{u2} (MeasurableSpace.{u2} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u2} α))) ι (fun (n : ι) => m n))
-Case conversion may be inaccurate. Consider using '#align measurable_space.generate_from_Union_measurable_set MeasurableSpace.generateFrom_unionᵢ_measurableSetₓ'. -/
-theorem generateFrom_unionᵢ_measurableSet (m : ι → MeasurableSpace α) :
+  forall {α : Type.{u2}} {ι : Sort.{u1}} (m : ι -> (MeasurableSpace.{u2} α)), Eq.{succ u2} (MeasurableSpace.{u2} α) (MeasurableSpace.generateFrom.{u2} α (Set.iUnion.{u2, u1} (Set.{u2} α) ι (fun (n : ι) => setOf.{u2} (Set.{u2} α) (fun (t : Set.{u2} α) => MeasurableSet.{u2} α (m n) t)))) (iSup.{u2, u1} (MeasurableSpace.{u2} α) (ConditionallyCompleteLattice.toSupSet.{u2} (MeasurableSpace.{u2} α) (CompleteLattice.toConditionallyCompleteLattice.{u2} (MeasurableSpace.{u2} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u2} α))) ι (fun (n : ι) => m n))
+Case conversion may be inaccurate. Consider using '#align measurable_space.generate_from_Union_measurable_set MeasurableSpace.generateFrom_iUnion_measurableSetₓ'. -/
+theorem generateFrom_iUnion_measurableSet (m : ι → MeasurableSpace α) :
     generateFrom (⋃ n, { t | measurable_set[m n] t }) = ⨆ n, m n :=
-  (@giGenerateFrom α).l_supᵢ_u m
-#align measurable_space.generate_from_Union_measurable_set MeasurableSpace.generateFrom_unionᵢ_measurableSet
+  (@giGenerateFrom α).l_iSup_u m
+#align measurable_space.generate_from_Union_measurable_set MeasurableSpace.generateFrom_iUnion_measurableSet
 
 end CompleteLattice
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/9da1b3534b65d9661eb8f42443598a92bbb49211

@@ -310,7 +310,7 @@ theorem MeasurableSet.diff {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (h
 lean 3 declaration is
   forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α}, (MeasurableSet.{u1} α m s₁) -> (MeasurableSet.{u1} α m s₂) -> (MeasurableSet.{u1} α m (symmDiff.{u1} (Set.{u1} α) (SemilatticeSup.toHasSup.{u1} (Set.{u1} α) (Lattice.toSemilatticeSup.{u1} (Set.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Set.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α)))))))) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s₁ s₂))
 but is expected to have type
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α}, (MeasurableSet.{u1} α m s₁) -> (MeasurableSet.{u1} α m s₂) -> (MeasurableSet.{u1} α m (symmDiff.{u1} (Set.{u1} α) (SemilatticeSup.toHasSup.{u1} (Set.{u1} α) (Lattice.toSemilatticeSup.{u1} (Set.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Set.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))))) (Set.instSDiffSet.{u1} α) s₁ s₂))
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α}, (MeasurableSet.{u1} α m s₁) -> (MeasurableSet.{u1} α m s₂) -> (MeasurableSet.{u1} α m (symmDiff.{u1} (Set.{u1} α) (SemilatticeSup.toSup.{u1} (Set.{u1} α) (Lattice.toSemilatticeSup.{u1} (Set.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Set.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))))) (Set.instSDiffSet.{u1} α) s₁ s₂))
 Case conversion may be inaccurate. Consider using '#align measurable_set.symm_diff MeasurableSet.symmDiffₓ'. -/
 @[simp]
 theorem MeasurableSet.symmDiff {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (h₂ : MeasurableSet s₂) :
@@ -602,9 +602,9 @@ theorem generateFrom_mono {s t : Set (Set α)} (h : s ⊆ t) : generateFrom s 
 
 /- warning: measurable_space.generate_from_sup_generate_from -> MeasurableSpace.generateFrom_sup_generateFrom is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} (Set.{u1} α)} {t : Set.{u1} (Set.{u1} α)}, Eq.{succ u1} (MeasurableSpace.{u1} α) (HasSup.sup.{u1} (MeasurableSpace.{u1} α) (SemilatticeSup.toHasSup.{u1} (MeasurableSpace.{u1} α) (Lattice.toSemilatticeSup.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))))) (MeasurableSpace.generateFrom.{u1} α s) (MeasurableSpace.generateFrom.{u1} α t)) (MeasurableSpace.generateFrom.{u1} α (Union.union.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasUnion.{u1} (Set.{u1} α)) s t))
+  forall {α : Type.{u1}} {s : Set.{u1} (Set.{u1} α)} {t : Set.{u1} (Set.{u1} α)}, Eq.{succ u1} (MeasurableSpace.{u1} α) (Sup.sup.{u1} (MeasurableSpace.{u1} α) (SemilatticeSup.toHasSup.{u1} (MeasurableSpace.{u1} α) (Lattice.toSemilatticeSup.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))))) (MeasurableSpace.generateFrom.{u1} α s) (MeasurableSpace.generateFrom.{u1} α t)) (MeasurableSpace.generateFrom.{u1} α (Union.union.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasUnion.{u1} (Set.{u1} α)) s t))
 but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} (Set.{u1} α)} {t : Set.{u1} (Set.{u1} α)}, Eq.{succ u1} (MeasurableSpace.{u1} α) (HasSup.sup.{u1} (MeasurableSpace.{u1} α) (SemilatticeSup.toHasSup.{u1} (MeasurableSpace.{u1} α) (Lattice.toSemilatticeSup.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))))) (MeasurableSpace.generateFrom.{u1} α s) (MeasurableSpace.generateFrom.{u1} α t)) (MeasurableSpace.generateFrom.{u1} α (Union.union.{u1} (Set.{u1} (Set.{u1} α)) (Set.instUnionSet.{u1} (Set.{u1} α)) s t))
+  forall {α : Type.{u1}} {s : Set.{u1} (Set.{u1} α)} {t : Set.{u1} (Set.{u1} α)}, Eq.{succ u1} (MeasurableSpace.{u1} α) (Sup.sup.{u1} (MeasurableSpace.{u1} α) (SemilatticeSup.toSup.{u1} (MeasurableSpace.{u1} α) (Lattice.toSemilatticeSup.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))))) (MeasurableSpace.generateFrom.{u1} α s) (MeasurableSpace.generateFrom.{u1} α t)) (MeasurableSpace.generateFrom.{u1} α (Union.union.{u1} (Set.{u1} (Set.{u1} α)) (Set.instUnionSet.{u1} (Set.{u1} α)) s t))
 Case conversion may be inaccurate. Consider using '#align measurable_space.generate_from_sup_generate_from MeasurableSpace.generateFrom_sup_generateFromₓ'. -/
 theorem generateFrom_sup_generateFrom {s t : Set (Set α)} :
     generateFrom s ⊔ generateFrom t = generateFrom (s ∪ t) :=
@@ -708,9 +708,9 @@ theorem measurableSet_top {s : Set α} : @MeasurableSet _ ⊤ s :=
 
 /- warning: measurable_space.measurable_set_inf -> MeasurableSpace.measurableSet_inf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {m₁ : MeasurableSpace.{u1} α} {m₂ : MeasurableSpace.{u1} α} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (HasInf.inf.{u1} (MeasurableSpace.{u1} α) (SemilatticeInf.toHasInf.{u1} (MeasurableSpace.{u1} α) (Lattice.toSemilatticeInf.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))))) m₁ m₂) s) (And (MeasurableSet.{u1} α m₁ s) (MeasurableSet.{u1} α m₂ s))
+  forall {α : Type.{u1}} {m₁ : MeasurableSpace.{u1} α} {m₂ : MeasurableSpace.{u1} α} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (Inf.inf.{u1} (MeasurableSpace.{u1} α) (SemilatticeInf.toHasInf.{u1} (MeasurableSpace.{u1} α) (Lattice.toSemilatticeInf.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))))) m₁ m₂) s) (And (MeasurableSet.{u1} α m₁ s) (MeasurableSet.{u1} α m₂ s))
 but is expected to have type
-  forall {α : Type.{u1}} {m₁ : MeasurableSpace.{u1} α} {m₂ : MeasurableSpace.{u1} α} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (HasInf.inf.{u1} (MeasurableSpace.{u1} α) (Lattice.toHasInf.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α)))) m₁ m₂) s) (And (MeasurableSet.{u1} α m₁ s) (MeasurableSet.{u1} α m₂ s))
+  forall {α : Type.{u1}} {m₁ : MeasurableSpace.{u1} α} {m₂ : MeasurableSpace.{u1} α} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (Inf.inf.{u1} (MeasurableSpace.{u1} α) (Lattice.toInf.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α)))) m₁ m₂) s) (And (MeasurableSet.{u1} α m₁ s) (MeasurableSet.{u1} α m₂ s))
 Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_set_inf MeasurableSpace.measurableSet_infₓ'. -/
 @[simp]
 theorem measurableSet_inf {m₁ m₂ : MeasurableSpace α} {s : Set α} :
@@ -744,9 +744,9 @@ theorem measurableSet_infᵢ {ι} {m : ι → MeasurableSpace α} {s : Set α} :
 
 /- warning: measurable_space.measurable_set_sup -> MeasurableSpace.measurableSet_sup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {m₁ : MeasurableSpace.{u1} α} {m₂ : MeasurableSpace.{u1} α} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (HasSup.sup.{u1} (MeasurableSpace.{u1} α) (SemilatticeSup.toHasSup.{u1} (MeasurableSpace.{u1} α) (Lattice.toSemilatticeSup.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))))) m₁ m₂) s) (MeasurableSpace.GenerateMeasurable.{u1} α (Union.union.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasUnion.{u1} (Set.{u1} α)) (MeasurableSet.{u1} α m₁) (MeasurableSet.{u1} α m₂)) s)
+  forall {α : Type.{u1}} {m₁ : MeasurableSpace.{u1} α} {m₂ : MeasurableSpace.{u1} α} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (Sup.sup.{u1} (MeasurableSpace.{u1} α) (SemilatticeSup.toHasSup.{u1} (MeasurableSpace.{u1} α) (Lattice.toSemilatticeSup.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.completeLattice.{u1} α))))) m₁ m₂) s) (MeasurableSpace.GenerateMeasurable.{u1} α (Union.union.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasUnion.{u1} (Set.{u1} α)) (MeasurableSet.{u1} α m₁) (MeasurableSet.{u1} α m₂)) s)
 but is expected to have type
-  forall {α : Type.{u1}} {m₁ : MeasurableSpace.{u1} α} {m₂ : MeasurableSpace.{u1} α} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (HasSup.sup.{u1} (MeasurableSpace.{u1} α) (SemilatticeSup.toHasSup.{u1} (MeasurableSpace.{u1} α) (Lattice.toSemilatticeSup.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))))) m₁ m₂) s) (MeasurableSpace.GenerateMeasurable.{u1} α (Union.union.{u1} (Set.{u1} (Set.{u1} α)) (Set.instUnionSet.{u1} (Set.{u1} α)) (MeasurableSet.{u1} α m₁) (MeasurableSet.{u1} α m₂)) s)
+  forall {α : Type.{u1}} {m₁ : MeasurableSpace.{u1} α} {m₂ : MeasurableSpace.{u1} α} {s : Set.{u1} α}, Iff (MeasurableSet.{u1} α (Sup.sup.{u1} (MeasurableSpace.{u1} α) (SemilatticeSup.toSup.{u1} (MeasurableSpace.{u1} α) (Lattice.toSemilatticeSup.{u1} (MeasurableSpace.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (MeasurableSpace.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (MeasurableSpace.{u1} α) (MeasurableSpace.instCompleteLatticeMeasurableSpace.{u1} α))))) m₁ m₂) s) (MeasurableSpace.GenerateMeasurable.{u1} α (Union.union.{u1} (Set.{u1} (Set.{u1} α)) (Set.instUnionSet.{u1} (Set.{u1} α)) (MeasurableSet.{u1} α m₁) (MeasurableSet.{u1} α m₂)) s)
 Case conversion may be inaccurate. Consider using '#align measurable_space.measurable_set_sup MeasurableSpace.measurableSet_supₓ'. -/
 theorem measurableSet_sup {m₁ m₂ : MeasurableSpace α} {s : Set α} :
     measurable_set[m₁ ⊔ m₂] s ↔ GenerateMeasurable (measurable_set[m₁] ∪ measurable_set[m₂]) s :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

Classifies by adding issue number #11215 to porting notes claiming "TODO".

@@ -64,7 +64,7 @@ def MeasurableSet [MeasurableSpace α] (s : Set α) : Prop :=
   ‹MeasurableSpace α›.MeasurableSet' s
 #align measurable_set MeasurableSet
 
--- Porting note: todo: `scoped[MeasureTheory]` doesn't work for unknown reason
+-- Porting note (#11215): TODO: `scoped[MeasureTheory]` doesn't work for unknown reason
 namespace MeasureTheory
 set_option quotPrecheck false in
 /-- Notation for `MeasurableSet` with respect to a non-standard σ-algebra. -/
@@ -497,7 +497,8 @@ theorem measurableSet_bot_iff {s : Set α} : MeasurableSet[⊥] s ↔ s = ∅ 
 @[simp, measurability] theorem measurableSet_top {s : Set α} : MeasurableSet[⊤] s := trivial
 #align measurable_space.measurable_set_top MeasurableSpace.measurableSet_top
 
-@[simp, nolint simpNF] -- Porting note: todo: `simpNF` claims that this lemma doesn't simplify LHS
+@[simp, nolint simpNF] -- Porting note (#11215): TODO: `simpNF` claims that
+-- this lemma doesn't simplify LHS
 theorem measurableSet_inf {m₁ m₂ : MeasurableSpace α} {s : Set α} :
     MeasurableSet[m₁ ⊓ m₂] s ↔ MeasurableSet[m₁] s ∧ MeasurableSet[m₂] s :=
   Iff.rfl

ball for "bounded forall" and bex for "bounded exists" are from experience very confusing abbreviations. This PR renames them to forall_mem and exists_mem in the few Set lemma names that mention them.

Also deprecate ball_image_of_ball, mem_image_elim, mem_image_elim_on since those lemmas are duplicates of the renamed lemmas (apart from argument order and implicitness, which I am also fixing by making the binder in the RHS of forall_mem_image semi-implicit), have obscure names and are completely unused.

@@ -486,7 +486,7 @@ theorem measurableSet_bot_iff {s : Set α} : MeasurableSet[⊥] s ↔ s = ∅ 
     { MeasurableSet' := fun s => s = ∅ ∨ s = univ
       measurableSet_empty := Or.inl rfl
       measurableSet_compl := by simp (config := { contextual := true }) [or_imp]
-      measurableSet_iUnion := fun f hf => sUnion_mem_empty_univ (forall_range_iff.2 hf) }
+      measurableSet_iUnion := fun f hf => sUnion_mem_empty_univ (forall_mem_range.2 hf) }
   have : b = ⊥ :=
     bot_unique fun s hs =>
       hs.elim (fun s => s.symm ▸ @measurableSet_empty _ ⊥) fun s =>
@@ -511,7 +511,7 @@ theorem measurableSet_sInf {ms : Set (MeasurableSpace α)} {s : Set α} :
 
 theorem measurableSet_iInf {ι} {m : ι → MeasurableSpace α} {s : Set α} :
     MeasurableSet[iInf m] s ↔ ∀ i, MeasurableSet[m i] s := by
-  rw [iInf, measurableSet_sInf, forall_range_iff]
+  rw [iInf, measurableSet_sInf, forall_mem_range]
 #align measurable_space.measurable_set_infi MeasurableSpace.measurableSet_iInf
 
 theorem measurableSet_sup {m₁ m₂ : MeasurableSpace α} {s : Set α} :

We remove all but one open Classicals, instead preferring to use open scoped Classical. The only real side-effect this led to is moving a couple declarations to use Exists.choose instead of Classical.choose.

The first few commits are explicitly labelled regex replaces for ease of review.

@@ -39,7 +39,7 @@ measurable space, σ-algebra, measurable function
 
 open Set Encodable Function Equiv
 
-open Classical
+open scoped Classical
 
 variable {α β γ δ δ' : Type*} {ι : Sort*} {s t u : Set α}
 

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

• converts "--porting note" into "-- Porting note";
• converts "porting note" into "Porting note".

@@ -64,7 +64,7 @@ def MeasurableSet [MeasurableSpace α] (s : Set α) : Prop :=
   ‹MeasurableSpace α›.MeasurableSet' s
 #align measurable_set MeasurableSet
 
--- porting note: todo: `scoped[MeasureTheory]` doesn't work for unknown reason
+-- Porting note: todo: `scoped[MeasureTheory]` doesn't work for unknown reason
 namespace MeasureTheory
 set_option quotPrecheck false in
 /-- Notation for `MeasurableSet` with respect to a non-standard σ-algebra. -/
@@ -497,7 +497,7 @@ theorem measurableSet_bot_iff {s : Set α} : MeasurableSet[⊥] s ↔ s = ∅ 
 @[simp, measurability] theorem measurableSet_top {s : Set α} : MeasurableSet[⊤] s := trivial
 #align measurable_space.measurable_set_top MeasurableSpace.measurableSet_top
 
-@[simp, nolint simpNF] -- porting note: todo: `simpNF` claims that this lemma doesn't simplify LHS
+@[simp, nolint simpNF] -- Porting note: todo: `simpNF` claims that this lemma doesn't simplify LHS
 theorem measurableSet_inf {m₁ m₂ : MeasurableSpace α} {s : Set α} :
     MeasurableSet[m₁ ⊓ m₂] s ↔ MeasurableSet[m₁] s ∧ MeasurableSet[m₂] s :=
   Iff.rfl

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -578,7 +578,7 @@ protected theorem Measurable.comp {_ : MeasurableSpace α} {_ : MeasurableSpace
 #align measurable.comp Measurable.comp
 
 -- This is needed due to reducibility issues with the `measurability` tactic.
-@[aesop safe 50 (rule_sets [Measurable])]
+@[aesop safe 50 (rule_sets := [Measurable])]
 protected theorem Measurable.comp' {_ : MeasurableSpace α} {_ : MeasurableSpace β}
     {_ : MeasurableSpace γ} {g : β → γ} {f : α → β} (hg : Measurable g) (hf : Measurable f) :
     Measurable (fun x => g (f x)) := Measurable.comp hg hf

@@ -453,6 +453,14 @@ theorem generateFrom_sup_generateFrom {s t : Set (Set α)} :
   (@giGenerateFrom α).gc.l_sup.symm
 #align measurable_space.generate_from_sup_generate_from MeasurableSpace.generateFrom_sup_generateFrom
 
+lemma iSup_generateFrom (s : ι → Set (Set α)) :
+    ⨆ i, generateFrom (s i) = generateFrom (⋃ i, s i) :=
+  (@MeasurableSpace.giGenerateFrom α).gc.l_iSup.symm
+
+@[simp]
+lemma generateFrom_empty : generateFrom (∅ : Set (Set α)) = ⊥ :=
+  le_bot_iff.mp (generateFrom_le (by simp))
+
 theorem generateFrom_singleton_empty : generateFrom {∅} = (⊥ : MeasurableSpace α) :=
   bot_unique <| generateFrom_le <| by simp [@MeasurableSet.empty α ⊥]
 #align measurable_space.generate_from_singleton_empty MeasurableSpace.generateFrom_singleton_empty

Those notations are not scoped whereas the file is very low in the import hierarchy.

@@ -75,6 +75,8 @@ open MeasureTheory
 
 section
 
+open scoped symmDiff
+
 @[simp, measurability]
 theorem MeasurableSet.empty [MeasurableSpace α] : MeasurableSet (∅ : Set α) :=
   MeasurableSpace.measurableSet_empty _

This uses the improved shake script from #9772 to reduce imports across mathlib. The corresponding noshake.json file has been added to #9772.

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

@@ -4,7 +4,6 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Mario Carneiro
 -/
 import Mathlib.Data.Set.Countable
-import Mathlib.Logic.Encodable.Lattice
 import Mathlib.Order.Disjointed
 import Mathlib.Tactic.Measurability
 

See Zulip thread for the discussion.

@@ -453,11 +453,11 @@ theorem generateFrom_sup_generateFrom {s t : Set (Set α)} :
 #align measurable_space.generate_from_sup_generate_from MeasurableSpace.generateFrom_sup_generateFrom
 
 theorem generateFrom_singleton_empty : generateFrom {∅} = (⊥ : MeasurableSpace α) :=
-  bot_unique $ generateFrom_le <| by simp [@MeasurableSet.empty α ⊥]
+  bot_unique <| generateFrom_le <| by simp [@MeasurableSet.empty α ⊥]
 #align measurable_space.generate_from_singleton_empty MeasurableSpace.generateFrom_singleton_empty
 
 theorem generateFrom_singleton_univ : generateFrom {Set.univ} = (⊥ : MeasurableSpace α) :=
-  bot_unique $ generateFrom_le <| by simp
+  bot_unique <| generateFrom_le <| by simp
 #align measurable_space.generate_from_singleton_univ MeasurableSpace.generateFrom_singleton_univ
 
 @[simp]

From PFR

@@ -207,12 +207,20 @@ protected theorem MeasurableSet.diff {s₁ s₂ : Set α} (h₁ : MeasurableSet
   h₁.inter h₂.compl
 #align measurable_set.diff MeasurableSet.diff
 
+@[simp, measurability]
+protected lemma MeasurableSet.himp {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (h₂ : MeasurableSet s₂) :
+    MeasurableSet (s₁ ⇨ s₂) := by rw [himp_eq]; exact h₂.union h₁.compl
+
 @[simp, measurability]
 protected theorem MeasurableSet.symmDiff {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁)
     (h₂ : MeasurableSet s₂) : MeasurableSet (s₁ ∆ s₂) :=
   (h₁.diff h₂).union (h₂.diff h₁)
 #align measurable_set.symm_diff MeasurableSet.symmDiff
 
+@[simp, measurability]
+protected lemma MeasurableSet.bihimp {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁)
+    (h₂ : MeasurableSet s₂) : MeasurableSet (s₁ ⇔ s₂) := (h₂.himp h₁).inter (h₁.himp h₂)
+
 @[simp, measurability]
 protected theorem MeasurableSet.ite {t s₁ s₂ : Set α} (ht : MeasurableSet t)
     (h₁ : MeasurableSet s₁) (h₂ : MeasurableSet s₂) : MeasurableSet (t.ite s₁ s₂) :=

Adds a typeclass for measurable spaces where all sets are measurable Proves several instances relating these to other classes

Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

@@ -575,8 +575,36 @@ theorem Measurable.le {α} {m m0 : MeasurableSpace α} {_ : MeasurableSpace β}
     {f : α → β} (hf : Measurable[m] f) : Measurable[m0] f := fun _ hs => hm _ (hf hs)
 #align measurable.le Measurable.le
 
-theorem MeasurableSpace.Top.measurable {α β : Type*} [MeasurableSpace β] (f : α → β) :
-    Measurable[⊤] f := fun _ _ => MeasurableSpace.measurableSet_top
-#align measurable_space.top.measurable MeasurableSpace.Top.measurable
-
 end MeasurableFunctions
+
+/-- A typeclass mixin for `MeasurableSpace`s such that all sets are measurable. -/
+class DiscreteMeasurableSpace (α : Type*) [MeasurableSpace α] : Prop where
+  /-- Do not use this. Use `measurableSet_discrete` instead. -/
+  forall_measurableSet : ∀ s : Set α, MeasurableSet s
+
+instance : @DiscreteMeasurableSpace α ⊤ :=
+  @DiscreteMeasurableSpace.mk _ (_) fun _ ↦ MeasurableSpace.measurableSet_top
+
+-- See note [lower instance priority]
+instance (priority := 100) MeasurableSingletonClass.toDiscreteMeasurableSpace [MeasurableSpace α]
+    [MeasurableSingletonClass α] [Countable α] : DiscreteMeasurableSpace α where
+  forall_measurableSet _ := (Set.to_countable _).measurableSet
+
+section DiscreteMeasurableSpace
+variable [MeasurableSpace α] [MeasurableSpace β] [DiscreteMeasurableSpace α]
+
+@[measurability] lemma measurableSet_discrete (s : Set α) : MeasurableSet s :=
+  DiscreteMeasurableSpace.forall_measurableSet _
+
+@[measurability]
+lemma measurable_discrete (f : α → β) : Measurable f := fun _ _ ↦ measurableSet_discrete _
+#align measurable_space.top.measurable measurable_discrete
+
+/-- Warning: Creates a typeclass loop with `MeasurableSingletonClass.toDiscreteMeasurableSpace`.
+To be monitored. -/
+-- See note [lower instance priority]
+instance (priority := 100) DiscreteMeasurableSpace.toMeasurableSingletonClass :
+    MeasurableSingletonClass α where
+  measurableSet_singleton _ := measurableSet_discrete _
+
+end DiscreteMeasurableSpace

@@ -68,7 +68,7 @@ def MeasurableSet [MeasurableSpace α] (s : Set α) : Prop :=
 -- porting note: todo: `scoped[MeasureTheory]` doesn't work for unknown reason
 namespace MeasureTheory
 set_option quotPrecheck false in
-/-- Notation for `MeasurableSet` with respect to a non-standanrd σ-algebra. -/
+/-- Notation for `MeasurableSet` with respect to a non-standard σ-algebra. -/
 scoped notation "MeasurableSet[" m "]" => @MeasurableSet _ m
 
 end MeasureTheory

Match https://github.com/leanprover-community/mathlib/pull/18506

@@ -8,7 +8,7 @@ import Mathlib.Logic.Encodable.Lattice
 import Mathlib.Order.Disjointed
 import Mathlib.Tactic.Measurability
 
-#align_import measure_theory.measurable_space_def from "leanprover-community/mathlib"@"4c19a16e4b705bf135cf9a80ac18fcc99c438514"
+#align_import measure_theory.measurable_space_def from "leanprover-community/mathlib"@"001ffdc42920050657fd45bd2b8bfbec8eaaeb29"
 
 /-!
 # Measurable spaces and measurable functions
@@ -238,7 +238,6 @@ protected theorem MeasurableSet.disjointed {f : ℕ → Set α} (h : ∀ i, Meas
   disjointedRec (fun _ _ ht => MeasurableSet.diff ht <| h _) (h n)
 #align measurable_set.disjointed MeasurableSet.disjointed
 
-@[simp]
 protected theorem MeasurableSet.const (p : Prop) : MeasurableSet { _a : α | p } := by
   by_cases p <;> simp [*]
 #align measurable_set.const MeasurableSet.const
@@ -445,12 +444,10 @@ theorem generateFrom_sup_generateFrom {s t : Set (Set α)} :
   (@giGenerateFrom α).gc.l_sup.symm
 #align measurable_space.generate_from_sup_generate_from MeasurableSpace.generateFrom_sup_generateFrom
 
-@[simp]
 theorem generateFrom_singleton_empty : generateFrom {∅} = (⊥ : MeasurableSpace α) :=
   bot_unique $ generateFrom_le <| by simp [@MeasurableSet.empty α ⊥]
 #align measurable_space.generate_from_singleton_empty MeasurableSpace.generateFrom_singleton_empty
 
-@[simp]
 theorem generateFrom_singleton_univ : generateFrom {Set.univ} = (⊥ : MeasurableSpace α) :=
   bot_unique $ generateFrom_le <| by simp
 #align measurable_space.generate_from_singleton_univ MeasurableSpace.generateFrom_singleton_univ

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

@@ -42,10 +42,10 @@ open Set Encodable Function Equiv
 
 open Classical
 
-variable {α β γ δ δ' : Type _} {ι : Sort _} {s t u : Set α}
+variable {α β γ δ δ' : Type*} {ι : Sort*} {s t u : Set α}
 
 /-- A measurable space is a space equipped with a σ-algebra. -/
-@[class] structure MeasurableSpace (α : Type _) where
+@[class] structure MeasurableSpace (α : Type*) where
   /-- Predicate saying that a given set is measurable. Use `MeasurableSet` in the root namespace
   instead. -/
   MeasurableSet' : Set α → Prop
@@ -265,7 +265,7 @@ theorem MeasurableSpace.ext_iff {m₁ m₂ : MeasurableSpace α} :
 #align measurable_space.ext_iff MeasurableSpace.ext_iff
 
 /-- A typeclass mixin for `MeasurableSpace`s such that each singleton is measurable. -/
-class MeasurableSingletonClass (α : Type _) [MeasurableSpace α] : Prop where
+class MeasurableSingletonClass (α : Type*) [MeasurableSpace α] : Prop where
   /-- A singleton is a measurable set. -/
   measurableSet_singleton : ∀ x, MeasurableSet ({x} : Set α)
 #align measurable_singleton_class MeasurableSingletonClass
@@ -578,7 +578,7 @@ theorem Measurable.le {α} {m m0 : MeasurableSpace α} {_ : MeasurableSpace β}
     {f : α → β} (hf : Measurable[m] f) : Measurable[m0] f := fun _ hs => hm _ (hf hs)
 #align measurable.le Measurable.le
 
-theorem MeasurableSpace.Top.measurable {α β : Type _} [MeasurableSpace β] (f : α → β) :
+theorem MeasurableSpace.Top.measurable {α β : Type*} [MeasurableSpace β] (f : α → β) :
     Measurable[⊤] f := fun _ _ => MeasurableSpace.measurableSet_top
 #align measurable_space.top.measurable MeasurableSpace.Top.measurable
 

• depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -2,17 +2,14 @@
 Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Mario Carneiro
-
-! This file was ported from Lean 3 source module measure_theory.measurable_space_def
-! leanprover-community/mathlib commit 4c19a16e4b705bf135cf9a80ac18fcc99c438514
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Set.Countable
 import Mathlib.Logic.Encodable.Lattice
 import Mathlib.Order.Disjointed
 import Mathlib.Tactic.Measurability
 
+#align_import measure_theory.measurable_space_def from "leanprover-community/mathlib"@"4c19a16e4b705bf135cf9a80ac18fcc99c438514"
+
 /-!
 # Measurable spaces and measurable functions
 

• Define a typeclass saying that a countable family of sets satisfying a given predicate separate points of a given set.
• Provide instances for open and closed sets in a T₀ space with second countable topology and for measurable sets in case of a countably generated σ-algebra.

See Zulip for motivation.

@@ -402,6 +402,16 @@ theorem generateFrom_measurableSet [MeasurableSpace α] :
   le_antisymm (generateFrom_le fun _ => id) fun _ => measurableSet_generateFrom
 #align measurable_space.generate_from_measurable_set MeasurableSpace.generateFrom_measurableSet
 
+theorem forall_generateFrom_mem_iff_mem_iff {S : Set (Set α)} {x y : α} :
+    (∀ s, MeasurableSet[generateFrom S] s → (x ∈ s ↔ y ∈ s)) ↔ (∀ s ∈ S, x ∈ s ↔ y ∈ s) := by
+  refine ⟨fun H s hs ↦ H s (.basic s hs), fun H s ↦ ?_⟩
+  apply generateFrom_induction
+  · exact H
+  · rfl
+  · exact fun _ ↦ Iff.not
+  · intro f hf
+    simp only [mem_iUnion, hf]
+
 /-- If `g` is a collection of subsets of `α` such that the `σ`-algebra generated from `g` contains
 the same sets as `g`, then `g` was already a `σ`-algebra. -/
 protected def mkOfClosure (g : Set (Set α)) (hg : { t | MeasurableSet[generateFrom g] t } = g) :

@@ -511,7 +511,7 @@ theorem measurableSet_iSup {ι} {m : ι → MeasurableSpace α} {s : Set α} :
 #align measurable_space.measurable_set_supr MeasurableSpace.measurableSet_iSup
 
 theorem measurableSpace_iSup_eq (m : ι → MeasurableSpace α) :
-    (⨆ n, m n) = generateFrom { s | ∃ n, MeasurableSet[m n] s } := by
+    ⨆ n, m n = generateFrom { s | ∃ n, MeasurableSet[m n] s } := by
   ext s
   rw [measurableSet_iSup]
   rfl

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

@@ -55,7 +55,7 @@ variable {α β γ δ δ' : Type _} {ι : Sort _} {s t u : Set α}
   /-- The empty set is a measurable set. Use `MeasurableSet.empty` instead. -/
   measurableSet_empty : MeasurableSet' ∅
   /-- The complement of a measurable set is a measurable set. Use `MeasurableSet.compl` instead. -/
-  measurableSet_compl : ∀ s, MeasurableSet' s → MeasurableSet' (sᶜ)
+  measurableSet_compl : ∀ s, MeasurableSet' s → MeasurableSet' sᶜ
   /-- The union of a sequence of measurable sets is a measurable set. Use a more general
   `MeasurableSet.iUnion` instead. -/
   measurableSet_iUnion : ∀ f : ℕ → Set α, (∀ i, MeasurableSet' (f i)) → MeasurableSet' (⋃ i, f i)
@@ -87,16 +87,16 @@ theorem MeasurableSet.empty [MeasurableSpace α] : MeasurableSet (∅ : Set α)
 variable {m : MeasurableSpace α}
 
 @[measurability]
-protected theorem MeasurableSet.compl : MeasurableSet s → MeasurableSet (sᶜ) :=
+protected theorem MeasurableSet.compl : MeasurableSet s → MeasurableSet sᶜ :=
   MeasurableSpace.measurableSet_compl _ s
 #align measurable_set.compl MeasurableSet.compl
 
-protected theorem MeasurableSet.of_compl (h : MeasurableSet (sᶜ)) : MeasurableSet s :=
+protected theorem MeasurableSet.of_compl (h : MeasurableSet sᶜ) : MeasurableSet s :=
   compl_compl s ▸ h.compl
 #align measurable_set.of_compl MeasurableSet.of_compl
 
 @[simp]
-theorem MeasurableSet.compl_iff : MeasurableSet (sᶜ) ↔ MeasurableSet s :=
+theorem MeasurableSet.compl_iff : MeasurableSet sᶜ ↔ MeasurableSet s :=
   ⟨.of_compl, .compl⟩
 #align measurable_set.compl_iff MeasurableSet.compl_iff
 
@@ -358,7 +358,7 @@ instance : PartialOrder (MeasurableSpace α) :=
 inductive GenerateMeasurable (s : Set (Set α)) : Set α → Prop
   | protected basic : ∀ u ∈ s, GenerateMeasurable s u
   | protected empty : GenerateMeasurable s ∅
-  | protected compl : ∀ t, GenerateMeasurable s t → GenerateMeasurable s (tᶜ)
+  | protected compl : ∀ t, GenerateMeasurable s t → GenerateMeasurable s tᶜ
   | protected iUnion : ∀ f : ℕ → Set α, (∀ n, GenerateMeasurable s (f n)) →
       GenerateMeasurable s (⋃ i, f i)
 #align measurable_space.generate_measurable MeasurableSpace.GenerateMeasurable
@@ -378,7 +378,7 @@ theorem measurableSet_generateFrom {s : Set (Set α)} {t : Set α} (ht : t ∈ s
 
 @[elab_as_elim]
 theorem generateFrom_induction (p : Set α → Prop) (C : Set (Set α)) (hC : ∀ t ∈ C, p t)
-    (h_empty : p ∅) (h_compl : ∀ t, p t → p (tᶜ))
+    (h_empty : p ∅) (h_compl : ∀ t, p t → p tᶜ)
     (h_Union : ∀ f : ℕ → Set α, (∀ n, p (f n)) → p (⋃ i, f i)) {s : Set α}
     (hs : MeasurableSet[generateFrom C] s) : p s := by
   induction hs

This PR adds aesop tags to a few lemmas pertaining to strong measurability, allowing to prove e.g. StronglyMeasurable Real.log using the measurability tactic.

It also implements measurability? via aesop?.

Co-authored-by: Frédéric Dupuis <31101893+dupuisf@users.noreply.github.com>

@@ -557,7 +557,7 @@ protected theorem Measurable.comp {_ : MeasurableSpace α} {_ : MeasurableSpace
 #align measurable.comp Measurable.comp
 
 -- This is needed due to reducibility issues with the `measurability` tactic.
-@[measurability]
+@[aesop safe 50 (rule_sets [Measurable])]
 protected theorem Measurable.comp' {_ : MeasurableSpace α} {_ : MeasurableSpace β}
     {_ : MeasurableSpace γ} {g : β → γ} {f : α → β} (hg : Measurable g) (hf : Measurable f) :
     Measurable (fun x => g (f x)) := Measurable.comp hg hf

Too often tempted to change these during other PRs, so doing a mass edit here.

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

@@ -225,14 +225,14 @@ protected theorem MeasurableSet.ite {t s₁ s₂ : Set α} (ht : MeasurableSet t
 theorem MeasurableSet.ite' {s t : Set α} {p : Prop} (hs : p → MeasurableSet s)
     (ht : ¬p → MeasurableSet t) : MeasurableSet (ite p s t) := by
   split_ifs with h
-  exacts[hs h, ht h]
+  exacts [hs h, ht h]
 #align measurable_set.ite' MeasurableSet.ite'
 
 @[simp, measurability]
 protected theorem MeasurableSet.cond {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁)
     (h₂ : MeasurableSet s₂) {i : Bool} : MeasurableSet (cond i s₁ s₂) := by
   cases i
-  exacts[h₂, h₁]
+  exacts [h₂, h₁]
 #align measurable_set.cond MeasurableSet.cond
 
 @[simp, measurability]

As discussed on Zulip

Renames

• supₛ → sSup
• infₛ → sInf
• supᵢ → iSup
• infᵢ → iInf
• bsupₛ → bsSup
• binfₛ → bsInf
• bsupᵢ → biSup
• binfᵢ → biInf
• csupₛ → csSup
• cinfₛ → csInf
• csupᵢ → ciSup
• cinfᵢ → ciInf
• unionₛ → sUnion
• interₛ → sInter
• unionᵢ → iUnion
• interᵢ → iInter
• bunionₛ → bsUnion
• binterₛ → bsInter
• bunionᵢ → biUnion
• binterᵢ → biInter

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -57,8 +57,8 @@ variable {α β γ δ δ' : Type _} {ι : Sort _} {s t u : Set α}
   /-- The complement of a measurable set is a measurable set. Use `MeasurableSet.compl` instead. -/
   measurableSet_compl : ∀ s, MeasurableSet' s → MeasurableSet' (sᶜ)
   /-- The union of a sequence of measurable sets is a measurable set. Use a more general
-  `MeasurableSet.unionᵢ` instead. -/
-  measurableSet_unionᵢ : ∀ f : ℕ → Set α, (∀ i, MeasurableSet' (f i)) → MeasurableSet' (⋃ i, f i)
+  `MeasurableSet.iUnion` instead. -/
+  measurableSet_iUnion : ∀ f : ℕ → Set α, (∀ i, MeasurableSet' (f i)) → MeasurableSet' (⋃ i, f i)
 #align measurable_space MeasurableSpace
 
 instance [h : MeasurableSpace α] : MeasurableSpace αᵒᵈ := h
@@ -115,86 +115,86 @@ theorem MeasurableSet.congr {s t : Set α} (hs : MeasurableSet s) (h : s = t) :
 #align measurable_set.congr MeasurableSet.congr
 
 @[measurability]
-protected theorem MeasurableSet.unionᵢ [Countable ι] ⦃f : ι → Set α⦄
+protected theorem MeasurableSet.iUnion [Countable ι] ⦃f : ι → Set α⦄
     (h : ∀ b, MeasurableSet (f b)) : MeasurableSet (⋃ b, f b) := by
   cases isEmpty_or_nonempty ι
   · simp
   · rcases exists_surjective_nat ι with ⟨e, he⟩
-    rw [← unionᵢ_congr_of_surjective _ he (fun _ => rfl)]
-    exact m.measurableSet_unionᵢ _ fun _ => h _
-#align measurable_set.Union MeasurableSet.unionᵢ
+    rw [← iUnion_congr_of_surjective _ he (fun _ => rfl)]
+    exact m.measurableSet_iUnion _ fun _ => h _
+#align measurable_set.Union MeasurableSet.iUnion
 
-@[deprecated MeasurableSet.unionᵢ]
-theorem MeasurableSet.bunionᵢ_decode₂ [Encodable β] ⦃f : β → Set α⦄ (h : ∀ b, MeasurableSet (f b))
+@[deprecated MeasurableSet.iUnion]
+theorem MeasurableSet.biUnion_decode₂ [Encodable β] ⦃f : β → Set α⦄ (h : ∀ b, MeasurableSet (f b))
     (n : ℕ) : MeasurableSet (⋃ b ∈ decode₂ β n, f b) :=
-  .unionᵢ fun _ => .unionᵢ fun _ => h _
-#align measurable_set.bUnion_decode₂ MeasurableSet.bunionᵢ_decode₂
+  .iUnion fun _ => .iUnion fun _ => h _
+#align measurable_set.bUnion_decode₂ MeasurableSet.biUnion_decode₂
 
-protected theorem MeasurableSet.bunionᵢ {f : β → Set α} {s : Set β} (hs : s.Countable)
+protected theorem MeasurableSet.biUnion {f : β → Set α} {s : Set β} (hs : s.Countable)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋃ b ∈ s, f b) := by
-  rw [bunionᵢ_eq_unionᵢ]
+  rw [biUnion_eq_iUnion]
   have := hs.to_subtype
-  exact MeasurableSet.unionᵢ (by simpa using h)
-#align measurable_set.bUnion MeasurableSet.bunionᵢ
+  exact MeasurableSet.iUnion (by simpa using h)
+#align measurable_set.bUnion MeasurableSet.biUnion
 
-theorem Set.Finite.measurableSet_bunionᵢ {f : β → Set α} {s : Set β} (hs : s.Finite)
+theorem Set.Finite.measurableSet_biUnion {f : β → Set α} {s : Set β} (hs : s.Finite)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋃ b ∈ s, f b) :=
-  .bunionᵢ hs.countable h
-#align set.finite.measurable_set_bUnion Set.Finite.measurableSet_bunionᵢ
+  .biUnion hs.countable h
+#align set.finite.measurable_set_bUnion Set.Finite.measurableSet_biUnion
 
-theorem Finset.measurableSet_bunionᵢ {f : β → Set α} (s : Finset β)
+theorem Finset.measurableSet_biUnion {f : β → Set α} (s : Finset β)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋃ b ∈ s, f b) :=
-  s.finite_toSet.measurableSet_bunionᵢ h
-#align finset.measurable_set_bUnion Finset.measurableSet_bunionᵢ
+  s.finite_toSet.measurableSet_biUnion h
+#align finset.measurable_set_bUnion Finset.measurableSet_biUnion
 
-protected theorem MeasurableSet.unionₛ {s : Set (Set α)} (hs : s.Countable)
+protected theorem MeasurableSet.sUnion {s : Set (Set α)} (hs : s.Countable)
     (h : ∀ t ∈ s, MeasurableSet t) : MeasurableSet (⋃₀ s) := by
-  rw [unionₛ_eq_bunionᵢ]
-  exact .bunionᵢ hs h
-#align measurable_set.sUnion MeasurableSet.unionₛ
+  rw [sUnion_eq_biUnion]
+  exact .biUnion hs h
+#align measurable_set.sUnion MeasurableSet.sUnion
 
-theorem Set.Finite.measurableSet_unionₛ {s : Set (Set α)} (hs : s.Finite)
+theorem Set.Finite.measurableSet_sUnion {s : Set (Set α)} (hs : s.Finite)
     (h : ∀ t ∈ s, MeasurableSet t) : MeasurableSet (⋃₀ s) :=
-  MeasurableSet.unionₛ hs.countable h
-#align set.finite.measurable_set_sUnion Set.Finite.measurableSet_unionₛ
+  MeasurableSet.sUnion hs.countable h
+#align set.finite.measurable_set_sUnion Set.Finite.measurableSet_sUnion
 
 @[measurability]
-theorem MeasurableSet.interᵢ [Countable ι] {f : ι → Set α} (h : ∀ b, MeasurableSet (f b)) :
+theorem MeasurableSet.iInter [Countable ι] {f : ι → Set α} (h : ∀ b, MeasurableSet (f b)) :
     MeasurableSet (⋂ b, f b) :=
-  .of_compl <| by rw [compl_interᵢ]; exact .unionᵢ fun b => (h b).compl
-#align measurable_set.Inter MeasurableSet.interᵢ
+  .of_compl <| by rw [compl_iInter]; exact .iUnion fun b => (h b).compl
+#align measurable_set.Inter MeasurableSet.iInter
 
-theorem MeasurableSet.binterᵢ {f : β → Set α} {s : Set β} (hs : s.Countable)
+theorem MeasurableSet.biInter {f : β → Set α} {s : Set β} (hs : s.Countable)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋂ b ∈ s, f b) :=
-  .of_compl <| by rw [compl_interᵢ₂]; exact .bunionᵢ hs fun b hb => (h b hb).compl
-#align measurable_set.bInter MeasurableSet.binterᵢ
+  .of_compl <| by rw [compl_iInter₂]; exact .biUnion hs fun b hb => (h b hb).compl
+#align measurable_set.bInter MeasurableSet.biInter
 
-theorem Set.Finite.measurableSet_binterᵢ {f : β → Set α} {s : Set β} (hs : s.Finite)
+theorem Set.Finite.measurableSet_biInter {f : β → Set α} {s : Set β} (hs : s.Finite)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋂ b ∈ s, f b) :=
- .binterᵢ hs.countable h
-#align set.finite.measurable_set_bInter Set.Finite.measurableSet_binterᵢ
+ .biInter hs.countable h
+#align set.finite.measurable_set_bInter Set.Finite.measurableSet_biInter
 
-theorem Finset.measurableSet_binterᵢ {f : β → Set α} (s : Finset β)
+theorem Finset.measurableSet_biInter {f : β → Set α} (s : Finset β)
     (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋂ b ∈ s, f b) :=
-  s.finite_toSet.measurableSet_binterᵢ h
-#align finset.measurable_set_bInter Finset.measurableSet_binterᵢ
+  s.finite_toSet.measurableSet_biInter h
+#align finset.measurable_set_bInter Finset.measurableSet_biInter
 
-theorem MeasurableSet.interₛ {s : Set (Set α)} (hs : s.Countable) (h : ∀ t ∈ s, MeasurableSet t) :
+theorem MeasurableSet.sInter {s : Set (Set α)} (hs : s.Countable) (h : ∀ t ∈ s, MeasurableSet t) :
     MeasurableSet (⋂₀ s) := by
-  rw [interₛ_eq_binterᵢ]
-  exact MeasurableSet.binterᵢ hs h
-#align measurable_set.sInter MeasurableSet.interₛ
+  rw [sInter_eq_biInter]
+  exact MeasurableSet.biInter hs h
+#align measurable_set.sInter MeasurableSet.sInter
 
-theorem Set.Finite.measurableSet_interₛ {s : Set (Set α)} (hs : s.Finite)
+theorem Set.Finite.measurableSet_sInter {s : Set (Set α)} (hs : s.Finite)
     (h : ∀ t ∈ s, MeasurableSet t) : MeasurableSet (⋂₀ s) :=
-  MeasurableSet.interₛ hs.countable h
-#align set.finite.measurable_set_sInter Set.Finite.measurableSet_interₛ
+  MeasurableSet.sInter hs.countable h
+#align set.finite.measurable_set_sInter Set.Finite.measurableSet_sInter
 
 @[simp, measurability]
 protected theorem MeasurableSet.union {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁)
     (h₂ : MeasurableSet s₂) : MeasurableSet (s₁ ∪ s₂) := by
-  rw [union_eq_unionᵢ]
-  exact .unionᵢ (Bool.forall_bool.2 ⟨h₂, h₁⟩)
+  rw [union_eq_iUnion]
+  exact .iUnion (Bool.forall_bool.2 ⟨h₂, h₁⟩)
 #align measurable_set.union MeasurableSet.union
 
 @[simp, measurability]
@@ -316,8 +316,8 @@ protected theorem Finset.measurableSet (s : Finset α) : MeasurableSet (↑s : S
 #align finset.measurable_set Finset.measurableSet
 
 theorem Set.Countable.measurableSet {s : Set α} (hs : s.Countable) : MeasurableSet s := by
-  rw [← bunionᵢ_of_singleton s]
-  exact .bunionᵢ hs fun b _ => .singleton b
+  rw [← biUnion_of_singleton s]
+  exact .biUnion hs fun b _ => .singleton b
 #align set.countable.measurable_set Set.Countable.measurableSet
 
 end MeasurableSingletonClass
@@ -331,7 +331,7 @@ protected def copy (m : MeasurableSpace α) (p : Set α → Prop) (h : ∀ s, p
   MeasurableSet' := p
   measurableSet_empty := by simpa only [h] using m.measurableSet_empty
   measurableSet_compl := by simpa only [h] using m.measurableSet_compl
-  measurableSet_unionᵢ := by simpa only [h] using m.measurableSet_unionᵢ
+  measurableSet_iUnion := by simpa only [h] using m.measurableSet_iUnion
 
 lemma measurableSet_copy {m : MeasurableSpace α} {p : Set α → Prop}
     (h : ∀ s, p s ↔ MeasurableSet[m] s) {s} : MeasurableSet[.copy m p h] s ↔ p s :=
@@ -359,7 +359,7 @@ inductive GenerateMeasurable (s : Set (Set α)) : Set α → Prop
   | protected basic : ∀ u ∈ s, GenerateMeasurable s u
   | protected empty : GenerateMeasurable s ∅
   | protected compl : ∀ t, GenerateMeasurable s t → GenerateMeasurable s (tᶜ)
-  | protected unionᵢ : ∀ f : ℕ → Set α, (∀ n, GenerateMeasurable s (f n)) →
+  | protected iUnion : ∀ f : ℕ → Set α, (∀ n, GenerateMeasurable s (f n)) →
       GenerateMeasurable s (⋃ i, f i)
 #align measurable_space.generate_measurable MeasurableSpace.GenerateMeasurable
 
@@ -368,7 +368,7 @@ def generateFrom (s : Set (Set α)) : MeasurableSpace α where
   MeasurableSet' := GenerateMeasurable s
   measurableSet_empty := .empty
   measurableSet_compl := .compl
-  measurableSet_unionᵢ := .unionᵢ
+  measurableSet_iUnion := .iUnion
 #align measurable_space.generate_from MeasurableSpace.generateFrom
 
 theorem measurableSet_generateFrom {s : Set (Set α)} {t : Set α} (ht : t ∈ s) :
@@ -388,7 +388,7 @@ theorem generateFrom_induction (p : Set α → Prop) (C : Set (Set α)) (hC : 
 theorem generateFrom_le {s : Set (Set α)} {m : MeasurableSpace α}
     (h : ∀ t ∈ s, MeasurableSet[m] t) : generateFrom s ≤ m :=
   fun t (ht : GenerateMeasurable s t) =>
-  ht.recOn h .empty (fun _ _ => .compl) fun _ _ hf => .unionᵢ hf
+  ht.recOn h .empty (fun _ _ => .compl) fun _ _ hf => .iUnion hf
 #align measurable_space.generate_from_le MeasurableSpace.generateFrom_le
 
 theorem generateFrom_le_iff {s : Set (Set α)} (m : MeasurableSpace α) :
@@ -465,7 +465,7 @@ theorem measurableSet_bot_iff {s : Set α} : MeasurableSet[⊥] s ↔ s = ∅ 
     { MeasurableSet' := fun s => s = ∅ ∨ s = univ
       measurableSet_empty := Or.inl rfl
       measurableSet_compl := by simp (config := { contextual := true }) [or_imp]
-      measurableSet_unionᵢ := fun f hf => unionₛ_mem_empty_univ (forall_range_iff.2 hf) }
+      measurableSet_iUnion := fun f hf => sUnion_mem_empty_univ (forall_range_iff.2 hf) }
   have : b = ⊥ :=
     bot_unique fun s hs =>
       hs.elim (fun s => s.symm ▸ @measurableSet_empty _ ⊥) fun s =>
@@ -483,44 +483,44 @@ theorem measurableSet_inf {m₁ m₂ : MeasurableSpace α} {s : Set α} :
 #align measurable_space.measurable_set_inf MeasurableSpace.measurableSet_inf
 
 @[simp]
-theorem measurableSet_infₛ {ms : Set (MeasurableSpace α)} {s : Set α} :
-    MeasurableSet[infₛ ms] s ↔ ∀ m ∈ ms, MeasurableSet[m] s :=
+theorem measurableSet_sInf {ms : Set (MeasurableSpace α)} {s : Set α} :
+    MeasurableSet[sInf ms] s ↔ ∀ m ∈ ms, MeasurableSet[m] s :=
   show s ∈ ⋂₀ _ ↔ _ by simp
-#align measurable_space.measurable_set_Inf MeasurableSpace.measurableSet_infₛ
+#align measurable_space.measurable_set_Inf MeasurableSpace.measurableSet_sInf
 
-theorem measurableSet_infᵢ {ι} {m : ι → MeasurableSpace α} {s : Set α} :
-    MeasurableSet[infᵢ m] s ↔ ∀ i, MeasurableSet[m i] s := by
-  rw [infᵢ, measurableSet_infₛ, forall_range_iff]
-#align measurable_space.measurable_set_infi MeasurableSpace.measurableSet_infᵢ
+theorem measurableSet_iInf {ι} {m : ι → MeasurableSpace α} {s : Set α} :
+    MeasurableSet[iInf m] s ↔ ∀ i, MeasurableSet[m i] s := by
+  rw [iInf, measurableSet_sInf, forall_range_iff]
+#align measurable_space.measurable_set_infi MeasurableSpace.measurableSet_iInf
 
 theorem measurableSet_sup {m₁ m₂ : MeasurableSpace α} {s : Set α} :
     MeasurableSet[m₁ ⊔ m₂] s ↔ GenerateMeasurable (MeasurableSet[m₁] ∪ MeasurableSet[m₂]) s :=
   Iff.rfl
 #align measurable_space.measurable_set_sup MeasurableSpace.measurableSet_sup
 
-theorem measurableSet_supₛ {ms : Set (MeasurableSpace α)} {s : Set α} :
-    MeasurableSet[supₛ ms] s ↔
+theorem measurableSet_sSup {ms : Set (MeasurableSpace α)} {s : Set α} :
+    MeasurableSet[sSup ms] s ↔
       GenerateMeasurable { s : Set α | ∃ m ∈ ms, MeasurableSet[m] s } s := by
   change GenerateMeasurable (⋃₀ _) _ ↔ _
   simp [← setOf_exists]
-#align measurable_space.measurable_set_Sup MeasurableSpace.measurableSet_supₛ
+#align measurable_space.measurable_set_Sup MeasurableSpace.measurableSet_sSup
 
-theorem measurableSet_supᵢ {ι} {m : ι → MeasurableSpace α} {s : Set α} :
-    MeasurableSet[supᵢ m] s ↔ GenerateMeasurable { s : Set α | ∃ i, MeasurableSet[m i] s } s :=
-  by simp only [supᵢ, measurableSet_supₛ, exists_range_iff]
-#align measurable_space.measurable_set_supr MeasurableSpace.measurableSet_supᵢ
+theorem measurableSet_iSup {ι} {m : ι → MeasurableSpace α} {s : Set α} :
+    MeasurableSet[iSup m] s ↔ GenerateMeasurable { s : Set α | ∃ i, MeasurableSet[m i] s } s :=
+  by simp only [iSup, measurableSet_sSup, exists_range_iff]
+#align measurable_space.measurable_set_supr MeasurableSpace.measurableSet_iSup
 
-theorem measurableSpace_supᵢ_eq (m : ι → MeasurableSpace α) :
+theorem measurableSpace_iSup_eq (m : ι → MeasurableSpace α) :
     (⨆ n, m n) = generateFrom { s | ∃ n, MeasurableSet[m n] s } := by
   ext s
-  rw [measurableSet_supᵢ]
+  rw [measurableSet_iSup]
   rfl
-#align measurable_space.measurable_space_supr_eq MeasurableSpace.measurableSpace_supᵢ_eq
+#align measurable_space.measurable_space_supr_eq MeasurableSpace.measurableSpace_iSup_eq
 
-theorem generateFrom_unionᵢ_measurableSet (m : ι → MeasurableSpace α) :
+theorem generateFrom_iUnion_measurableSet (m : ι → MeasurableSpace α) :
     generateFrom (⋃ n, { t | MeasurableSet[m n] t }) = ⨆ n, m n :=
-  (@giGenerateFrom α).l_supᵢ_u m
-#align measurable_space.generate_from_Union_measurable_set MeasurableSpace.generateFrom_unionᵢ_measurableSet
+  (@giGenerateFrom α).l_iSup_u m
+#align measurable_space.generate_from_Union_measurable_set MeasurableSpace.generateFrom_iUnion_measurableSet
 
 end CompleteLattice
 

@@ -11,6 +11,7 @@ Authors: Johannes Hölzl, Mario Carneiro
 import Mathlib.Data.Set.Countable
 import Mathlib.Logic.Encodable.Lattice
 import Mathlib.Order.Disjointed
+import Mathlib.Tactic.Measurability
 
 /-!
 # Measurable spaces and measurable functions
@@ -28,10 +29,6 @@ also `m₂`-measurable (that is, `m₁` is a subset of `m₂`). In particular, a
 collection of subsets of `α` generates a smallest σ-algebra which
 contains all of them.
 
-Do not add measurability lemmas (which could be tagged with
-@[measurability]) to this file, since the measurability tactic is downstream
-from here. Use `Mathlib.MeasureTheory.MeasurableSpace` instead.
-
 ## References
 
 * <https://en.wikipedia.org/wiki/Measurable_space>
@@ -82,13 +79,14 @@ open MeasureTheory
 
 section
 
-@[simp]
+@[simp, measurability]
 theorem MeasurableSet.empty [MeasurableSpace α] : MeasurableSet (∅ : Set α) :=
   MeasurableSpace.measurableSet_empty _
 #align measurable_set.empty MeasurableSet.empty
 
 variable {m : MeasurableSpace α}
 
+@[measurability]
 protected theorem MeasurableSet.compl : MeasurableSet s → MeasurableSet (sᶜ) :=
   MeasurableSpace.measurableSet_compl _ s
 #align measurable_set.compl MeasurableSet.compl
@@ -102,12 +100,12 @@ theorem MeasurableSet.compl_iff : MeasurableSet (sᶜ) ↔ MeasurableSet s :=
   ⟨.of_compl, .compl⟩
 #align measurable_set.compl_iff MeasurableSet.compl_iff
 
-@[simp]
+@[simp, measurability]
 protected theorem MeasurableSet.univ : MeasurableSet (univ : Set α) :=
   .of_compl <| by simp
 #align measurable_set.univ MeasurableSet.univ
 
-@[nontriviality]
+@[nontriviality, measurability]
 theorem Subsingleton.measurableSet [Subsingleton α] {s : Set α} : MeasurableSet s :=
   Subsingleton.set_cases MeasurableSet.empty MeasurableSet.univ s
 #align subsingleton.measurable_set Subsingleton.measurableSet
@@ -116,6 +114,7 @@ theorem MeasurableSet.congr {s t : Set α} (hs : MeasurableSet s) (h : s = t) :
   rwa [← h]
 #align measurable_set.congr MeasurableSet.congr
 
+@[measurability]
 protected theorem MeasurableSet.unionᵢ [Countable ι] ⦃f : ι → Set α⦄
     (h : ∀ b, MeasurableSet (f b)) : MeasurableSet (⋃ b, f b) := by
   cases isEmpty_or_nonempty ι
@@ -159,6 +158,7 @@ theorem Set.Finite.measurableSet_unionₛ {s : Set (Set α)} (hs : s.Finite)
   MeasurableSet.unionₛ hs.countable h
 #align set.finite.measurable_set_sUnion Set.Finite.measurableSet_unionₛ
 
+@[measurability]
 theorem MeasurableSet.interᵢ [Countable ι] {f : ι → Set α} (h : ∀ b, MeasurableSet (f b)) :
     MeasurableSet (⋂ b, f b) :=
   .of_compl <| by rw [compl_interᵢ]; exact .unionᵢ fun b => (h b).compl
@@ -190,33 +190,33 @@ theorem Set.Finite.measurableSet_interₛ {s : Set (Set α)} (hs : s.Finite)
   MeasurableSet.interₛ hs.countable h
 #align set.finite.measurable_set_sInter Set.Finite.measurableSet_interₛ
 
-@[simp]
+@[simp, measurability]
 protected theorem MeasurableSet.union {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁)
     (h₂ : MeasurableSet s₂) : MeasurableSet (s₁ ∪ s₂) := by
   rw [union_eq_unionᵢ]
   exact .unionᵢ (Bool.forall_bool.2 ⟨h₂, h₁⟩)
 #align measurable_set.union MeasurableSet.union
 
-@[simp]
+@[simp, measurability]
 protected theorem MeasurableSet.inter {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁)
     (h₂ : MeasurableSet s₂) : MeasurableSet (s₁ ∩ s₂) := by
   rw [inter_eq_compl_compl_union_compl]
   exact (h₁.compl.union h₂.compl).compl
 #align measurable_set.inter MeasurableSet.inter
 
-@[simp]
+@[simp, measurability]
 protected theorem MeasurableSet.diff {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁)
     (h₂ : MeasurableSet s₂) : MeasurableSet (s₁ \ s₂) :=
   h₁.inter h₂.compl
 #align measurable_set.diff MeasurableSet.diff
 
-@[simp]
+@[simp, measurability]
 protected theorem MeasurableSet.symmDiff {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁)
     (h₂ : MeasurableSet s₂) : MeasurableSet (s₁ ∆ s₂) :=
   (h₁.diff h₂).union (h₂.diff h₁)
 #align measurable_set.symm_diff MeasurableSet.symmDiff
 
-@[simp]
+@[simp, measurability]
 protected theorem MeasurableSet.ite {t s₁ s₂ : Set α} (ht : MeasurableSet t)
     (h₁ : MeasurableSet s₁) (h₂ : MeasurableSet s₂) : MeasurableSet (t.ite s₁ s₂) :=
   (h₁.inter ht).union (h₂.diff ht)
@@ -228,14 +228,14 @@ theorem MeasurableSet.ite' {s t : Set α} {p : Prop} (hs : p → MeasurableSet s
   exacts[hs h, ht h]
 #align measurable_set.ite' MeasurableSet.ite'
 
-@[simp]
+@[simp, measurability]
 protected theorem MeasurableSet.cond {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁)
     (h₂ : MeasurableSet s₂) {i : Bool} : MeasurableSet (cond i s₁ s₂) := by
   cases i
   exacts[h₂, h₁]
 #align measurable_set.cond MeasurableSet.cond
 
-@[simp]
+@[simp, measurability]
 protected theorem MeasurableSet.disjointed {f : ℕ → Set α} (h : ∀ i, MeasurableSet (f i)) (n) :
     MeasurableSet (disjointed f n) :=
   disjointedRec (fun _ _ ht => MeasurableSet.diff ht <| h _) (h n)
@@ -284,9 +284,11 @@ section MeasurableSingletonClass
 
 variable [MeasurableSpace α] [MeasurableSingletonClass α]
 
+@[measurability]
 theorem measurableSet_eq {a : α} : MeasurableSet { x | x = a } := .singleton a
 #align measurable_set_eq measurableSet_eq
 
+@[measurability]
 protected theorem MeasurableSet.insert {s : Set α} (hs : MeasurableSet s) (a : α) :
     MeasurableSet (insert a s) :=
   .union (.singleton a) hs
@@ -308,6 +310,7 @@ theorem Set.Finite.measurableSet {s : Set α} (hs : s.Finite) : MeasurableSet s
   Finite.induction_on hs MeasurableSet.empty fun _ _ hsm => hsm.insert _
 #align set.finite.measurable_set Set.Finite.measurableSet
 
+@[measurability]
 protected theorem Finset.measurableSet (s : Finset α) : MeasurableSet (↑s : Set α) :=
   s.finite_toSet.measurableSet
 #align finset.measurable_set Finset.measurableSet
@@ -470,7 +473,7 @@ theorem measurableSet_bot_iff {s : Set α} : MeasurableSet[⊥] s ↔ s = ∅ 
   this ▸ Iff.rfl
 #align measurable_space.measurable_set_bot_iff MeasurableSpace.measurableSet_bot_iff
 
-@[simp] theorem measurableSet_top {s : Set α} : MeasurableSet[⊤] s := trivial
+@[simp, measurability] theorem measurableSet_top {s : Set α} : MeasurableSet[⊤] s := trivial
 #align measurable_space.measurable_set_top MeasurableSpace.measurableSet_top
 
 @[simp, nolint simpNF] -- porting note: todo: `simpNF` claims that this lemma doesn't simplify LHS
@@ -539,9 +542,11 @@ end MeasureTheory
 
 section MeasurableFunctions
 
+@[measurability]
 theorem measurable_id {_ : MeasurableSpace α} : Measurable (@id α) := fun _ => id
 #align measurable_id measurable_id
 
+@[measurability]
 theorem measurable_id' {_ : MeasurableSpace α} : Measurable fun a : α => a := measurable_id
 #align measurable_id' measurable_id'
 
@@ -551,7 +556,13 @@ protected theorem Measurable.comp {_ : MeasurableSpace α} {_ : MeasurableSpace
   fun _ h => hf (hg h)
 #align measurable.comp Measurable.comp
 
-@[simp]
+-- This is needed due to reducibility issues with the `measurability` tactic.
+@[measurability]
+protected theorem Measurable.comp' {_ : MeasurableSpace α} {_ : MeasurableSpace β}
+    {_ : MeasurableSpace γ} {g : β → γ} {f : α → β} (hg : Measurable g) (hf : Measurable f) :
+    Measurable (fun x => g (f x)) := Measurable.comp hg hf
+
+@[simp, measurability]
 theorem measurable_const {_ : MeasurableSpace α} {_ : MeasurableSpace β} {a : α} :
     Measurable fun _ : β => a := fun s _ => .const (a ∈ s)
 #align measurable_const measurable_const

Restore most of the mono attribute now that #1740 is merged.

I think I got all of the monos.

@@ -425,7 +425,7 @@ instance : CompleteLattice (MeasurableSpace α) :=
 
 instance : Inhabited (MeasurableSpace α) := ⟨⊤⟩
 
--- porting note: todo: restore @[mono]
+@[mono]
 theorem generateFrom_mono {s t : Set (Set α)} (h : s ⊆ t) : generateFrom s ≤ generateFrom t :=
   giGenerateFrom.gc.monotone_l h
 #align measurable_space.generate_from_mono MeasurableSpace.generateFrom_mono