data.set.Union_lift ⟷ Mathlib.Data.Set.UnionLift

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

@@ -3,8 +3,8 @@ Copyright (c) 2021 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
 -/
-import Mathbin.Data.Set.Lattice
-import Mathbin.Order.Directed
+import Data.Set.Lattice
+import Order.Directed
 
 #align_import data.set.Union_lift from "leanprover-community/mathlib"@"5a4ea8453f128345f73cc656e80a49de2a54f481"
 

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

@@ -2,15 +2,12 @@
 Copyright (c) 2021 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
-
-! This file was ported from Lean 3 source module data.set.Union_lift
-! leanprover-community/mathlib commit 5a4ea8453f128345f73cc656e80a49de2a54f481
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Set.Lattice
 import Mathbin.Order.Directed
 
+#align_import data.set.Union_lift from "leanprover-community/mathlib"@"5a4ea8453f128345f73cc656e80a49de2a54f481"
+
 /-!
 # Union lift
 

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

@@ -70,6 +70,7 @@ variable {S : ι → Set α} {f : ∀ (i) (x : S i), β}
   {hf : ∀ (i j) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩} {T : Set α}
   {hT : T ⊆ iUnion S} (hT' : T = iUnion S)
 
+#print Set.iUnionLift_mk /-
 @[simp]
 theorem iUnionLift_mk {i : ι} (x : S i) (hx : (x : α) ∈ T) :
     iUnionLift S f hf T hT ⟨x, hx⟩ = f i x :=
@@ -77,17 +78,23 @@ theorem iUnionLift_mk {i : ι} (x : S i) (hx : (x : α) ∈ T) :
   let j := Classical.indefiniteDescription _ (mem_iUnion.1 (hT hx))
   cases' x with x hx <;> exact hf j i x j.2 _
 #align set.Union_lift_mk Set.iUnionLift_mk
+-/
 
+#print Set.iUnionLift_inclusion /-
 @[simp]
 theorem iUnionLift_inclusion {i : ι} (x : S i) (h : S i ⊆ T) :
     iUnionLift S f hf T hT (Set.inclusion h x) = f i x :=
   iUnionLift_mk x _
 #align set.Union_lift_inclusion Set.iUnionLift_inclusion
+-/
 
+#print Set.iUnionLift_of_mem /-
 theorem iUnionLift_of_mem (x : T) {i : ι} (hx : (x : α) ∈ S i) :
     iUnionLift S f hf T hT x = f i ⟨x, hx⟩ := by cases' x with x hx <;> exact hf _ _ _ _ _
 #align set.Union_lift_of_mem Set.iUnionLift_of_mem
+-/
 
+#print Set.iUnionLift_const /-
 /-- `Union_lift_const` is useful for proving that `Union_lift` is a homomorphism
   of algebraic structures when defined on the Union of algebraic subobjects.
   For example, it could be used to prove that the lift of a collection
@@ -99,7 +106,9 @@ theorem iUnionLift_const (c : T) (ci : ∀ i, S i) (hci : ∀ i, (ci i : α) = c
   have : ci i = ⟨c, hi⟩ := Subtype.ext (hci i)
   rw [Union_lift_of_mem _ hi, ← this, h]
 #align set.Union_lift_const Set.iUnionLift_const
+-/
 
+#print Set.iUnionLift_unary /-
 /-- `Union_lift_unary` is useful for proving that `Union_lift` is a homomorphism
   of algebraic structures when defined on the Union of algebraic subobjects.
   For example, it could be used to prove that the lift of a collection
@@ -119,7 +128,9 @@ theorem iUnionLift_unary (u : T → T) (ui : ∀ i, S i → S i)
   have hx' : (Set.inclusion (Set.subset_iUnion S i) (ui i ⟨x, hi⟩) : α) ∈ S i := (ui i ⟨x, hi⟩).Prop
   conv_lhs => rw [this, hui, Union_lift_inclusion]
 #align set.Union_lift_unary Set.iUnionLift_unary
+-/
 
+#print Set.iUnionLift_binary /-
 /-- `Union_lift_binary` is useful for proving that `Union_lift` is a homomorphism
   of algebraic structures when defined on the Union of algebraic subobjects.
   For example, it could be used to prove that the lift of a collection
@@ -146,6 +157,7 @@ theorem iUnionLift_binary (dir : Directed (· ≤ ·) S) (op : T → T → T) (o
   conv_lhs => rw [hx, hy, ← hopi, Union_lift_of_mem _ hxy]
   simp only [coe_inclusion, Subtype.coe_eta]
 #align set.Union_lift_binary Set.iUnionLift_binary
+-/
 
 end UnionLift
 
@@ -163,15 +175,19 @@ noncomputable def liftCover (S : ι → Set α) (f : ∀ (i) (x : S i), β)
 #align set.lift_cover Set.liftCover
 -/
 
+#print Set.liftCover_coe /-
 @[simp]
 theorem liftCover_coe {i : ι} (x : S i) : liftCover S f hf hS x = f i x :=
   iUnionLift_mk x _
 #align set.lift_cover_coe Set.liftCover_coe
+-/
 
+#print Set.liftCover_of_mem /-
 theorem liftCover_of_mem {i : ι} {x : α} (hx : (x : α) ∈ S i) :
     liftCover S f hf hS x = f i ⟨x, hx⟩ :=
   iUnionLift_of_mem ⟨x, trivial⟩ hx
 #align set.lift_cover_of_mem Set.liftCover_of_mem
+-/
 
 end Set
 

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

@@ -70,12 +70,6 @@ variable {S : ι → Set α} {f : ∀ (i) (x : S i), β}
   {hf : ∀ (i j) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩} {T : Set α}
   {hT : T ⊆ iUnion S} (hT' : T = iUnion S)
 
-/- warning: set.Union_lift_mk -> Set.iUnionLift_mk is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, u2} α ι S)} {i : ι} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (hx : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) x) T), Eq.{u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) x) hx)) (f i x)
-but is expected to have type
-  forall {α : Type.{u3}} {ι : Sort.{u1}} {β : Sort.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, u1} α ι S)} {i : ι} (x : Set.Elem.{u3} α (S i)) (hx : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x) T), Eq.{u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x) hx)) (f i x)
-Case conversion may be inaccurate. Consider using '#align set.Union_lift_mk Set.iUnionLift_mkₓ'. -/
 @[simp]
 theorem iUnionLift_mk {i : ι} (x : S i) (hx : (x : α) ∈ T) :
     iUnionLift S f hf T hT ⟨x, hx⟩ = f i x :=
@@ -84,34 +78,16 @@ theorem iUnionLift_mk {i : ι} (x : S i) (hx : (x : α) ∈ T) :
   cases' x with x hx <;> exact hf j i x j.2 _
 #align set.Union_lift_mk Set.iUnionLift_mk
 
-/- warning: set.Union_lift_inclusion -> Set.iUnionLift_inclusion is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, u2} α ι S)} {i : ι} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (h : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T), Eq.{u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT (Set.inclusion.{u1} α (S i) T h x)) (f i x)
-but is expected to have type
-  forall {α : Type.{u3}} {ι : Sort.{u1}} {β : Sort.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, u1} α ι S)} {i : ι} (x : Set.Elem.{u3} α (S i)) (h : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S i) T), Eq.{u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT (Set.inclusion.{u3} α (S i) T h x)) (f i x)
-Case conversion may be inaccurate. Consider using '#align set.Union_lift_inclusion Set.iUnionLift_inclusionₓ'. -/
 @[simp]
 theorem iUnionLift_inclusion {i : ι} (x : S i) (h : S i ⊆ T) :
     iUnionLift S f hf T hT (Set.inclusion h x) = f i x :=
   iUnionLift_mk x _
 #align set.Union_lift_inclusion Set.iUnionLift_inclusion
 
-/- warning: set.Union_lift_of_mem -> Set.iUnionLift_of_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, u2} α ι S)} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) {i : ι} (hx : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T))))) x) (S i)), Eq.{u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT x) (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T))))) x) hx))
-but is expected to have type
-  forall {α : Type.{u3}} {ι : Sort.{u1}} {β : Sort.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, u1} α ι S)} (x : Set.Elem.{u3} α T) {i : ι} (hx : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) x) (S i)), Eq.{u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT x) (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) x) hx))
-Case conversion may be inaccurate. Consider using '#align set.Union_lift_of_mem Set.iUnionLift_of_memₓ'. -/
 theorem iUnionLift_of_mem (x : T) {i : ι} (hx : (x : α) ∈ S i) :
     iUnionLift S f hf T hT x = f i ⟨x, hx⟩ := by cases' x with x hx <;> exact hf _ _ _ _ _
 #align set.Union_lift_of_mem Set.iUnionLift_of_mem
 
-/- warning: set.Union_lift_const -> Set.iUnionLift_const is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, u2} α ι S)} (c : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (ci : forall (i : ι), coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), (forall (i : ι), Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) (ci i)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T))))) c)) -> (forall (cβ : β), (forall (i : ι), Eq.{u3} β (f i (ci i)) cβ) -> (Eq.{u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT c) cβ))
-but is expected to have type
-  forall {α : Type.{u3}} {ι : Sort.{u1}} {β : Sort.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, u1} α ι S)} (c : Set.Elem.{u3} α T) (ci : forall (i : ι), Set.Elem.{u3} α (S i)), (forall (i : ι), Eq.{succ u3} α (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (ci i)) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) c)) -> (forall (cβ : β), (forall (i : ι), Eq.{u2} β (f i (ci i)) cβ) -> (Eq.{u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT c) cβ))
-Case conversion may be inaccurate. Consider using '#align set.Union_lift_const Set.iUnionLift_constₓ'. -/
 /-- `Union_lift_const` is useful for proving that `Union_lift` is a homomorphism
   of algebraic structures when defined on the Union of algebraic subobjects.
   For example, it could be used to prove that the lift of a collection
@@ -124,9 +100,6 @@ theorem iUnionLift_const (c : T) (ci : ∀ i, S i) (hci : ∀ i, (ci i : α) = c
   rw [Union_lift_of_mem _ hi, ← this, h]
 #align set.Union_lift_const Set.iUnionLift_const
 
-/- warning: set.Union_lift_unary -> Set.iUnionLift_unary is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align set.Union_lift_unary Set.iUnionLift_unaryₓ'. -/
 /-- `Union_lift_unary` is useful for proving that `Union_lift` is a homomorphism
   of algebraic structures when defined on the Union of algebraic subobjects.
   For example, it could be used to prove that the lift of a collection
@@ -147,9 +120,6 @@ theorem iUnionLift_unary (u : T → T) (ui : ∀ i, S i → S i)
   conv_lhs => rw [this, hui, Union_lift_inclusion]
 #align set.Union_lift_unary Set.iUnionLift_unary
 
-/- warning: set.Union_lift_binary -> Set.iUnionLift_binary is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align set.Union_lift_binary Set.iUnionLift_binaryₓ'. -/
 /-- `Union_lift_binary` is useful for proving that `Union_lift` is a homomorphism
   of algebraic structures when defined on the Union of algebraic subobjects.
   For example, it could be used to prove that the lift of a collection
@@ -193,23 +163,11 @@ noncomputable def liftCover (S : ι → Set α) (f : ∀ (i) (x : S i), β)
 #align set.lift_cover Set.liftCover
 -/
 
-/- warning: set.lift_cover_coe -> Set.liftCover_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {hS : Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, u2} α ι S) (Set.univ.{u1} α)} {i : ι} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{u3} β (Set.liftCover.{u1, u2, u3} α ι β S f hf hS ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) x)) (f i x)
-but is expected to have type
-  forall {α : Type.{u3}} {ι : Sort.{u1}} {β : Sort.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {hS : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, u1} α ι S) (Set.univ.{u3} α)} {i : ι} (x : Set.Elem.{u3} α (S i)), Eq.{u2} β (Set.liftCover.{u3, u1, u2} α ι β S f hf hS (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x)) (f i x)
-Case conversion may be inaccurate. Consider using '#align set.lift_cover_coe Set.liftCover_coeₓ'. -/
 @[simp]
 theorem liftCover_coe {i : ι} (x : S i) : liftCover S f hf hS x = f i x :=
   iUnionLift_mk x _
 #align set.lift_cover_coe Set.liftCover_coe
 
-/- warning: set.lift_cover_of_mem -> Set.liftCover_of_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {hS : Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, u2} α ι S) (Set.univ.{u1} α)} {i : ι} {x : α} (hx : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)), Eq.{u3} β (Set.liftCover.{u1, u2, u3} α ι β S f hf hS x) (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hx))
-but is expected to have type
-  forall {α : Type.{u3}} {ι : Sort.{u1}} {β : Sort.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {hS : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, u1} α ι S) (Set.univ.{u3} α)} {i : ι} {x : α} (hx : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)), Eq.{u2} β (Set.liftCover.{u3, u1, u2} α ι β S f hf hS x) (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hx))
-Case conversion may be inaccurate. Consider using '#align set.lift_cover_of_mem Set.liftCover_of_memₓ'. -/
 theorem liftCover_of_mem {i : ι} {x : α} (hx : (x : α) ∈ S i) :
     liftCover S f hf hS x = f i ⟨x, hx⟩ :=
   iUnionLift_of_mem ⟨x, trivial⟩ hx

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

@@ -142,10 +142,7 @@ theorem iUnionLift_unary (u : T → T) (ui : ∀ i, S i → S i)
   subst hT'
   cases' Set.mem_iUnion.1 x.prop with i hi
   rw [Union_lift_of_mem x hi, ← h i]
-  have : x = Set.inclusion (Set.subset_iUnion S i) ⟨x, hi⟩ :=
-    by
-    cases x
-    rfl
+  have : x = Set.inclusion (Set.subset_iUnion S i) ⟨x, hi⟩ := by cases x; rfl
   have hx' : (Set.inclusion (Set.subset_iUnion S i) (ui i ⟨x, hi⟩) : α) ∈ S i := (ui i ⟨x, hi⟩).Prop
   conv_lhs => rw [this, hui, Union_lift_inclusion]
 #align set.Union_lift_unary Set.iUnionLift_unary
@@ -172,14 +169,8 @@ theorem iUnionLift_binary (dir : Directed (· ≤ ·) S) (op : T → T → T) (o
   cases' Set.mem_iUnion.1 y.prop with j hj
   rcases dir i j with ⟨k, hik, hjk⟩
   rw [Union_lift_of_mem x (hik hi), Union_lift_of_mem y (hjk hj), ← h k]
-  have hx : x = Set.inclusion (Set.subset_iUnion S k) ⟨x, hik hi⟩ :=
-    by
-    cases x
-    rfl
-  have hy : y = Set.inclusion (Set.subset_iUnion S k) ⟨y, hjk hj⟩ :=
-    by
-    cases y
-    rfl
+  have hx : x = Set.inclusion (Set.subset_iUnion S k) ⟨x, hik hi⟩ := by cases x; rfl
+  have hy : y = Set.inclusion (Set.subset_iUnion S k) ⟨y, hjk hj⟩ := by cases y; rfl
   have hxy : (Set.inclusion (Set.subset_iUnion S k) (opi k ⟨x, hik hi⟩ ⟨y, hjk hj⟩) : α) ∈ S k :=
     (opi k ⟨x, hik hi⟩ ⟨y, hjk hj⟩).Prop
   conv_lhs => rw [hx, hy, ← hopi, Union_lift_of_mem _ hxy]

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

@@ -125,10 +125,7 @@ theorem iUnionLift_const (c : T) (ci : ∀ i, S i) (hci : ∀ i, (ci i : α) = c
 #align set.Union_lift_const Set.iUnionLift_const
 
 /- warning: set.Union_lift_unary -> Set.iUnionLift_unary is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} (hT' : Eq.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S)) (u : (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T)) (ui : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i))), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (u (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S) hT') (Set.subset_iUnion.{u1, u2} α ι S i))) x)) (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S) hT') (Set.subset_iUnion.{u1, u2} α ι S i))) (ui i x))) -> (forall (uβ : β -> β), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{u3} β (f i (ui i x)) (uβ (f i x))) -> (forall (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T), Eq.{u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, u2} α ι S) hT') (u x)) (uβ (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, u2} α ι S) hT') x))))
-but is expected to have type
-  forall {α : Type.{u3}} {ι : Sort.{u2}} {β : Sort.{u1}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{u1} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT' : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, u2} α ι S)} (u : Eq.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, u2} α ι S)) (ui : (Set.Elem.{u3} α T) -> (Set.Elem.{u3} α T)) (hui : forall (i : ι), (Set.Elem.{u3} α (S i)) -> (Set.Elem.{u3} α (S i))), (forall (ᾰ : ι) (x : Set.Elem.{u3} α (S ᾰ)), Eq.{succ u3} (Set.Elem.{u3} α T) (ui (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.995 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.996 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.995) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.995) (Set.subset_iUnion.{u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, u2} α ι S) u))]) x)) (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1019 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1020 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1019) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1019) (Set.subset_iUnion.{u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, u2} α ι S) u))]) (hui ᾰ x))) -> (forall (h : β -> β), (forall (i : ι) (x : Set.Elem.{u3} α (S i)), Eq.{u1} β (f i (hui i x)) (h (f i x))) -> (forall (x : Set.Elem.{u3} α T), Eq.{u1} β (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, u2} α ι S) u) (ui x)) (h (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, u2} α ι S) u) x))))
+<too large>
 Case conversion may be inaccurate. Consider using '#align set.Union_lift_unary Set.iUnionLift_unaryₓ'. -/
 /-- `Union_lift_unary` is useful for proving that `Union_lift` is a homomorphism
   of algebraic structures when defined on the Union of algebraic subobjects.
@@ -154,10 +151,7 @@ theorem iUnionLift_unary (u : T → T) (ui : ∀ i, S i → S i)
 #align set.Union_lift_unary Set.iUnionLift_unary
 
 /- warning: set.Union_lift_binary -> Set.iUnionLift_binary is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} (hT' : Eq.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S)), (Directed.{u1, u2} (Set.{u1} α) ι (LE.le.{u1} (Set.{u1} α) (Set.hasLe.{u1} α)) S) -> (forall (op : (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T)) (opi : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i))), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (y : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S) hT') (Set.subset_iUnion.{u1, u2} α ι S i))) (opi i x y)) (op (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S) hT') (Set.subset_iUnion.{u1, u2} α ι S i))) x) (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S) hT') (Set.subset_iUnion.{u1, u2} α ι S i))) y))) -> (forall (opβ : β -> β -> β), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (y : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{u3} β (f i (opi i x y)) (opβ (f i x) (f i y))) -> (forall (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (y : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T), Eq.{u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, u2} α ι S) hT') (op x y)) (opβ (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, u2} α ι S) hT') x) (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, u2} α ι S) hT') y)))))
-but is expected to have type
-  forall {α : Type.{u3}} {ι : Sort.{u2}} {β : Sort.{u1}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{u1} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT' : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, u2} α ι S)} (dir : Eq.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, u2} α ι S)), (Directed.{u3, u2} (Set.{u3} α) ι (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1261 : Set.{u3} α) (x._@.Mathlib.Data.Set.UnionLift._hyg.1263 : Set.{u3} α) => LE.le.{u3} (Set.{u3} α) (Set.instLESet.{u3} α) x._@.Mathlib.Data.Set.UnionLift._hyg.1261 x._@.Mathlib.Data.Set.UnionLift._hyg.1263) S) -> (forall (opi : (Set.Elem.{u3} α T) -> (Set.Elem.{u3} α T) -> (Set.Elem.{u3} α T)) (hopi : forall (i : ι), (Set.Elem.{u3} α (S i)) -> (Set.Elem.{u3} α (S i)) -> (Set.Elem.{u3} α (S i))), (forall (ᾰ : ι) (ᾰ_1 : Set.Elem.{u3} α (S ᾰ)) (y : Set.Elem.{u3} α (S ᾰ)), Eq.{succ u3} (Set.Elem.{u3} α T) (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1318 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1319 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1318) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1318) (Set.subset_iUnion.{u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, u2} α ι S) dir))]) (hopi ᾰ ᾰ_1 y)) (opi (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1350 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1351 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1350) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1350) (Set.subset_iUnion.{u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, u2} α ι S) dir))]) ᾰ_1) (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1376 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1377 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1376) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1376) (Set.subset_iUnion.{u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, u2} α ι S) dir))]) y))) -> (forall (h : β -> β -> β), (forall (i : ι) (x : Set.Elem.{u3} α (S i)) (y : Set.Elem.{u3} α (S i)), Eq.{u1} β (f i (hopi i x y)) (h (f i x) (f i y))) -> (forall (y : Set.Elem.{u3} α T) (y_1 : Set.Elem.{u3} α T), Eq.{u1} β (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, u2} α ι S) dir) (opi y y_1)) (h (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, u2} α ι S) dir) y) (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, u2} α ι S) dir) y_1)))))
+<too large>
 Case conversion may be inaccurate. Consider using '#align set.Union_lift_binary Set.iUnionLift_binaryₓ'. -/
 /-- `Union_lift_binary` is useful for proving that `Union_lift` is a homomorphism
   of algebraic structures when defined on the Union of algebraic subobjects.

mathlib commit https://github.com/leanprover-community/mathlib/commit/95a87616d63b3cb49d3fe678d416fbe9c4217bf4

@@ -51,12 +51,7 @@ namespace Set
 
 section UnionLift
 
-/- warning: set.Union_lift -> Set.iUnionLift is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} (S : ι -> (Set.{u1} α)) (f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β), (forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))) -> (forall (T : Set.{u1} α), (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, u2} α ι S)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> β)
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} (S : ι -> (Set.{u1} α)) (f : forall (i : ι), (Set.Elem.{u1} α (S i)) -> β), (forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (S i)) (hxj : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (S j)) x hxj))) -> (forall (T : Set.{u1} α), (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S)) -> (Set.Elem.{u1} α T) -> β)
-Case conversion may be inaccurate. Consider using '#align set.Union_lift Set.iUnionLiftₓ'. -/
+#print Set.iUnionLift /-
 /- The unused argument `hf` is left in the definition so that the `simp` lemmas
 `Union_lift_inclusion` will work without the user having to provide `hf` explicitly to
 simplify terms involving `Union_lift`. -/
@@ -69,6 +64,7 @@ noncomputable def iUnionLift (S : ι → Set α) (f : ∀ (i) (x : S i), β)
   let i := Classical.indefiniteDescription _ (mem_iUnion.1 (hT x.Prop))
   f i ⟨x, i.Prop⟩
 #align set.Union_lift Set.iUnionLift
+-/
 
 variable {S : ι → Set α} {f : ∀ (i) (x : S i), β}
   {hf : ∀ (i j) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩} {T : Set α}
@@ -78,7 +74,7 @@ variable {S : ι → Set α} {f : ∀ (i) (x : S i), β}
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, u2} α ι S)} {i : ι} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (hx : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) x) T), Eq.{u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) x) hx)) (f i x)
 but is expected to have type
-  forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, succ u1} α ι S)} {i : ι} (x : Set.Elem.{u3} α (S i)) (hx : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x) T), Eq.{succ u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x) hx)) (f i x)
+  forall {α : Type.{u3}} {ι : Sort.{u1}} {β : Sort.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, u1} α ι S)} {i : ι} (x : Set.Elem.{u3} α (S i)) (hx : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x) T), Eq.{u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x) hx)) (f i x)
 Case conversion may be inaccurate. Consider using '#align set.Union_lift_mk Set.iUnionLift_mkₓ'. -/
 @[simp]
 theorem iUnionLift_mk {i : ι} (x : S i) (hx : (x : α) ∈ T) :
@@ -92,7 +88,7 @@ theorem iUnionLift_mk {i : ι} (x : S i) (hx : (x : α) ∈ T) :
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, u2} α ι S)} {i : ι} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (h : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T), Eq.{u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT (Set.inclusion.{u1} α (S i) T h x)) (f i x)
 but is expected to have type
-  forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, succ u1} α ι S)} {i : ι} (x : Set.Elem.{u3} α (S i)) (h : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S i) T), Eq.{succ u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT (Set.inclusion.{u3} α (S i) T h x)) (f i x)
+  forall {α : Type.{u3}} {ι : Sort.{u1}} {β : Sort.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, u1} α ι S)} {i : ι} (x : Set.Elem.{u3} α (S i)) (h : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S i) T), Eq.{u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT (Set.inclusion.{u3} α (S i) T h x)) (f i x)
 Case conversion may be inaccurate. Consider using '#align set.Union_lift_inclusion Set.iUnionLift_inclusionₓ'. -/
 @[simp]
 theorem iUnionLift_inclusion {i : ι} (x : S i) (h : S i ⊆ T) :
@@ -104,7 +100,7 @@ theorem iUnionLift_inclusion {i : ι} (x : S i) (h : S i ⊆ T) :
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, u2} α ι S)} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) {i : ι} (hx : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T))))) x) (S i)), Eq.{u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT x) (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T))))) x) hx))
 but is expected to have type
-  forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, succ u1} α ι S)} (x : Set.Elem.{u3} α T) {i : ι} (hx : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) x) (S i)), Eq.{succ u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT x) (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) x) hx))
+  forall {α : Type.{u3}} {ι : Sort.{u1}} {β : Sort.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, u1} α ι S)} (x : Set.Elem.{u3} α T) {i : ι} (hx : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) x) (S i)), Eq.{u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT x) (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) x) hx))
 Case conversion may be inaccurate. Consider using '#align set.Union_lift_of_mem Set.iUnionLift_of_memₓ'. -/
 theorem iUnionLift_of_mem (x : T) {i : ι} (hx : (x : α) ∈ S i) :
     iUnionLift S f hf T hT x = f i ⟨x, hx⟩ := by cases' x with x hx <;> exact hf _ _ _ _ _
@@ -114,7 +110,7 @@ theorem iUnionLift_of_mem (x : T) {i : ι} (hx : (x : α) ∈ S i) :
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, u2} α ι S)} (c : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (ci : forall (i : ι), coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), (forall (i : ι), Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) (ci i)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T))))) c)) -> (forall (cβ : β), (forall (i : ι), Eq.{u3} β (f i (ci i)) cβ) -> (Eq.{u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT c) cβ))
 but is expected to have type
-  forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, succ u1} α ι S)} (c : Set.Elem.{u3} α T) (ci : forall (i : ι), Set.Elem.{u3} α (S i)), (forall (i : ι), Eq.{succ u3} α (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (ci i)) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) c)) -> (forall (cβ : β), (forall (i : ι), Eq.{succ u2} β (f i (ci i)) cβ) -> (Eq.{succ u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT c) cβ))
+  forall {α : Type.{u3}} {ι : Sort.{u1}} {β : Sort.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, u1} α ι S)} (c : Set.Elem.{u3} α T) (ci : forall (i : ι), Set.Elem.{u3} α (S i)), (forall (i : ι), Eq.{succ u3} α (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (ci i)) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) c)) -> (forall (cβ : β), (forall (i : ι), Eq.{u2} β (f i (ci i)) cβ) -> (Eq.{u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT c) cβ))
 Case conversion may be inaccurate. Consider using '#align set.Union_lift_const Set.iUnionLift_constₓ'. -/
 /-- `Union_lift_const` is useful for proving that `Union_lift` is a homomorphism
   of algebraic structures when defined on the Union of algebraic subobjects.
@@ -132,7 +128,7 @@ theorem iUnionLift_const (c : T) (ci : ∀ i, S i) (hci : ∀ i, (ci i : α) = c
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} (hT' : Eq.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S)) (u : (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T)) (ui : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i))), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (u (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S) hT') (Set.subset_iUnion.{u1, u2} α ι S i))) x)) (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S) hT') (Set.subset_iUnion.{u1, u2} α ι S i))) (ui i x))) -> (forall (uβ : β -> β), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{u3} β (f i (ui i x)) (uβ (f i x))) -> (forall (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T), Eq.{u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, u2} α ι S) hT') (u x)) (uβ (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, u2} α ι S) hT') x))))
 but is expected to have type
-  forall {α : Type.{u3}} {ι : Type.{u2}} {β : Type.{u1}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u1} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT' : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S)} (u : Eq.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S)) (ui : (Set.Elem.{u3} α T) -> (Set.Elem.{u3} α T)) (hui : forall (i : ι), (Set.Elem.{u3} α (S i)) -> (Set.Elem.{u3} α (S i))), (forall (ᾰ : ι) (x : Set.Elem.{u3} α (S ᾰ)), Eq.{succ u3} (Set.Elem.{u3} α T) (ui (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.995 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.996 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.995) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.995) (Set.subset_iUnion.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S) u))]) x)) (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1019 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1020 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1019) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1019) (Set.subset_iUnion.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S) u))]) (hui ᾰ x))) -> (forall (h : β -> β), (forall (i : ι) (x : Set.Elem.{u3} α (S i)), Eq.{succ u1} β (f i (hui i x)) (h (f i x))) -> (forall (x : Set.Elem.{u3} α T), Eq.{succ u1} β (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, succ u2} α ι S) u) (ui x)) (h (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, succ u2} α ι S) u) x))))
+  forall {α : Type.{u3}} {ι : Sort.{u2}} {β : Sort.{u1}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{u1} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT' : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, u2} α ι S)} (u : Eq.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, u2} α ι S)) (ui : (Set.Elem.{u3} α T) -> (Set.Elem.{u3} α T)) (hui : forall (i : ι), (Set.Elem.{u3} α (S i)) -> (Set.Elem.{u3} α (S i))), (forall (ᾰ : ι) (x : Set.Elem.{u3} α (S ᾰ)), Eq.{succ u3} (Set.Elem.{u3} α T) (ui (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.995 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.996 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.995) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.995) (Set.subset_iUnion.{u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, u2} α ι S) u))]) x)) (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1019 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1020 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1019) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1019) (Set.subset_iUnion.{u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, u2} α ι S) u))]) (hui ᾰ x))) -> (forall (h : β -> β), (forall (i : ι) (x : Set.Elem.{u3} α (S i)), Eq.{u1} β (f i (hui i x)) (h (f i x))) -> (forall (x : Set.Elem.{u3} α T), Eq.{u1} β (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, u2} α ι S) u) (ui x)) (h (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, u2} α ι S) u) x))))
 Case conversion may be inaccurate. Consider using '#align set.Union_lift_unary Set.iUnionLift_unaryₓ'. -/
 /-- `Union_lift_unary` is useful for proving that `Union_lift` is a homomorphism
   of algebraic structures when defined on the Union of algebraic subobjects.
@@ -161,7 +157,7 @@ theorem iUnionLift_unary (u : T → T) (ui : ∀ i, S i → S i)
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} (hT' : Eq.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S)), (Directed.{u1, u2} (Set.{u1} α) ι (LE.le.{u1} (Set.{u1} α) (Set.hasLe.{u1} α)) S) -> (forall (op : (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T)) (opi : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i))), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (y : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S) hT') (Set.subset_iUnion.{u1, u2} α ι S i))) (opi i x y)) (op (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S) hT') (Set.subset_iUnion.{u1, u2} α ι S i))) x) (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S) hT') (Set.subset_iUnion.{u1, u2} α ι S i))) y))) -> (forall (opβ : β -> β -> β), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (y : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{u3} β (f i (opi i x y)) (opβ (f i x) (f i y))) -> (forall (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (y : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T), Eq.{u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, u2} α ι S) hT') (op x y)) (opβ (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, u2} α ι S) hT') x) (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, u2} α ι S) hT') y)))))
 but is expected to have type
-  forall {α : Type.{u3}} {ι : Type.{u2}} {β : Type.{u1}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u1} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT' : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S)} (dir : Eq.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S)), (Directed.{u3, succ u2} (Set.{u3} α) ι (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1261 : Set.{u3} α) (x._@.Mathlib.Data.Set.UnionLift._hyg.1263 : Set.{u3} α) => LE.le.{u3} (Set.{u3} α) (Set.instLESet.{u3} α) x._@.Mathlib.Data.Set.UnionLift._hyg.1261 x._@.Mathlib.Data.Set.UnionLift._hyg.1263) S) -> (forall (opi : (Set.Elem.{u3} α T) -> (Set.Elem.{u3} α T) -> (Set.Elem.{u3} α T)) (hopi : forall (i : ι), (Set.Elem.{u3} α (S i)) -> (Set.Elem.{u3} α (S i)) -> (Set.Elem.{u3} α (S i))), (forall (ᾰ : ι) (ᾰ_1 : Set.Elem.{u3} α (S ᾰ)) (y : Set.Elem.{u3} α (S ᾰ)), Eq.{succ u3} (Set.Elem.{u3} α T) (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1318 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1319 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1318) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1318) (Set.subset_iUnion.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S) dir))]) (hopi ᾰ ᾰ_1 y)) (opi (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1350 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1351 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1350) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1350) (Set.subset_iUnion.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S) dir))]) ᾰ_1) (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1376 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1377 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1376) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1376) (Set.subset_iUnion.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S) dir))]) y))) -> (forall (h : β -> β -> β), (forall (i : ι) (x : Set.Elem.{u3} α (S i)) (y : Set.Elem.{u3} α (S i)), Eq.{succ u1} β (f i (hopi i x y)) (h (f i x) (f i y))) -> (forall (y : Set.Elem.{u3} α T) (y_1 : Set.Elem.{u3} α T), Eq.{succ u1} β (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, succ u2} α ι S) dir) (opi y y_1)) (h (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, succ u2} α ι S) dir) y) (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, succ u2} α ι S) dir) y_1)))))
+  forall {α : Type.{u3}} {ι : Sort.{u2}} {β : Sort.{u1}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{u1} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT' : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, u2} α ι S)} (dir : Eq.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, u2} α ι S)), (Directed.{u3, u2} (Set.{u3} α) ι (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1261 : Set.{u3} α) (x._@.Mathlib.Data.Set.UnionLift._hyg.1263 : Set.{u3} α) => LE.le.{u3} (Set.{u3} α) (Set.instLESet.{u3} α) x._@.Mathlib.Data.Set.UnionLift._hyg.1261 x._@.Mathlib.Data.Set.UnionLift._hyg.1263) S) -> (forall (opi : (Set.Elem.{u3} α T) -> (Set.Elem.{u3} α T) -> (Set.Elem.{u3} α T)) (hopi : forall (i : ι), (Set.Elem.{u3} α (S i)) -> (Set.Elem.{u3} α (S i)) -> (Set.Elem.{u3} α (S i))), (forall (ᾰ : ι) (ᾰ_1 : Set.Elem.{u3} α (S ᾰ)) (y : Set.Elem.{u3} α (S ᾰ)), Eq.{succ u3} (Set.Elem.{u3} α T) (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1318 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1319 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1318) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1318) (Set.subset_iUnion.{u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, u2} α ι S) dir))]) (hopi ᾰ ᾰ_1 y)) (opi (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1350 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1351 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1350) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1350) (Set.subset_iUnion.{u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, u2} α ι S) dir))]) ᾰ_1) (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1376 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1377 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1376) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1376) (Set.subset_iUnion.{u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, u2} α ι S) dir))]) y))) -> (forall (h : β -> β -> β), (forall (i : ι) (x : Set.Elem.{u3} α (S i)) (y : Set.Elem.{u3} α (S i)), Eq.{u1} β (f i (hopi i x y)) (h (f i x) (f i y))) -> (forall (y : Set.Elem.{u3} α T) (y_1 : Set.Elem.{u3} α T), Eq.{u1} β (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, u2} α ι S) dir) (opi y y_1)) (h (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, u2} α ι S) dir) y) (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, u2} α ι S) dir) y_1)))))
 Case conversion may be inaccurate. Consider using '#align set.Union_lift_binary Set.iUnionLift_binaryₓ'. -/
 /-- `Union_lift_binary` is useful for proving that `Union_lift` is a homomorphism
   of algebraic structures when defined on the Union of algebraic subobjects.
@@ -202,12 +198,7 @@ variable {S : ι → Set α} {f : ∀ (i) (x : S i), β}
   {hf : ∀ (i j) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩}
   {hS : iUnion S = univ}
 
-/- warning: set.lift_cover -> Set.liftCover is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} (S : ι -> (Set.{u1} α)) (f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β), (forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))) -> (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, u2} α ι S) (Set.univ.{u1} α)) -> α -> β
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} (S : ι -> (Set.{u1} α)) (f : forall (i : ι), (Set.Elem.{u1} α (S i)) -> β), (forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (S i)) (hxj : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (S j)) x hxj))) -> (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι S) (Set.univ.{u1} α)) -> α -> β
-Case conversion may be inaccurate. Consider using '#align set.lift_cover Set.liftCoverₓ'. -/
+#print Set.liftCover /-
 /-- Glue together functions defined on each of a collection `S` of sets that cover a type. See
   also `set.Union_lift`.   -/
 noncomputable def liftCover (S : ι → Set α) (f : ∀ (i) (x : S i), β)
@@ -215,12 +206,13 @@ noncomputable def liftCover (S : ι → Set α) (f : ∀ (i) (x : S i), β)
     (hS : iUnion S = univ) (a : α) : β :=
   iUnionLift S f hf univ (hS ▸ Set.Subset.refl _) ⟨a, trivial⟩
 #align set.lift_cover Set.liftCover
+-/
 
 /- warning: set.lift_cover_coe -> Set.liftCover_coe is a dubious translation:
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {hS : Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, u2} α ι S) (Set.univ.{u1} α)} {i : ι} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{u3} β (Set.liftCover.{u1, u2, u3} α ι β S f hf hS ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) x)) (f i x)
 but is expected to have type
-  forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {hS : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u1} α ι S) (Set.univ.{u3} α)} {i : ι} (x : Set.Elem.{u3} α (S i)), Eq.{succ u2} β (Set.liftCover.{u3, u1, u2} α ι β S f hf hS (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x)) (f i x)
+  forall {α : Type.{u3}} {ι : Sort.{u1}} {β : Sort.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {hS : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, u1} α ι S) (Set.univ.{u3} α)} {i : ι} (x : Set.Elem.{u3} α (S i)), Eq.{u2} β (Set.liftCover.{u3, u1, u2} α ι β S f hf hS (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x)) (f i x)
 Case conversion may be inaccurate. Consider using '#align set.lift_cover_coe Set.liftCover_coeₓ'. -/
 @[simp]
 theorem liftCover_coe {i : ι} (x : S i) : liftCover S f hf hS x = f i x :=
@@ -231,7 +223,7 @@ theorem liftCover_coe {i : ι} (x : S i) : liftCover S f hf hS x = f i x :=
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {hS : Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, u2} α ι S) (Set.univ.{u1} α)} {i : ι} {x : α} (hx : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)), Eq.{u3} β (Set.liftCover.{u1, u2, u3} α ι β S f hf hS x) (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hx))
 but is expected to have type
-  forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {hS : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u1} α ι S) (Set.univ.{u3} α)} {i : ι} {x : α} (hx : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)), Eq.{succ u2} β (Set.liftCover.{u3, u1, u2} α ι β S f hf hS x) (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hx))
+  forall {α : Type.{u3}} {ι : Sort.{u1}} {β : Sort.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {hS : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, u1} α ι S) (Set.univ.{u3} α)} {i : ι} {x : α} (hx : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)), Eq.{u2} β (Set.liftCover.{u3, u1, u2} α ι β S f hf hS x) (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hx))
 Case conversion may be inaccurate. Consider using '#align set.lift_cover_of_mem Set.liftCover_of_memₓ'. -/
 theorem liftCover_of_mem {i : ι} {x : α} (hx : (x : α) ∈ S i) :
     liftCover S f hf hS x = f i ⟨x, hx⟩ :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/95a87616d63b3cb49d3fe678d416fbe9c4217bf4

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
 
 ! This file was ported from Lean 3 source module data.set.Union_lift
-! leanprover-community/mathlib commit c3291da49cfa65f0d43b094750541c0731edc932
+! leanprover-community/mathlib commit 5a4ea8453f128345f73cc656e80a49de2a54f481
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -45,13 +45,18 @@ directed union, directed supremum, glue, gluing
 -/
 
 
-variable {α ι β : Type _}
+variable {α : Type _} {ι β : Sort _}
 
 namespace Set
 
 section UnionLift
 
-#print Set.iUnionLift /-
+/- warning: set.Union_lift -> Set.iUnionLift is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} (S : ι -> (Set.{u1} α)) (f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β), (forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))) -> (forall (T : Set.{u1} α), (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, u2} α ι S)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> β)
+but is expected to have type
+  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} (S : ι -> (Set.{u1} α)) (f : forall (i : ι), (Set.Elem.{u1} α (S i)) -> β), (forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (S i)) (hxj : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (S j)) x hxj))) -> (forall (T : Set.{u1} α), (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S)) -> (Set.Elem.{u1} α T) -> β)
+Case conversion may be inaccurate. Consider using '#align set.Union_lift Set.iUnionLiftₓ'. -/
 /- The unused argument `hf` is left in the definition so that the `simp` lemmas
 `Union_lift_inclusion` will work without the user having to provide `hf` explicitly to
 simplify terms involving `Union_lift`. -/
@@ -64,7 +69,6 @@ noncomputable def iUnionLift (S : ι → Set α) (f : ∀ (i) (x : S i), β)
   let i := Classical.indefiniteDescription _ (mem_iUnion.1 (hT x.Prop))
   f i ⟨x, i.Prop⟩
 #align set.Union_lift Set.iUnionLift
--/
 
 variable {S : ι → Set α} {f : ∀ (i) (x : S i), β}
   {hf : ∀ (i j) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩} {T : Set α}
@@ -72,7 +76,7 @@ variable {S : ι → Set α} {f : ∀ (i) (x : S i), β}
 
 /- warning: set.Union_lift_mk -> Set.iUnionLift_mk is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S)} {i : ι} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (hx : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) x) T), Eq.{succ u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) x) hx)) (f i x)
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, u2} α ι S)} {i : ι} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (hx : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) x) T), Eq.{u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) x) hx)) (f i x)
 but is expected to have type
   forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, succ u1} α ι S)} {i : ι} (x : Set.Elem.{u3} α (S i)) (hx : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x) T), Eq.{succ u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x) hx)) (f i x)
 Case conversion may be inaccurate. Consider using '#align set.Union_lift_mk Set.iUnionLift_mkₓ'. -/
@@ -86,7 +90,7 @@ theorem iUnionLift_mk {i : ι} (x : S i) (hx : (x : α) ∈ T) :
 
 /- warning: set.Union_lift_inclusion -> Set.iUnionLift_inclusion is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S)} {i : ι} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (h : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T), Eq.{succ u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT (Set.inclusion.{u1} α (S i) T h x)) (f i x)
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, u2} α ι S)} {i : ι} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (h : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T), Eq.{u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT (Set.inclusion.{u1} α (S i) T h x)) (f i x)
 but is expected to have type
   forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, succ u1} α ι S)} {i : ι} (x : Set.Elem.{u3} α (S i)) (h : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S i) T), Eq.{succ u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT (Set.inclusion.{u3} α (S i) T h x)) (f i x)
 Case conversion may be inaccurate. Consider using '#align set.Union_lift_inclusion Set.iUnionLift_inclusionₓ'. -/
@@ -98,7 +102,7 @@ theorem iUnionLift_inclusion {i : ι} (x : S i) (h : S i ⊆ T) :
 
 /- warning: set.Union_lift_of_mem -> Set.iUnionLift_of_mem is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S)} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) {i : ι} (hx : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T))))) x) (S i)), Eq.{succ u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT x) (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T))))) x) hx))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, u2} α ι S)} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) {i : ι} (hx : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T))))) x) (S i)), Eq.{u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT x) (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T))))) x) hx))
 but is expected to have type
   forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, succ u1} α ι S)} (x : Set.Elem.{u3} α T) {i : ι} (hx : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) x) (S i)), Eq.{succ u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT x) (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) x) hx))
 Case conversion may be inaccurate. Consider using '#align set.Union_lift_of_mem Set.iUnionLift_of_memₓ'. -/
@@ -108,7 +112,7 @@ theorem iUnionLift_of_mem (x : T) {i : ι} (hx : (x : α) ∈ S i) :
 
 /- warning: set.Union_lift_const -> Set.iUnionLift_const is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S)} (c : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (ci : forall (i : ι), coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), (forall (i : ι), Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) (ci i)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T))))) c)) -> (forall (cβ : β), (forall (i : ι), Eq.{succ u3} β (f i (ci i)) cβ) -> (Eq.{succ u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT c) cβ))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, u2} α ι S)} (c : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (ci : forall (i : ι), coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), (forall (i : ι), Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) (ci i)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T))))) c)) -> (forall (cβ : β), (forall (i : ι), Eq.{u3} β (f i (ci i)) cβ) -> (Eq.{u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT c) cβ))
 but is expected to have type
   forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, succ u1} α ι S)} (c : Set.Elem.{u3} α T) (ci : forall (i : ι), Set.Elem.{u3} α (S i)), (forall (i : ι), Eq.{succ u3} α (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (ci i)) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) c)) -> (forall (cβ : β), (forall (i : ι), Eq.{succ u2} β (f i (ci i)) cβ) -> (Eq.{succ u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT c) cβ))
 Case conversion may be inaccurate. Consider using '#align set.Union_lift_const Set.iUnionLift_constₓ'. -/
@@ -126,7 +130,7 @@ theorem iUnionLift_const (c : T) (ci : ∀ i, S i) (hci : ∀ i, (ci i : α) = c
 
 /- warning: set.Union_lift_unary -> Set.iUnionLift_unary is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} (hT' : Eq.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S)) (u : (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T)) (ui : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i))), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (u (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, succ u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S) hT') (Set.subset_iUnion.{u1, succ u2} α ι S i))) x)) (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, succ u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S) hT') (Set.subset_iUnion.{u1, succ u2} α ι S i))) (ui i x))) -> (forall (uβ : β -> β), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u3} β (f i (ui i x)) (uβ (f i x))) -> (forall (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T), Eq.{succ u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, succ u2} α ι S) hT') (u x)) (uβ (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, succ u2} α ι S) hT') x))))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} (hT' : Eq.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S)) (u : (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T)) (ui : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i))), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (u (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S) hT') (Set.subset_iUnion.{u1, u2} α ι S i))) x)) (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S) hT') (Set.subset_iUnion.{u1, u2} α ι S i))) (ui i x))) -> (forall (uβ : β -> β), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{u3} β (f i (ui i x)) (uβ (f i x))) -> (forall (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T), Eq.{u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, u2} α ι S) hT') (u x)) (uβ (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, u2} α ι S) hT') x))))
 but is expected to have type
   forall {α : Type.{u3}} {ι : Type.{u2}} {β : Type.{u1}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u1} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT' : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S)} (u : Eq.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S)) (ui : (Set.Elem.{u3} α T) -> (Set.Elem.{u3} α T)) (hui : forall (i : ι), (Set.Elem.{u3} α (S i)) -> (Set.Elem.{u3} α (S i))), (forall (ᾰ : ι) (x : Set.Elem.{u3} α (S ᾰ)), Eq.{succ u3} (Set.Elem.{u3} α T) (ui (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.995 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.996 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.995) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.995) (Set.subset_iUnion.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S) u))]) x)) (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1019 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1020 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1019) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1019) (Set.subset_iUnion.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S) u))]) (hui ᾰ x))) -> (forall (h : β -> β), (forall (i : ι) (x : Set.Elem.{u3} α (S i)), Eq.{succ u1} β (f i (hui i x)) (h (f i x))) -> (forall (x : Set.Elem.{u3} α T), Eq.{succ u1} β (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, succ u2} α ι S) u) (ui x)) (h (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, succ u2} α ι S) u) x))))
 Case conversion may be inaccurate. Consider using '#align set.Union_lift_unary Set.iUnionLift_unaryₓ'. -/
@@ -155,7 +159,7 @@ theorem iUnionLift_unary (u : T → T) (ui : ∀ i, S i → S i)
 
 /- warning: set.Union_lift_binary -> Set.iUnionLift_binary is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} (hT' : Eq.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S)), (Directed.{u1, succ u2} (Set.{u1} α) ι (LE.le.{u1} (Set.{u1} α) (Set.hasLe.{u1} α)) S) -> (forall (op : (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T)) (opi : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i))), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (y : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, succ u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S) hT') (Set.subset_iUnion.{u1, succ u2} α ι S i))) (opi i x y)) (op (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, succ u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S) hT') (Set.subset_iUnion.{u1, succ u2} α ι S i))) x) (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, succ u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S) hT') (Set.subset_iUnion.{u1, succ u2} α ι S i))) y))) -> (forall (opβ : β -> β -> β), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (y : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u3} β (f i (opi i x y)) (opβ (f i x) (f i y))) -> (forall (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (y : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T), Eq.{succ u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, succ u2} α ι S) hT') (op x y)) (opβ (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, succ u2} α ι S) hT') x) (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, succ u2} α ι S) hT') y)))))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} (hT' : Eq.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S)), (Directed.{u1, u2} (Set.{u1} α) ι (LE.le.{u1} (Set.{u1} α) (Set.hasLe.{u1} α)) S) -> (forall (op : (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T)) (opi : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i))), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (y : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S) hT') (Set.subset_iUnion.{u1, u2} α ι S i))) (opi i x y)) (op (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S) hT') (Set.subset_iUnion.{u1, u2} α ι S i))) x) (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, u2} α ι S) hT') (Set.subset_iUnion.{u1, u2} α ι S i))) y))) -> (forall (opβ : β -> β -> β), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (y : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{u3} β (f i (opi i x y)) (opβ (f i x) (f i y))) -> (forall (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (y : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T), Eq.{u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, u2} α ι S) hT') (op x y)) (opβ (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, u2} α ι S) hT') x) (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, u2} α ι S) hT') y)))))
 but is expected to have type
   forall {α : Type.{u3}} {ι : Type.{u2}} {β : Type.{u1}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u1} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT' : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S)} (dir : Eq.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S)), (Directed.{u3, succ u2} (Set.{u3} α) ι (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1261 : Set.{u3} α) (x._@.Mathlib.Data.Set.UnionLift._hyg.1263 : Set.{u3} α) => LE.le.{u3} (Set.{u3} α) (Set.instLESet.{u3} α) x._@.Mathlib.Data.Set.UnionLift._hyg.1261 x._@.Mathlib.Data.Set.UnionLift._hyg.1263) S) -> (forall (opi : (Set.Elem.{u3} α T) -> (Set.Elem.{u3} α T) -> (Set.Elem.{u3} α T)) (hopi : forall (i : ι), (Set.Elem.{u3} α (S i)) -> (Set.Elem.{u3} α (S i)) -> (Set.Elem.{u3} α (S i))), (forall (ᾰ : ι) (ᾰ_1 : Set.Elem.{u3} α (S ᾰ)) (y : Set.Elem.{u3} α (S ᾰ)), Eq.{succ u3} (Set.Elem.{u3} α T) (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1318 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1319 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1318) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1318) (Set.subset_iUnion.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S) dir))]) (hopi ᾰ ᾰ_1 y)) (opi (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1350 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1351 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1350) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1350) (Set.subset_iUnion.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S) dir))]) ᾰ_1) (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1376 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1377 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1376) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1376) (Set.subset_iUnion.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S) dir))]) y))) -> (forall (h : β -> β -> β), (forall (i : ι) (x : Set.Elem.{u3} α (S i)) (y : Set.Elem.{u3} α (S i)), Eq.{succ u1} β (f i (hopi i x y)) (h (f i x) (f i y))) -> (forall (y : Set.Elem.{u3} α T) (y_1 : Set.Elem.{u3} α T), Eq.{succ u1} β (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, succ u2} α ι S) dir) (opi y y_1)) (h (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, succ u2} α ι S) dir) y) (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, succ u2} α ι S) dir) y_1)))))
 Case conversion may be inaccurate. Consider using '#align set.Union_lift_binary Set.iUnionLift_binaryₓ'. -/
@@ -198,7 +202,12 @@ variable {S : ι → Set α} {f : ∀ (i) (x : S i), β}
   {hf : ∀ (i j) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩}
   {hS : iUnion S = univ}
 
-#print Set.liftCover /-
+/- warning: set.lift_cover -> Set.liftCover is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} (S : ι -> (Set.{u1} α)) (f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β), (forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))) -> (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, u2} α ι S) (Set.univ.{u1} α)) -> α -> β
+but is expected to have type
+  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} (S : ι -> (Set.{u1} α)) (f : forall (i : ι), (Set.Elem.{u1} α (S i)) -> β), (forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (S i)) (hxj : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (S j)) x hxj))) -> (Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι S) (Set.univ.{u1} α)) -> α -> β
+Case conversion may be inaccurate. Consider using '#align set.lift_cover Set.liftCoverₓ'. -/
 /-- Glue together functions defined on each of a collection `S` of sets that cover a type. See
   also `set.Union_lift`.   -/
 noncomputable def liftCover (S : ι → Set α) (f : ∀ (i) (x : S i), β)
@@ -206,11 +215,10 @@ noncomputable def liftCover (S : ι → Set α) (f : ∀ (i) (x : S i), β)
     (hS : iUnion S = univ) (a : α) : β :=
   iUnionLift S f hf univ (hS ▸ Set.Subset.refl _) ⟨a, trivial⟩
 #align set.lift_cover Set.liftCover
--/
 
 /- warning: set.lift_cover_coe -> Set.liftCover_coe is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {hS : Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι S) (Set.univ.{u1} α)} {i : ι} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u3} β (Set.liftCover.{u1, u2, u3} α ι β S f hf hS ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) x)) (f i x)
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {hS : Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, u2} α ι S) (Set.univ.{u1} α)} {i : ι} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{u3} β (Set.liftCover.{u1, u2, u3} α ι β S f hf hS ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) x)) (f i x)
 but is expected to have type
   forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {hS : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u1} α ι S) (Set.univ.{u3} α)} {i : ι} (x : Set.Elem.{u3} α (S i)), Eq.{succ u2} β (Set.liftCover.{u3, u1, u2} α ι β S f hf hS (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x)) (f i x)
 Case conversion may be inaccurate. Consider using '#align set.lift_cover_coe Set.liftCover_coeₓ'. -/
@@ -221,7 +229,7 @@ theorem liftCover_coe {i : ι} (x : S i) : liftCover S f hf hS x = f i x :=
 
 /- warning: set.lift_cover_of_mem -> Set.liftCover_of_mem is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {hS : Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι S) (Set.univ.{u1} α)} {i : ι} {x : α} (hx : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)), Eq.{succ u3} β (Set.liftCover.{u1, u2, u3} α ι β S f hf hS x) (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hx))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {β : Sort.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {hS : Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, u2} α ι S) (Set.univ.{u1} α)} {i : ι} {x : α} (hx : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)), Eq.{u3} β (Set.liftCover.{u1, u2, u3} α ι β S f hf hS x) (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hx))
 but is expected to have type
   forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {hS : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u1} α ι S) (Set.univ.{u3} α)} {i : ι} {x : α} (hx : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)), Eq.{succ u2} β (Set.liftCover.{u3, u1, u2} α ι β S f hf hS x) (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hx))
 Case conversion may be inaccurate. Consider using '#align set.lift_cover_of_mem Set.liftCover_of_memₓ'. -/

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

@@ -51,183 +51,183 @@ namespace Set
 
 section UnionLift
 
-#print Set.unionᵢLift /-
+#print Set.iUnionLift /-
 /- The unused argument `hf` is left in the definition so that the `simp` lemmas
 `Union_lift_inclusion` will work without the user having to provide `hf` explicitly to
 simplify terms involving `Union_lift`. -/
 /-- Given a Union of sets `Union S`, define a function on the Union by defining
 it on each component, and proving that it agrees on the intersections. -/
 @[nolint unused_arguments]
-noncomputable def unionᵢLift (S : ι → Set α) (f : ∀ (i) (x : S i), β)
+noncomputable def iUnionLift (S : ι → Set α) (f : ∀ (i) (x : S i), β)
     (hf : ∀ (i j) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩) (T : Set α)
-    (hT : T ⊆ unionᵢ S) (x : T) : β :=
-  let i := Classical.indefiniteDescription _ (mem_unionᵢ.1 (hT x.Prop))
+    (hT : T ⊆ iUnion S) (x : T) : β :=
+  let i := Classical.indefiniteDescription _ (mem_iUnion.1 (hT x.Prop))
   f i ⟨x, i.Prop⟩
-#align set.Union_lift Set.unionᵢLift
+#align set.Union_lift Set.iUnionLift
 -/
 
 variable {S : ι → Set α} {f : ∀ (i) (x : S i), β}
   {hf : ∀ (i j) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩} {T : Set α}
-  {hT : T ⊆ unionᵢ S} (hT' : T = unionᵢ S)
+  {hT : T ⊆ iUnion S} (hT' : T = iUnion S)
 
-/- warning: set.Union_lift_mk -> Set.unionᵢLift_mk is a dubious translation:
+/- warning: set.Union_lift_mk -> Set.iUnionLift_mk is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.unionᵢ.{u1, succ u2} α ι S)} {i : ι} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (hx : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) x) T), Eq.{succ u3} β (Set.unionᵢLift.{u1, u2, u3} α ι β S f hf T hT (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) x) hx)) (f i x)
+  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S)} {i : ι} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (hx : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) x) T), Eq.{succ u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) x) hx)) (f i x)
 but is expected to have type
-  forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.unionᵢ.{u3, succ u1} α ι S)} {i : ι} (x : Set.Elem.{u3} α (S i)) (hx : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x) T), Eq.{succ u2} β (Set.unionᵢLift.{u3, u1, u2} α ι β S f hf T hT (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x) hx)) (f i x)
-Case conversion may be inaccurate. Consider using '#align set.Union_lift_mk Set.unionᵢLift_mkₓ'. -/
+  forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, succ u1} α ι S)} {i : ι} (x : Set.Elem.{u3} α (S i)) (hx : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x) T), Eq.{succ u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x) hx)) (f i x)
+Case conversion may be inaccurate. Consider using '#align set.Union_lift_mk Set.iUnionLift_mkₓ'. -/
 @[simp]
-theorem unionᵢLift_mk {i : ι} (x : S i) (hx : (x : α) ∈ T) :
-    unionᵢLift S f hf T hT ⟨x, hx⟩ = f i x :=
+theorem iUnionLift_mk {i : ι} (x : S i) (hx : (x : α) ∈ T) :
+    iUnionLift S f hf T hT ⟨x, hx⟩ = f i x :=
   by
-  let j := Classical.indefiniteDescription _ (mem_unionᵢ.1 (hT hx))
+  let j := Classical.indefiniteDescription _ (mem_iUnion.1 (hT hx))
   cases' x with x hx <;> exact hf j i x j.2 _
-#align set.Union_lift_mk Set.unionᵢLift_mk
+#align set.Union_lift_mk Set.iUnionLift_mk
 
-/- warning: set.Union_lift_inclusion -> Set.unionᵢLift_inclusion is a dubious translation:
+/- warning: set.Union_lift_inclusion -> Set.iUnionLift_inclusion is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.unionᵢ.{u1, succ u2} α ι S)} {i : ι} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (h : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T), Eq.{succ u3} β (Set.unionᵢLift.{u1, u2, u3} α ι β S f hf T hT (Set.inclusion.{u1} α (S i) T h x)) (f i x)
+  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S)} {i : ι} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (h : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T), Eq.{succ u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT (Set.inclusion.{u1} α (S i) T h x)) (f i x)
 but is expected to have type
-  forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.unionᵢ.{u3, succ u1} α ι S)} {i : ι} (x : Set.Elem.{u3} α (S i)) (h : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S i) T), Eq.{succ u2} β (Set.unionᵢLift.{u3, u1, u2} α ι β S f hf T hT (Set.inclusion.{u3} α (S i) T h x)) (f i x)
-Case conversion may be inaccurate. Consider using '#align set.Union_lift_inclusion Set.unionᵢLift_inclusionₓ'. -/
+  forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, succ u1} α ι S)} {i : ι} (x : Set.Elem.{u3} α (S i)) (h : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S i) T), Eq.{succ u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT (Set.inclusion.{u3} α (S i) T h x)) (f i x)
+Case conversion may be inaccurate. Consider using '#align set.Union_lift_inclusion Set.iUnionLift_inclusionₓ'. -/
 @[simp]
-theorem unionᵢLift_inclusion {i : ι} (x : S i) (h : S i ⊆ T) :
-    unionᵢLift S f hf T hT (Set.inclusion h x) = f i x :=
-  unionᵢLift_mk x _
-#align set.Union_lift_inclusion Set.unionᵢLift_inclusion
+theorem iUnionLift_inclusion {i : ι} (x : S i) (h : S i ⊆ T) :
+    iUnionLift S f hf T hT (Set.inclusion h x) = f i x :=
+  iUnionLift_mk x _
+#align set.Union_lift_inclusion Set.iUnionLift_inclusion
 
-/- warning: set.Union_lift_of_mem -> Set.unionᵢLift_of_mem is a dubious translation:
+/- warning: set.Union_lift_of_mem -> Set.iUnionLift_of_mem is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.unionᵢ.{u1, succ u2} α ι S)} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) {i : ι} (hx : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T))))) x) (S i)), Eq.{succ u3} β (Set.unionᵢLift.{u1, u2, u3} α ι β S f hf T hT x) (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T))))) x) hx))
+  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S)} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) {i : ι} (hx : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T))))) x) (S i)), Eq.{succ u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT x) (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T))))) x) hx))
 but is expected to have type
-  forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.unionᵢ.{u3, succ u1} α ι S)} (x : Set.Elem.{u3} α T) {i : ι} (hx : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) x) (S i)), Eq.{succ u2} β (Set.unionᵢLift.{u3, u1, u2} α ι β S f hf T hT x) (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) x) hx))
-Case conversion may be inaccurate. Consider using '#align set.Union_lift_of_mem Set.unionᵢLift_of_memₓ'. -/
-theorem unionᵢLift_of_mem (x : T) {i : ι} (hx : (x : α) ∈ S i) :
-    unionᵢLift S f hf T hT x = f i ⟨x, hx⟩ := by cases' x with x hx <;> exact hf _ _ _ _ _
-#align set.Union_lift_of_mem Set.unionᵢLift_of_mem
+  forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, succ u1} α ι S)} (x : Set.Elem.{u3} α T) {i : ι} (hx : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) x) (S i)), Eq.{succ u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT x) (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) x) hx))
+Case conversion may be inaccurate. Consider using '#align set.Union_lift_of_mem Set.iUnionLift_of_memₓ'. -/
+theorem iUnionLift_of_mem (x : T) {i : ι} (hx : (x : α) ∈ S i) :
+    iUnionLift S f hf T hT x = f i ⟨x, hx⟩ := by cases' x with x hx <;> exact hf _ _ _ _ _
+#align set.Union_lift_of_mem Set.iUnionLift_of_mem
 
-/- warning: set.Union_lift_const -> Set.unionᵢLift_const is a dubious translation:
+/- warning: set.Union_lift_const -> Set.iUnionLift_const is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.unionᵢ.{u1, succ u2} α ι S)} (c : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (ci : forall (i : ι), coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), (forall (i : ι), Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) (ci i)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T))))) c)) -> (forall (cβ : β), (forall (i : ι), Eq.{succ u3} β (f i (ci i)) cβ) -> (Eq.{succ u3} β (Set.unionᵢLift.{u1, u2, u3} α ι β S f hf T hT c) cβ))
+  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} {hT : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S)} (c : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (ci : forall (i : ι), coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), (forall (i : ι), Eq.{succ u1} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) (ci i)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x T))))) c)) -> (forall (cβ : β), (forall (i : ι), Eq.{succ u3} β (f i (ci i)) cβ) -> (Eq.{succ u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T hT c) cβ))
 but is expected to have type
-  forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.unionᵢ.{u3, succ u1} α ι S)} (c : Set.Elem.{u3} α T) (ci : forall (i : ι), Set.Elem.{u3} α (S i)), (forall (i : ι), Eq.{succ u3} α (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (ci i)) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) c)) -> (forall (cβ : β), (forall (i : ι), Eq.{succ u2} β (f i (ci i)) cβ) -> (Eq.{succ u2} β (Set.unionᵢLift.{u3, u1, u2} α ι β S f hf T hT c) cβ))
-Case conversion may be inaccurate. Consider using '#align set.Union_lift_const Set.unionᵢLift_constₓ'. -/
+  forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, succ u1} α ι S)} (c : Set.Elem.{u3} α T) (ci : forall (i : ι), Set.Elem.{u3} α (S i)), (forall (i : ι), Eq.{succ u3} α (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (ci i)) (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x T) c)) -> (forall (cβ : β), (forall (i : ι), Eq.{succ u2} β (f i (ci i)) cβ) -> (Eq.{succ u2} β (Set.iUnionLift.{u3, u1, u2} α ι β S f hf T hT c) cβ))
+Case conversion may be inaccurate. Consider using '#align set.Union_lift_const Set.iUnionLift_constₓ'. -/
 /-- `Union_lift_const` is useful for proving that `Union_lift` is a homomorphism
   of algebraic structures when defined on the Union of algebraic subobjects.
   For example, it could be used to prove that the lift of a collection
   of group homomorphisms on a union of subgroups preserves `1`. -/
-theorem unionᵢLift_const (c : T) (ci : ∀ i, S i) (hci : ∀ i, (ci i : α) = c) (cβ : β)
-    (h : ∀ i, f i (ci i) = cβ) : unionᵢLift S f hf T hT c = cβ :=
+theorem iUnionLift_const (c : T) (ci : ∀ i, S i) (hci : ∀ i, (ci i : α) = c) (cβ : β)
+    (h : ∀ i, f i (ci i) = cβ) : iUnionLift S f hf T hT c = cβ :=
   by
-  let ⟨i, hi⟩ := Set.mem_unionᵢ.1 (hT c.Prop)
+  let ⟨i, hi⟩ := Set.mem_iUnion.1 (hT c.Prop)
   have : ci i = ⟨c, hi⟩ := Subtype.ext (hci i)
   rw [Union_lift_of_mem _ hi, ← this, h]
-#align set.Union_lift_const Set.unionᵢLift_const
+#align set.Union_lift_const Set.iUnionLift_const
 
-/- warning: set.Union_lift_unary -> Set.unionᵢLift_unary is a dubious translation:
+/- warning: set.Union_lift_unary -> Set.iUnionLift_unary is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} (hT' : Eq.{succ u1} (Set.{u1} α) T (Set.unionᵢ.{u1, succ u2} α ι S)) (u : (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T)) (ui : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i))), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (u (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.unionᵢ.{u1, succ u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.unionᵢ.{u1, succ u2} α ι S) hT') (Set.subset_unionᵢ.{u1, succ u2} α ι S i))) x)) (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.unionᵢ.{u1, succ u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.unionᵢ.{u1, succ u2} α ι S) hT') (Set.subset_unionᵢ.{u1, succ u2} α ι S i))) (ui i x))) -> (forall (uβ : β -> β), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u3} β (f i (ui i x)) (uβ (f i x))) -> (forall (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T), Eq.{succ u3} β (Set.unionᵢLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.unionᵢ.{u1, succ u2} α ι S) hT') (u x)) (uβ (Set.unionᵢLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.unionᵢ.{u1, succ u2} α ι S) hT') x))))
+  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} (hT' : Eq.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S)) (u : (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T)) (ui : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i))), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (u (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, succ u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S) hT') (Set.subset_iUnion.{u1, succ u2} α ι S i))) x)) (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, succ u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S) hT') (Set.subset_iUnion.{u1, succ u2} α ι S i))) (ui i x))) -> (forall (uβ : β -> β), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u3} β (f i (ui i x)) (uβ (f i x))) -> (forall (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T), Eq.{succ u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, succ u2} α ι S) hT') (u x)) (uβ (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, succ u2} α ι S) hT') x))))
 but is expected to have type
-  forall {α : Type.{u3}} {ι : Type.{u2}} {β : Type.{u1}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u1} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT' : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.unionᵢ.{u3, succ u2} α ι S)} (u : Eq.{succ u3} (Set.{u3} α) T (Set.unionᵢ.{u3, succ u2} α ι S)) (ui : (Set.Elem.{u3} α T) -> (Set.Elem.{u3} α T)) (hui : forall (i : ι), (Set.Elem.{u3} α (S i)) -> (Set.Elem.{u3} α (S i))), (forall (ᾰ : ι) (x : Set.Elem.{u3} α (S ᾰ)), Eq.{succ u3} (Set.Elem.{u3} α T) (ui (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.unionᵢ.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.995 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.996 : Eq.{succ u3} (Set.{u3} α) (Set.unionᵢ.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.995) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.995) (Set.subset_unionᵢ.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.unionᵢ.{u3, succ u2} α ι S) u))]) x)) (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.unionᵢ.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1019 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1020 : Eq.{succ u3} (Set.{u3} α) (Set.unionᵢ.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1019) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1019) (Set.subset_unionᵢ.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.unionᵢ.{u3, succ u2} α ι S) u))]) (hui ᾰ x))) -> (forall (h : β -> β), (forall (i : ι) (x : Set.Elem.{u3} α (S i)), Eq.{succ u1} β (f i (hui i x)) (h (f i x))) -> (forall (x : Set.Elem.{u3} α T), Eq.{succ u1} β (Set.unionᵢLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.unionᵢ.{u3, succ u2} α ι S) u) (ui x)) (h (Set.unionᵢLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.unionᵢ.{u3, succ u2} α ι S) u) x))))
-Case conversion may be inaccurate. Consider using '#align set.Union_lift_unary Set.unionᵢLift_unaryₓ'. -/
+  forall {α : Type.{u3}} {ι : Type.{u2}} {β : Type.{u1}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u1} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT' : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S)} (u : Eq.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S)) (ui : (Set.Elem.{u3} α T) -> (Set.Elem.{u3} α T)) (hui : forall (i : ι), (Set.Elem.{u3} α (S i)) -> (Set.Elem.{u3} α (S i))), (forall (ᾰ : ι) (x : Set.Elem.{u3} α (S ᾰ)), Eq.{succ u3} (Set.Elem.{u3} α T) (ui (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.995 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.996 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.995) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.995) (Set.subset_iUnion.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S) u))]) x)) (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1019 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1020 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1019) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1019) (Set.subset_iUnion.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S) u))]) (hui ᾰ x))) -> (forall (h : β -> β), (forall (i : ι) (x : Set.Elem.{u3} α (S i)), Eq.{succ u1} β (f i (hui i x)) (h (f i x))) -> (forall (x : Set.Elem.{u3} α T), Eq.{succ u1} β (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, succ u2} α ι S) u) (ui x)) (h (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, succ u2} α ι S) u) x))))
+Case conversion may be inaccurate. Consider using '#align set.Union_lift_unary Set.iUnionLift_unaryₓ'. -/
 /-- `Union_lift_unary` is useful for proving that `Union_lift` is a homomorphism
   of algebraic structures when defined on the Union of algebraic subobjects.
   For example, it could be used to prove that the lift of a collection
   of linear_maps on a union of submodules preserves scalar multiplication. -/
-theorem unionᵢLift_unary (u : T → T) (ui : ∀ i, S i → S i)
+theorem iUnionLift_unary (u : T → T) (ui : ∀ i, S i → S i)
     (hui :
       ∀ (i) (x : S i),
-        u (Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_unionᵢ S i) x) =
-          Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_unionᵢ S i) (ui i x))
+        u (Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_iUnion S i) x) =
+          Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_iUnion S i) (ui i x))
     (uβ : β → β) (h : ∀ (i) (x : S i), f i (ui i x) = uβ (f i x)) (x : T) :
-    unionᵢLift S f hf T (le_of_eq hT') (u x) = uβ (unionᵢLift S f hf T (le_of_eq hT') x) :=
+    iUnionLift S f hf T (le_of_eq hT') (u x) = uβ (iUnionLift S f hf T (le_of_eq hT') x) :=
   by
   subst hT'
-  cases' Set.mem_unionᵢ.1 x.prop with i hi
+  cases' Set.mem_iUnion.1 x.prop with i hi
   rw [Union_lift_of_mem x hi, ← h i]
-  have : x = Set.inclusion (Set.subset_unionᵢ S i) ⟨x, hi⟩ :=
+  have : x = Set.inclusion (Set.subset_iUnion S i) ⟨x, hi⟩ :=
     by
     cases x
     rfl
-  have hx' : (Set.inclusion (Set.subset_unionᵢ S i) (ui i ⟨x, hi⟩) : α) ∈ S i := (ui i ⟨x, hi⟩).Prop
+  have hx' : (Set.inclusion (Set.subset_iUnion S i) (ui i ⟨x, hi⟩) : α) ∈ S i := (ui i ⟨x, hi⟩).Prop
   conv_lhs => rw [this, hui, Union_lift_inclusion]
-#align set.Union_lift_unary Set.unionᵢLift_unary
+#align set.Union_lift_unary Set.iUnionLift_unary
 
-/- warning: set.Union_lift_binary -> Set.unionᵢLift_binary is a dubious translation:
+/- warning: set.Union_lift_binary -> Set.iUnionLift_binary is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} (hT' : Eq.{succ u1} (Set.{u1} α) T (Set.unionᵢ.{u1, succ u2} α ι S)), (Directed.{u1, succ u2} (Set.{u1} α) ι (LE.le.{u1} (Set.{u1} α) (Set.hasLe.{u1} α)) S) -> (forall (op : (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T)) (opi : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i))), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (y : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.unionᵢ.{u1, succ u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.unionᵢ.{u1, succ u2} α ι S) hT') (Set.subset_unionᵢ.{u1, succ u2} α ι S i))) (opi i x y)) (op (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.unionᵢ.{u1, succ u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.unionᵢ.{u1, succ u2} α ι S) hT') (Set.subset_unionᵢ.{u1, succ u2} α ι S i))) x) (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.unionᵢ.{u1, succ u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.unionᵢ.{u1, succ u2} α ι S) hT') (Set.subset_unionᵢ.{u1, succ u2} α ι S i))) y))) -> (forall (opβ : β -> β -> β), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (y : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u3} β (f i (opi i x y)) (opβ (f i x) (f i y))) -> (forall (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (y : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T), Eq.{succ u3} β (Set.unionᵢLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.unionᵢ.{u1, succ u2} α ι S) hT') (op x y)) (opβ (Set.unionᵢLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.unionᵢ.{u1, succ u2} α ι S) hT') x) (Set.unionᵢLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.unionᵢ.{u1, succ u2} α ι S) hT') y)))))
+  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {T : Set.{u1} α} (hT' : Eq.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S)), (Directed.{u1, succ u2} (Set.{u1} α) ι (LE.le.{u1} (Set.{u1} α) (Set.hasLe.{u1} α)) S) -> (forall (op : (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T)) (opi : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i))), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (y : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, succ u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S) hT') (Set.subset_iUnion.{u1, succ u2} α ι S i))) (opi i x y)) (op (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, succ u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S) hT') (Set.subset_iUnion.{u1, succ u2} α ι S i))) x) (Set.inclusion.{u1} α (S i) T ((fun (this : HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) T) => this) (Eq.subst.{succ u1} (Set.{u1} α) (fun (_x : Set.{u1} α) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (S i) _x) (Set.iUnion.{u1, succ u2} α ι S) T (Eq.symm.{succ u1} (Set.{u1} α) T (Set.iUnion.{u1, succ u2} α ι S) hT') (Set.subset_iUnion.{u1, succ u2} α ι S i))) y))) -> (forall (opβ : β -> β -> β), (forall (i : ι) (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) (y : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u3} β (f i (opi i x y)) (opβ (f i x) (f i y))) -> (forall (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T) (y : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) T), Eq.{succ u3} β (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, succ u2} α ι S) hT') (op x y)) (opβ (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, succ u2} α ι S) hT') x) (Set.iUnionLift.{u1, u2, u3} α ι β S f hf T (le_of_eq.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) T (Set.iUnion.{u1, succ u2} α ι S) hT') y)))))
 but is expected to have type
-  forall {α : Type.{u3}} {ι : Type.{u2}} {β : Type.{u1}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u1} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT' : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.unionᵢ.{u3, succ u2} α ι S)} (dir : Eq.{succ u3} (Set.{u3} α) T (Set.unionᵢ.{u3, succ u2} α ι S)), (Directed.{u3, succ u2} (Set.{u3} α) ι (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1261 : Set.{u3} α) (x._@.Mathlib.Data.Set.UnionLift._hyg.1263 : Set.{u3} α) => LE.le.{u3} (Set.{u3} α) (Set.instLESet.{u3} α) x._@.Mathlib.Data.Set.UnionLift._hyg.1261 x._@.Mathlib.Data.Set.UnionLift._hyg.1263) S) -> (forall (opi : (Set.Elem.{u3} α T) -> (Set.Elem.{u3} α T) -> (Set.Elem.{u3} α T)) (hopi : forall (i : ι), (Set.Elem.{u3} α (S i)) -> (Set.Elem.{u3} α (S i)) -> (Set.Elem.{u3} α (S i))), (forall (ᾰ : ι) (ᾰ_1 : Set.Elem.{u3} α (S ᾰ)) (y : Set.Elem.{u3} α (S ᾰ)), Eq.{succ u3} (Set.Elem.{u3} α T) (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.unionᵢ.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1318 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1319 : Eq.{succ u3} (Set.{u3} α) (Set.unionᵢ.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1318) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1318) (Set.subset_unionᵢ.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.unionᵢ.{u3, succ u2} α ι S) dir))]) (hopi ᾰ ᾰ_1 y)) (opi (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.unionᵢ.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1350 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1351 : Eq.{succ u3} (Set.{u3} α) (Set.unionᵢ.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1350) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1350) (Set.subset_unionᵢ.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.unionᵢ.{u3, succ u2} α ι S) dir))]) ᾰ_1) (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.unionᵢ.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1376 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1377 : Eq.{succ u3} (Set.{u3} α) (Set.unionᵢ.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1376) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1376) (Set.subset_unionᵢ.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.unionᵢ.{u3, succ u2} α ι S) dir))]) y))) -> (forall (h : β -> β -> β), (forall (i : ι) (x : Set.Elem.{u3} α (S i)) (y : Set.Elem.{u3} α (S i)), Eq.{succ u1} β (f i (hopi i x y)) (h (f i x) (f i y))) -> (forall (y : Set.Elem.{u3} α T) (y_1 : Set.Elem.{u3} α T), Eq.{succ u1} β (Set.unionᵢLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.unionᵢ.{u3, succ u2} α ι S) dir) (opi y y_1)) (h (Set.unionᵢLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.unionᵢ.{u3, succ u2} α ι S) dir) y) (Set.unionᵢLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.unionᵢ.{u3, succ u2} α ι S) dir) y_1)))))
-Case conversion may be inaccurate. Consider using '#align set.Union_lift_binary Set.unionᵢLift_binaryₓ'. -/
+  forall {α : Type.{u3}} {ι : Type.{u2}} {β : Type.{u1}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u1} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {T : Set.{u3} α} {hT' : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S)} (dir : Eq.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S)), (Directed.{u3, succ u2} (Set.{u3} α) ι (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1261 : Set.{u3} α) (x._@.Mathlib.Data.Set.UnionLift._hyg.1263 : Set.{u3} α) => LE.le.{u3} (Set.{u3} α) (Set.instLESet.{u3} α) x._@.Mathlib.Data.Set.UnionLift._hyg.1261 x._@.Mathlib.Data.Set.UnionLift._hyg.1263) S) -> (forall (opi : (Set.Elem.{u3} α T) -> (Set.Elem.{u3} α T) -> (Set.Elem.{u3} α T)) (hopi : forall (i : ι), (Set.Elem.{u3} α (S i)) -> (Set.Elem.{u3} α (S i)) -> (Set.Elem.{u3} α (S i))), (forall (ᾰ : ι) (ᾰ_1 : Set.Elem.{u3} α (S ᾰ)) (y : Set.Elem.{u3} α (S ᾰ)), Eq.{succ u3} (Set.Elem.{u3} α T) (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1318 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1319 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1318) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1318) (Set.subset_iUnion.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S) dir))]) (hopi ᾰ ᾰ_1 y)) (opi (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1350 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1351 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1350) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1350) (Set.subset_iUnion.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S) dir))]) ᾰ_1) (Set.inclusion.{u3} α (S ᾰ) T ([mdata let_fun:1 (fun (this : HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) T) => this) (Eq.rec.{0, succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) (fun (x._@.Mathlib.Data.Set.UnionLift._hyg.1376 : Set.{u3} α) (h._@.Mathlib.Data.Set.UnionLift._hyg.1377 : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u2} α ι S) x._@.Mathlib.Data.Set.UnionLift._hyg.1376) => HasSubset.Subset.{u3} (Set.{u3} α) (Set.instHasSubsetSet.{u3} α) (S ᾰ) x._@.Mathlib.Data.Set.UnionLift._hyg.1376) (Set.subset_iUnion.{succ u2, u3} α ι S ᾰ) T (Eq.symm.{succ u3} (Set.{u3} α) T (Set.iUnion.{u3, succ u2} α ι S) dir))]) y))) -> (forall (h : β -> β -> β), (forall (i : ι) (x : Set.Elem.{u3} α (S i)) (y : Set.Elem.{u3} α (S i)), Eq.{succ u1} β (f i (hopi i x y)) (h (f i x) (f i y))) -> (forall (y : Set.Elem.{u3} α T) (y_1 : Set.Elem.{u3} α T), Eq.{succ u1} β (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, succ u2} α ι S) dir) (opi y y_1)) (h (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, succ u2} α ι S) dir) y) (Set.iUnionLift.{u3, u2, u1} α ι β S f hf T (le_of_eq.{u3} (Set.{u3} α) (PartialOrder.toPreorder.{u3} (Set.{u3} α) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α))))))) T (Set.iUnion.{u3, succ u2} α ι S) dir) y_1)))))
+Case conversion may be inaccurate. Consider using '#align set.Union_lift_binary Set.iUnionLift_binaryₓ'. -/
 /-- `Union_lift_binary` is useful for proving that `Union_lift` is a homomorphism
   of algebraic structures when defined on the Union of algebraic subobjects.
   For example, it could be used to prove that the lift of a collection
   of group homomorphisms on a union of subgroups preserves `*`. -/
-theorem unionᵢLift_binary (dir : Directed (· ≤ ·) S) (op : T → T → T) (opi : ∀ i, S i → S i → S i)
+theorem iUnionLift_binary (dir : Directed (· ≤ ·) S) (op : T → T → T) (opi : ∀ i, S i → S i → S i)
     (hopi :
       ∀ i x y,
-        Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_unionᵢ S i) (opi i x y) =
-          op (Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_unionᵢ S i) x)
-            (Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_unionᵢ S i) y))
+        Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_iUnion S i) (opi i x y) =
+          op (Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_iUnion S i) x)
+            (Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_iUnion S i) y))
     (opβ : β → β → β) (h : ∀ (i) (x y : S i), f i (opi i x y) = opβ (f i x) (f i y)) (x y : T) :
-    unionᵢLift S f hf T (le_of_eq hT') (op x y) =
-      opβ (unionᵢLift S f hf T (le_of_eq hT') x) (unionᵢLift S f hf T (le_of_eq hT') y) :=
+    iUnionLift S f hf T (le_of_eq hT') (op x y) =
+      opβ (iUnionLift S f hf T (le_of_eq hT') x) (iUnionLift S f hf T (le_of_eq hT') y) :=
   by
   subst hT'
-  cases' Set.mem_unionᵢ.1 x.prop with i hi
-  cases' Set.mem_unionᵢ.1 y.prop with j hj
+  cases' Set.mem_iUnion.1 x.prop with i hi
+  cases' Set.mem_iUnion.1 y.prop with j hj
   rcases dir i j with ⟨k, hik, hjk⟩
   rw [Union_lift_of_mem x (hik hi), Union_lift_of_mem y (hjk hj), ← h k]
-  have hx : x = Set.inclusion (Set.subset_unionᵢ S k) ⟨x, hik hi⟩ :=
+  have hx : x = Set.inclusion (Set.subset_iUnion S k) ⟨x, hik hi⟩ :=
     by
     cases x
     rfl
-  have hy : y = Set.inclusion (Set.subset_unionᵢ S k) ⟨y, hjk hj⟩ :=
+  have hy : y = Set.inclusion (Set.subset_iUnion S k) ⟨y, hjk hj⟩ :=
     by
     cases y
     rfl
-  have hxy : (Set.inclusion (Set.subset_unionᵢ S k) (opi k ⟨x, hik hi⟩ ⟨y, hjk hj⟩) : α) ∈ S k :=
+  have hxy : (Set.inclusion (Set.subset_iUnion S k) (opi k ⟨x, hik hi⟩ ⟨y, hjk hj⟩) : α) ∈ S k :=
     (opi k ⟨x, hik hi⟩ ⟨y, hjk hj⟩).Prop
   conv_lhs => rw [hx, hy, ← hopi, Union_lift_of_mem _ hxy]
   simp only [coe_inclusion, Subtype.coe_eta]
-#align set.Union_lift_binary Set.unionᵢLift_binary
+#align set.Union_lift_binary Set.iUnionLift_binary
 
 end UnionLift
 
 variable {S : ι → Set α} {f : ∀ (i) (x : S i), β}
   {hf : ∀ (i j) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩}
-  {hS : unionᵢ S = univ}
+  {hS : iUnion S = univ}
 
 #print Set.liftCover /-
 /-- Glue together functions defined on each of a collection `S` of sets that cover a type. See
   also `set.Union_lift`.   -/
 noncomputable def liftCover (S : ι → Set α) (f : ∀ (i) (x : S i), β)
     (hf : ∀ (i j) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩)
-    (hS : unionᵢ S = univ) (a : α) : β :=
-  unionᵢLift S f hf univ (hS ▸ Set.Subset.refl _) ⟨a, trivial⟩
+    (hS : iUnion S = univ) (a : α) : β :=
+  iUnionLift S f hf univ (hS ▸ Set.Subset.refl _) ⟨a, trivial⟩
 #align set.lift_cover Set.liftCover
 -/
 
 /- warning: set.lift_cover_coe -> Set.liftCover_coe is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {hS : Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u2} α ι S) (Set.univ.{u1} α)} {i : ι} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u3} β (Set.liftCover.{u1, u2, u3} α ι β S f hf hS ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) x)) (f i x)
+  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {hS : Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι S) (Set.univ.{u1} α)} {i : ι} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)), Eq.{succ u3} β (Set.liftCover.{u1, u2, u3} α ι β S f hf hS ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)))))) x)) (f i x)
 but is expected to have type
-  forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {hS : Eq.{succ u3} (Set.{u3} α) (Set.unionᵢ.{u3, succ u1} α ι S) (Set.univ.{u3} α)} {i : ι} (x : Set.Elem.{u3} α (S i)), Eq.{succ u2} β (Set.liftCover.{u3, u1, u2} α ι β S f hf hS (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x)) (f i x)
+  forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {hS : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u1} α ι S) (Set.univ.{u3} α)} {i : ι} (x : Set.Elem.{u3} α (S i)), Eq.{succ u2} β (Set.liftCover.{u3, u1, u2} α ι β S f hf hS (Subtype.val.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x)) (f i x)
 Case conversion may be inaccurate. Consider using '#align set.lift_cover_coe Set.liftCover_coeₓ'. -/
 @[simp]
 theorem liftCover_coe {i : ι} (x : S i) : liftCover S f hf hS x = f i x :=
-  unionᵢLift_mk x _
+  iUnionLift_mk x _
 #align set.lift_cover_coe Set.liftCover_coe
 
 /- warning: set.lift_cover_of_mem -> Set.liftCover_of_mem is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {hS : Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u2} α ι S) (Set.univ.{u1} α)} {i : ι} {x : α} (hx : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)), Eq.{succ u3} β (Set.liftCover.{u1, u2, u3} α ι β S f hf hS x) (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hx))
+  forall {α : Type.{u1}} {ι : Type.{u2}} {β : Type.{u3}} {S : ι -> (Set.{u1} α)} {f : forall (i : ι), (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) (hxj : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)), Eq.{succ u3} β (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S j)) x hxj))} {hS : Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u2} α ι S) (Set.univ.{u1} α)} {i : ι} {x : α} (hx : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)), Eq.{succ u3} β (Set.liftCover.{u1, u2, u3} α ι β S f hf hS x) (f i (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (S i)) x hx))
 but is expected to have type
-  forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {hS : Eq.{succ u3} (Set.{u3} α) (Set.unionᵢ.{u3, succ u1} α ι S) (Set.univ.{u3} α)} {i : ι} {x : α} (hx : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)), Eq.{succ u2} β (Set.liftCover.{u3, u1, u2} α ι β S f hf hS x) (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hx))
+  forall {α : Type.{u3}} {ι : Type.{u1}} {β : Type.{u2}} {S : ι -> (Set.{u3} α)} {f : forall (i : ι), (Set.Elem.{u3} α (S i)) -> β} {hf : forall (i : ι) (j : ι) (x : α) (hxi : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) (hxj : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)), Eq.{succ u2} β (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hxi)) (f j (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S j)) x hxj))} {hS : Eq.{succ u3} (Set.{u3} α) (Set.iUnion.{u3, succ u1} α ι S) (Set.univ.{u3} α)} {i : ι} {x : α} (hx : Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)), Eq.{succ u2} β (Set.liftCover.{u3, u1, u2} α ι β S f hf hS x) (f i (Subtype.mk.{succ u3} α (fun (x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) x (S i)) x hx))
 Case conversion may be inaccurate. Consider using '#align set.lift_cover_of_mem Set.liftCover_of_memₓ'. -/
 theorem liftCover_of_mem {i : ι} {x : α} (hx : (x : α) ∈ S i) :
     liftCover S f hf hS x = f i ⟨x, hx⟩ :=
-  unionᵢLift_of_mem ⟨x, trivial⟩ hx
+  iUnionLift_of_mem ⟨x, trivial⟩ hx
 #align set.lift_cover_of_mem Set.liftCover_of_mem
 
 end Set

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

Search for [∀∃].*(_ and manually replace some occurrences with more readable versions. In case of ∀, the new expressions are defeq to the old ones. In case of ∃, they differ by exists_prop.

In some rare cases, golf proofs that needed fixing.

@@ -50,14 +50,14 @@ simplify terms involving `iUnionLift`. -/
 /-- Given a union of sets `iUnion S`, define a function on the Union by defining
 it on each component, and proving that it agrees on the intersections. -/
 @[nolint unusedArguments]
-noncomputable def iUnionLift (S : ι → Set α) (f : ∀ (i) (_ : S i), β)
+noncomputable def iUnionLift (S : ι → Set α) (f : ∀ i, S i → β)
     (_ : ∀ (i j) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩) (T : Set α)
     (hT : T ⊆ iUnion S) (x : T) : β :=
   let i := Classical.indefiniteDescription _ (mem_iUnion.1 (hT x.prop))
   f i ⟨x, i.prop⟩
 #align set.Union_lift Set.iUnionLift
 
-variable {S : ι → Set α} {f : ∀ (i) (_ : S i), β}
+variable {S : ι → Set α} {f : ∀ i, S i → β}
   {hf : ∀ (i j) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩} {T : Set α}
   {hT : T ⊆ iUnion S} (hT' : T = iUnion S)
 
@@ -151,13 +151,13 @@ theorem iUnionLift_binary (dir : Directed (· ≤ ·) S) (op : T → T → T) (o
 
 end UnionLift
 
-variable {S : ι → Set α} {f : ∀ (i) (_ : S i), β}
+variable {S : ι → Set α} {f : ∀ i, S i → β}
   {hf : ∀ (i j) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩}
   {hS : iUnion S = univ}
 
 /-- Glue together functions defined on each of a collection `S` of sets that cover a type. See
   also `Set.iUnionLift`.   -/
-noncomputable def liftCover (S : ι → Set α) (f : ∀ (i) (_ : S i), β)
+noncomputable def liftCover (S : ι → Set α) (f : ∀ i, S i → β)
     (hf : ∀ (i j) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩)
     (hS : iUnion S = univ) (a : α) : β :=
   iUnionLift S f hf univ hS.symm.subset ⟨a, trivial⟩

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

This has nice performance benefits.

@@ -38,7 +38,7 @@ constants, unary functions, or binary functions are preserved. These lemmas are:
 directed union, directed supremum, glue, gluing
 -/
 
-variable {α : Type _} {ι β : Sort _}
+variable {α : Type*} {ι β : Sort _}
 
 namespace Set
 

• depends on: #5966

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

@@ -2,15 +2,12 @@
 Copyright (c) 2021 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
-
-! This file was ported from Lean 3 source module data.set.Union_lift
-! leanprover-community/mathlib commit 5a4ea8453f128345f73cc656e80a49de2a54f481
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Set.Lattice
 import Mathlib.Order.Directed
 
+#align_import data.set.Union_lift from "leanprover-community/mathlib"@"5a4ea8453f128345f73cc656e80a49de2a54f481"
+
 /-!
 # Union lift
 This file defines `Set.iUnionLift` to glue together functions defined on each of a collection of

Co-authored-by: Komyyy <pol_tta@outlook.jp>

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
 
 ! This file was ported from Lean 3 source module data.set.Union_lift
-! leanprover-community/mathlib commit 207cfac9fcd06138865b5d04f7091e46d9320432
+! leanprover-community/mathlib commit 5a4ea8453f128345f73cc656e80a49de2a54f481
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -41,7 +41,7 @@ constants, unary functions, or binary functions are preserved. These lemmas are:
 directed union, directed supremum, glue, gluing
 -/
 
-variable {α ι β : Type _}
+variable {α : Type _} {ι β : Sort _}
 
 namespace Set
 

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>

@@ -13,28 +13,28 @@ import Mathlib.Order.Directed
 
 /-!
 # Union lift
-This file defines `Set.unionᵢLift` to glue together functions defined on each of a collection of
+This file defines `Set.iUnionLift` to glue together functions defined on each of a collection of
 sets to make a function on the Union of those sets.
 
 ## Main definitions
 
-* `Set.unionᵢLift` -  Given a Union of sets `unionᵢ S`, define a function on any subset of the Union
+* `Set.iUnionLift` -  Given a Union of sets `iUnion S`, define a function on any subset of the Union
   by defining it on each component, and proving that it agrees on the intersections.
-* `Set.liftCover` - Version of `Set.unionᵢLift` for the special case that the sets cover the
+* `Set.liftCover` - Version of `Set.iUnionLift` for the special case that the sets cover the
   entire type.
 
 ## Main statements
 
-There are proofs of the obvious properties of `unionᵢLift`, i.e. what it does to elements of
-each of the sets in the `unionᵢ`, stated in different ways.
+There are proofs of the obvious properties of `iUnionLift`, i.e. what it does to elements of
+each of the sets in the `iUnion`, stated in different ways.
 
-There are also three lemmas about `unionᵢLift` intended to aid with proving that `unionᵢLift` is a
+There are also three lemmas about `iUnionLift` intended to aid with proving that `iUnionLift` is a
 homomorphism when defined on a Union of substructures. There is one lemma each to show that
 constants, unary functions, or binary functions are preserved. These lemmas are:
 
-*`Set.unionᵢLift_const`
-*`Set.unionᵢLift_unary`
-*`Set.unionᵢLift_binary`
+*`Set.iUnionLift_const`
+*`Set.iUnionLift_unary`
+*`Set.iUnionLift_binary`
 
 ## Tags
 
@@ -48,137 +48,137 @@ namespace Set
 section UnionLift
 
 /- The unused argument is left in the definition so that the `simp` lemmas
-`unionᵢLift_inclusion` will work without the user having to provide it explicitly to
-simplify terms involving `unionᵢLift`. -/
-/-- Given a union of sets `unionᵢ S`, define a function on the Union by defining
+`iUnionLift_inclusion` will work without the user having to provide it explicitly to
+simplify terms involving `iUnionLift`. -/
+/-- Given a union of sets `iUnion S`, define a function on the Union by defining
 it on each component, and proving that it agrees on the intersections. -/
 @[nolint unusedArguments]
-noncomputable def unionᵢLift (S : ι → Set α) (f : ∀ (i) (_ : S i), β)
+noncomputable def iUnionLift (S : ι → Set α) (f : ∀ (i) (_ : S i), β)
     (_ : ∀ (i j) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩) (T : Set α)
-    (hT : T ⊆ unionᵢ S) (x : T) : β :=
-  let i := Classical.indefiniteDescription _ (mem_unionᵢ.1 (hT x.prop))
+    (hT : T ⊆ iUnion S) (x : T) : β :=
+  let i := Classical.indefiniteDescription _ (mem_iUnion.1 (hT x.prop))
   f i ⟨x, i.prop⟩
-#align set.Union_lift Set.unionᵢLift
+#align set.Union_lift Set.iUnionLift
 
 variable {S : ι → Set α} {f : ∀ (i) (_ : S i), β}
   {hf : ∀ (i j) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩} {T : Set α}
-  {hT : T ⊆ unionᵢ S} (hT' : T = unionᵢ S)
+  {hT : T ⊆ iUnion S} (hT' : T = iUnion S)
 
 @[simp]
-theorem unionᵢLift_mk {i : ι} (x : S i) (hx : (x : α) ∈ T) :
-    unionᵢLift S f hf T hT ⟨x, hx⟩ = f i x := hf _ i x _ _
-#align set.Union_lift_mk Set.unionᵢLift_mk
+theorem iUnionLift_mk {i : ι} (x : S i) (hx : (x : α) ∈ T) :
+    iUnionLift S f hf T hT ⟨x, hx⟩ = f i x := hf _ i x _ _
+#align set.Union_lift_mk Set.iUnionLift_mk
 
 @[simp]
-theorem unionᵢLift_inclusion {i : ι} (x : S i) (h : S i ⊆ T) :
-    unionᵢLift S f hf T hT (Set.inclusion h x) = f i x :=
-  unionᵢLift_mk x _
-#align set.Union_lift_inclusion Set.unionᵢLift_inclusion
-
-theorem unionᵢLift_of_mem (x : T) {i : ι} (hx : (x : α) ∈ S i) :
-    unionᵢLift S f hf T hT x = f i ⟨x, hx⟩ := by cases' x with x hx; exact hf _ _ _ _ _
-#align set.Union_lift_of_mem Set.unionᵢLift_of_mem
-
-theorem preimage_unionᵢLift (t : Set β) :
-    unionᵢLift S f hf T hT ⁻¹' t =
-      inclusion hT ⁻¹' (⋃ i, inclusion (subset_unionᵢ S i) '' (f i ⁻¹' t)) := by
+theorem iUnionLift_inclusion {i : ι} (x : S i) (h : S i ⊆ T) :
+    iUnionLift S f hf T hT (Set.inclusion h x) = f i x :=
+  iUnionLift_mk x _
+#align set.Union_lift_inclusion Set.iUnionLift_inclusion
+
+theorem iUnionLift_of_mem (x : T) {i : ι} (hx : (x : α) ∈ S i) :
+    iUnionLift S f hf T hT x = f i ⟨x, hx⟩ := by cases' x with x hx; exact hf _ _ _ _ _
+#align set.Union_lift_of_mem Set.iUnionLift_of_mem
+
+theorem preimage_iUnionLift (t : Set β) :
+    iUnionLift S f hf T hT ⁻¹' t =
+      inclusion hT ⁻¹' (⋃ i, inclusion (subset_iUnion S i) '' (f i ⁻¹' t)) := by
   ext x
-  simp only [mem_preimage, mem_unionᵢ, mem_image]
+  simp only [mem_preimage, mem_iUnion, mem_image]
   constructor
-  · rcases mem_unionᵢ.1 (hT x.prop) with ⟨i, hi⟩
+  · rcases mem_iUnion.1 (hT x.prop) with ⟨i, hi⟩
     refine fun h => ⟨i, ⟨x, hi⟩, ?_, rfl⟩
-    rwa [unionᵢLift_of_mem x hi] at h
+    rwa [iUnionLift_of_mem x hi] at h
   · rintro ⟨i, ⟨y, hi⟩, h, hxy⟩
     obtain rfl : y = x := congr_arg Subtype.val hxy
-    rwa [unionᵢLift_of_mem x hi]
+    rwa [iUnionLift_of_mem x hi]
 
-/-- `unionᵢLift_const` is useful for proving that `unionᵢLift` is a homomorphism
+/-- `iUnionLift_const` is useful for proving that `iUnionLift` is a homomorphism
   of algebraic structures when defined on the Union of algebraic subobjects.
   For example, it could be used to prove that the lift of a collection
   of group homomorphisms on a union of subgroups preserves `1`. -/
-theorem unionᵢLift_const (c : T) (ci : ∀ i, S i) (hci : ∀ i, (ci i : α) = c) (cβ : β)
-    (h : ∀ i, f i (ci i) = cβ) : unionᵢLift S f hf T hT c = cβ := by
-  let ⟨i, hi⟩ := Set.mem_unionᵢ.1 (hT c.prop)
+theorem iUnionLift_const (c : T) (ci : ∀ i, S i) (hci : ∀ i, (ci i : α) = c) (cβ : β)
+    (h : ∀ i, f i (ci i) = cβ) : iUnionLift S f hf T hT c = cβ := by
+  let ⟨i, hi⟩ := Set.mem_iUnion.1 (hT c.prop)
   have : ci i = ⟨c, hi⟩ := Subtype.ext (hci i)
-  rw [unionᵢLift_of_mem _ hi, ← this, h]
-#align set.Union_lift_const Set.unionᵢLift_const
+  rw [iUnionLift_of_mem _ hi, ← this, h]
+#align set.Union_lift_const Set.iUnionLift_const
 
-/-- `unionᵢLift_unary` is useful for proving that `unionᵢLift` is a homomorphism
+/-- `iUnionLift_unary` is useful for proving that `iUnionLift` is a homomorphism
   of algebraic structures when defined on the Union of algebraic subobjects.
   For example, it could be used to prove that the lift of a collection
   of linear_maps on a union of submodules preserves scalar multiplication. -/
-theorem unionᵢLift_unary (u : T → T) (ui : ∀ i, S i → S i)
+theorem iUnionLift_unary (u : T → T) (ui : ∀ i, S i → S i)
     (hui :
       ∀ (i) (x : S i),
-        u (Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_unionᵢ S i) x) =
-          Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_unionᵢ S i) (ui i x))
+        u (Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_iUnion S i) x) =
+          Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_iUnion S i) (ui i x))
     (uβ : β → β) (h : ∀ (i) (x : S i), f i (ui i x) = uβ (f i x)) (x : T) :
-    unionᵢLift S f hf T (le_of_eq hT') (u x) = uβ (unionᵢLift S f hf T (le_of_eq hT') x) := by
+    iUnionLift S f hf T (le_of_eq hT') (u x) = uβ (iUnionLift S f hf T (le_of_eq hT') x) := by
   subst hT'
-  cases' Set.mem_unionᵢ.1 x.prop with i hi
-  rw [unionᵢLift_of_mem x hi, ← h i]
-  have : x = Set.inclusion (Set.subset_unionᵢ S i) ⟨x, hi⟩ := by
+  cases' Set.mem_iUnion.1 x.prop with i hi
+  rw [iUnionLift_of_mem x hi, ← h i]
+  have : x = Set.inclusion (Set.subset_iUnion S i) ⟨x, hi⟩ := by
     cases x
     rfl
-  conv_lhs => rw [this, hui, unionᵢLift_inclusion]
-#align set.Union_lift_unary Set.unionᵢLift_unary
+  conv_lhs => rw [this, hui, iUnionLift_inclusion]
+#align set.Union_lift_unary Set.iUnionLift_unary
 
-/-- `unionᵢLift_binary` is useful for proving that `unionᵢLift` is a homomorphism
+/-- `iUnionLift_binary` is useful for proving that `iUnionLift` is a homomorphism
   of algebraic structures when defined on the Union of algebraic subobjects.
   For example, it could be used to prove that the lift of a collection
   of group homomorphisms on a union of subgroups preserves `*`. -/
-theorem unionᵢLift_binary (dir : Directed (· ≤ ·) S) (op : T → T → T) (opi : ∀ i, S i → S i → S i)
+theorem iUnionLift_binary (dir : Directed (· ≤ ·) S) (op : T → T → T) (opi : ∀ i, S i → S i → S i)
     (hopi :
       ∀ i x y,
-        Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_unionᵢ S i) (opi i x y) =
-          op (Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_unionᵢ S i) x)
-            (Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_unionᵢ S i) y))
+        Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_iUnion S i) (opi i x y) =
+          op (Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_iUnion S i) x)
+            (Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_iUnion S i) y))
     (opβ : β → β → β) (h : ∀ (i) (x y : S i), f i (opi i x y) = opβ (f i x) (f i y)) (x y : T) :
-    unionᵢLift S f hf T (le_of_eq hT') (op x y) =
-      opβ (unionᵢLift S f hf T (le_of_eq hT') x) (unionᵢLift S f hf T (le_of_eq hT') y) := by
+    iUnionLift S f hf T (le_of_eq hT') (op x y) =
+      opβ (iUnionLift S f hf T (le_of_eq hT') x) (iUnionLift S f hf T (le_of_eq hT') y) := by
   subst hT'
-  cases' Set.mem_unionᵢ.1 x.prop with i hi
-  cases' Set.mem_unionᵢ.1 y.prop with j hj
+  cases' Set.mem_iUnion.1 x.prop with i hi
+  cases' Set.mem_iUnion.1 y.prop with j hj
   rcases dir i j with ⟨k, hik, hjk⟩
-  rw [unionᵢLift_of_mem x (hik hi), unionᵢLift_of_mem y (hjk hj), ← h k]
-  have hx : x = Set.inclusion (Set.subset_unionᵢ S k) ⟨x, hik hi⟩ := by
+  rw [iUnionLift_of_mem x (hik hi), iUnionLift_of_mem y (hjk hj), ← h k]
+  have hx : x = Set.inclusion (Set.subset_iUnion S k) ⟨x, hik hi⟩ := by
     cases x
     rfl
-  have hy : y = Set.inclusion (Set.subset_unionᵢ S k) ⟨y, hjk hj⟩ := by
+  have hy : y = Set.inclusion (Set.subset_iUnion S k) ⟨y, hjk hj⟩ := by
     cases y
     rfl
-  have hxy : (Set.inclusion (Set.subset_unionᵢ S k) (opi k ⟨x, hik hi⟩ ⟨y, hjk hj⟩) : α) ∈ S k :=
+  have hxy : (Set.inclusion (Set.subset_iUnion S k) (opi k ⟨x, hik hi⟩ ⟨y, hjk hj⟩) : α) ∈ S k :=
     (opi k ⟨x, hik hi⟩ ⟨y, hjk hj⟩).prop
-  conv_lhs => rw [hx, hy, ← hopi, unionᵢLift_of_mem _ hxy]
-#align set.Union_lift_binary Set.unionᵢLift_binary
+  conv_lhs => rw [hx, hy, ← hopi, iUnionLift_of_mem _ hxy]
+#align set.Union_lift_binary Set.iUnionLift_binary
 
 end UnionLift
 
 variable {S : ι → Set α} {f : ∀ (i) (_ : S i), β}
   {hf : ∀ (i j) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩}
-  {hS : unionᵢ S = univ}
+  {hS : iUnion S = univ}
 
 /-- Glue together functions defined on each of a collection `S` of sets that cover a type. See
-  also `Set.unionᵢLift`.   -/
+  also `Set.iUnionLift`.   -/
 noncomputable def liftCover (S : ι → Set α) (f : ∀ (i) (_ : S i), β)
     (hf : ∀ (i j) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩)
-    (hS : unionᵢ S = univ) (a : α) : β :=
-  unionᵢLift S f hf univ hS.symm.subset ⟨a, trivial⟩
+    (hS : iUnion S = univ) (a : α) : β :=
+  iUnionLift S f hf univ hS.symm.subset ⟨a, trivial⟩
 #align set.lift_cover Set.liftCover
 
 @[simp]
 theorem liftCover_coe {i : ι} (x : S i) : liftCover S f hf hS x = f i x :=
-  unionᵢLift_mk x _
+  iUnionLift_mk x _
 #align set.lift_cover_coe Set.liftCover_coe
 
 theorem liftCover_of_mem {i : ι} {x : α} (hx : (x : α) ∈ S i) :
     liftCover S f hf hS x = f i ⟨x, hx⟩ :=
-  unionᵢLift_of_mem (⟨x, trivial⟩ : {_z // True}) hx
+  iUnionLift_of_mem (⟨x, trivial⟩ : {_z // True}) hx
 #align set.lift_cover_of_mem Set.liftCover_of_mem
 
 theorem preimage_liftCover (t : Set β) : liftCover S f hf hS ⁻¹' t = ⋃ i, (↑) '' (f i ⁻¹' t) := by
-  change (unionᵢLift S f hf univ hS.symm.subset ∘ fun a => ⟨a, mem_univ a⟩) ⁻¹' t = _
-  rw [preimage_comp, preimage_unionᵢLift]
+  change (iUnionLift S f hf univ hS.symm.subset ∘ fun a => ⟨a, mem_univ a⟩) ⁻¹' t = _
+  rw [preimage_comp, preimage_iUnionLift]
   ext; simp
 
 end Set

Co-authored-by: Johan Commelin <johan@commelin.net>

@@ -79,6 +79,19 @@ theorem unionᵢLift_of_mem (x : T) {i : ι} (hx : (x : α) ∈ S i) :
     unionᵢLift S f hf T hT x = f i ⟨x, hx⟩ := by cases' x with x hx; exact hf _ _ _ _ _
 #align set.Union_lift_of_mem Set.unionᵢLift_of_mem
 
+theorem preimage_unionᵢLift (t : Set β) :
+    unionᵢLift S f hf T hT ⁻¹' t =
+      inclusion hT ⁻¹' (⋃ i, inclusion (subset_unionᵢ S i) '' (f i ⁻¹' t)) := by
+  ext x
+  simp only [mem_preimage, mem_unionᵢ, mem_image]
+  constructor
+  · rcases mem_unionᵢ.1 (hT x.prop) with ⟨i, hi⟩
+    refine fun h => ⟨i, ⟨x, hi⟩, ?_, rfl⟩
+    rwa [unionᵢLift_of_mem x hi] at h
+  · rintro ⟨i, ⟨y, hi⟩, h, hxy⟩
+    obtain rfl : y = x := congr_arg Subtype.val hxy
+    rwa [unionᵢLift_of_mem x hi]
+
 /-- `unionᵢLift_const` is useful for proving that `unionᵢLift` is a homomorphism
   of algebraic structures when defined on the Union of algebraic subobjects.
   For example, it could be used to prove that the lift of a collection
@@ -150,7 +163,7 @@ variable {S : ι → Set α} {f : ∀ (i) (_ : S i), β}
 noncomputable def liftCover (S : ι → Set α) (f : ∀ (i) (_ : S i), β)
     (hf : ∀ (i j) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩)
     (hS : unionᵢ S = univ) (a : α) : β :=
-  unionᵢLift S f hf univ (hS ▸ Set.Subset.refl _) ⟨a, trivial⟩
+  unionᵢLift S f hf univ hS.symm.subset ⟨a, trivial⟩
 #align set.lift_cover Set.liftCover
 
 @[simp]
@@ -163,4 +176,9 @@ theorem liftCover_of_mem {i : ι} {x : α} (hx : (x : α) ∈ S i) :
   unionᵢLift_of_mem (⟨x, trivial⟩ : {_z // True}) hx
 #align set.lift_cover_of_mem Set.liftCover_of_mem
 
+theorem preimage_liftCover (t : Set β) : liftCover S f hf hS ⁻¹' t = ⋃ i, (↑) '' (f i ⁻¹' t) := by
+  change (unionᵢLift S f hf univ hS.symm.subset ∘ fun a => ⟨a, mem_univ a⟩) ⁻¹' t = _
+  rw [preimage_comp, preimage_unionᵢLift]
+  ext; simp
+
 end Set

During porting, I usually fix the desired format we seem to want for the line breaks around by with

awk '{do {{if (match($0, "^  by$") && length(p) < 98) {p=p " by";} else {if (NR!=1) {print p}; p=$0}}} while (getline == 1) if (getline==0) print p}' Mathlib/File/Im/Working/On.lean

I noticed there are some more files that slipped through.

This pull request is the result of running this command:

grep -lr "^  by\$" Mathlib | xargs -n 1 awk -i inplace '{do {{if (match($0, "^  by$") && length(p) < 98 && not (match(p, "^[ \t]*--"))) {p=p " by";} else {if (NR!=1) {print p}; p=$0}}} while (getline == 1) if (getline==0) print p}'

Co-authored-by: Moritz Firsching <firsching@google.com>

@@ -122,8 +122,7 @@ theorem unionᵢLift_binary (dir : Directed (· ≤ ·) S) (op : T → T → T)
             (Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_unionᵢ S i) y))
     (opβ : β → β → β) (h : ∀ (i) (x y : S i), f i (opi i x y) = opβ (f i x) (f i y)) (x y : T) :
     unionᵢLift S f hf T (le_of_eq hT') (op x y) =
-      opβ (unionᵢLift S f hf T (le_of_eq hT') x) (unionᵢLift S f hf T (le_of_eq hT') y) :=
-  by
+      opβ (unionᵢLift S f hf T (le_of_eq hT') x) (unionᵢLift S f hf T (le_of_eq hT') y) := by
   subst hT'
   cases' Set.mem_unionᵢ.1 x.prop with i hi
   cases' Set.mem_unionᵢ.1 y.prop with j hj

These were mostly added in the process of porting and weren't removed at the end. There was one that may have been needed, let's see what CI says.

@@ -41,8 +41,6 @@ constants, unary functions, or binary functions are preserved. These lemmas are:
 directed union, directed supremum, glue, gluing
 -/
 
-set_option autoImplicit false
-
 variable {α ι β : Type _}
 
 namespace Set