data.set.sups ⟷ Mathlib.Data.Set.Sups

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

@@ -3,8 +3,8 @@ Copyright (c) 2022 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
 -/
-import Mathbin.Data.Set.NAry
-import Mathbin.Order.UpperLower.Basic
+import Data.Set.NAry
+import Order.UpperLower.Basic
 
 #align_import data.set.sups from "leanprover-community/mathlib"@"97eab48559068f3d6313da387714ef25768fb730"
 

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

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
-
-! This file was ported from Lean 3 source module data.set.sups
-! leanprover-community/mathlib commit 97eab48559068f3d6313da387714ef25768fb730
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Set.NAry
 import Mathbin.Order.UpperLower.Basic
 
+#align_import data.set.sups from "leanprover-community/mathlib"@"97eab48559068f3d6313da387714ef25768fb730"
+
 /-!
 # Set family operations
 

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

@@ -54,13 +54,11 @@ class HasInfs (α : Type _) where
 #align has_infs HasInfs
 -/
 
--- mathport name: «expr ⊻ »
 infixl:74
   " ⊻ " =>-- This notation is meant to have higher precedence than `⊔` and `⊓`, but still within the realm of
   -- other binary operations
   HasSups.sups
 
--- mathport name: «expr ⊼ »
 infixl:75 " ⊼ " => HasInfs.infs
 
 namespace Set
@@ -80,13 +78,17 @@ scoped[SetFamily] attribute [instance] Set.hasSups
 
 variable {s s₁ s₂ t t₁ t₂ u} {a b c : α}
 
+#print Set.mem_sups /-
 @[simp]
 theorem mem_sups : c ∈ s ⊻ t ↔ ∃ a ∈ s, ∃ b ∈ t, a ⊔ b = c := by simp [(· ⊻ ·)]
 #align set.mem_sups Set.mem_sups
+-/
 
+#print Set.sup_mem_sups /-
 theorem sup_mem_sups : a ∈ s → b ∈ t → a ⊔ b ∈ s ⊻ t :=
   mem_image2_of_mem
 #align set.sup_mem_sups Set.sup_mem_sups
+-/
 
 #print Set.sups_subset /-
 theorem sups_subset : s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ ⊻ t₁ ⊆ s₂ ⊻ t₂ :=
@@ -106,22 +108,30 @@ theorem sups_subset_right : s₁ ⊆ s₂ → s₁ ⊻ t ⊆ s₂ ⊻ t :=
 #align set.sups_subset_right Set.sups_subset_right
 -/
 
+#print Set.image_subset_sups_left /-
 theorem image_subset_sups_left : b ∈ t → (fun a => a ⊔ b) '' s ⊆ s ⊻ t :=
   image_subset_image2_left
 #align set.image_subset_sups_left Set.image_subset_sups_left
+-/
 
+#print Set.image_subset_sups_right /-
 theorem image_subset_sups_right : a ∈ s → (· ⊔ ·) a '' t ⊆ s ⊻ t :=
   image_subset_image2_right
 #align set.image_subset_sups_right Set.image_subset_sups_right
+-/
 
+#print Set.forall_sups_iff /-
 theorem forall_sups_iff {p : α → Prop} : (∀ c ∈ s ⊻ t, p c) ↔ ∀ a ∈ s, ∀ b ∈ t, p (a ⊔ b) :=
   forall_image2_iff
 #align set.forall_sups_iff Set.forall_sups_iff
+-/
 
+#print Set.sups_subset_iff /-
 @[simp]
 theorem sups_subset_iff : s ⊻ t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a ⊔ b ∈ u :=
   image2_subset_iff
 #align set.sups_subset_iff Set.sups_subset_iff
+-/
 
 #print Set.sups_nonempty /-
 @[simp]
@@ -169,51 +179,71 @@ theorem sups_eq_empty : s ⊻ t = ∅ ↔ s = ∅ ∨ t = ∅ :=
 #align set.sups_eq_empty Set.sups_eq_empty
 -/
 
+#print Set.singleton_sups /-
 @[simp]
 theorem singleton_sups : {a} ⊻ t = t.image fun b => a ⊔ b :=
   image2_singleton_left
 #align set.singleton_sups Set.singleton_sups
+-/
 
+#print Set.sups_singleton /-
 @[simp]
 theorem sups_singleton : s ⊻ {b} = s.image fun a => a ⊔ b :=
   image2_singleton_right
 #align set.sups_singleton Set.sups_singleton
+-/
 
+#print Set.singleton_sups_singleton /-
 theorem singleton_sups_singleton : ({a} ⊻ {b} : Set α) = {a ⊔ b} :=
   image2_singleton
 #align set.singleton_sups_singleton Set.singleton_sups_singleton
+-/
 
+#print Set.sups_union_left /-
 theorem sups_union_left : (s₁ ∪ s₂) ⊻ t = s₁ ⊻ t ∪ s₂ ⊻ t :=
   image2_union_left
 #align set.sups_union_left Set.sups_union_left
+-/
 
+#print Set.sups_union_right /-
 theorem sups_union_right : s ⊻ (t₁ ∪ t₂) = s ⊻ t₁ ∪ s ⊻ t₂ :=
   image2_union_right
 #align set.sups_union_right Set.sups_union_right
+-/
 
+#print Set.sups_inter_subset_left /-
 theorem sups_inter_subset_left : (s₁ ∩ s₂) ⊻ t ⊆ s₁ ⊻ t ∩ s₂ ⊻ t :=
   image2_inter_subset_left
 #align set.sups_inter_subset_left Set.sups_inter_subset_left
+-/
 
+#print Set.sups_inter_subset_right /-
 theorem sups_inter_subset_right : s ⊻ (t₁ ∩ t₂) ⊆ s ⊻ t₁ ∩ s ⊻ t₂ :=
   image2_inter_subset_right
 #align set.sups_inter_subset_right Set.sups_inter_subset_right
+-/
 
 variable (s t u v)
 
+#print Set.iUnion_image_sup_left /-
 theorem iUnion_image_sup_left : (⋃ a ∈ s, (· ⊔ ·) a '' t) = s ⊻ t :=
   iUnion_image_left _
 #align set.Union_image_sup_left Set.iUnion_image_sup_left
+-/
 
+#print Set.iUnion_image_sup_right /-
 theorem iUnion_image_sup_right : (⋃ b ∈ t, (· ⊔ b) '' s) = s ⊻ t :=
   iUnion_image_right _
 #align set.Union_image_sup_right Set.iUnion_image_sup_right
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.image_sup_prod /-
 @[simp]
 theorem image_sup_prod (s t : Set α) : (s ×ˢ t).image (uncurry (· ⊔ ·)) = s ⊻ t :=
   image_uncurry_prod _ _ _
 #align set.image_sup_prod Set.image_sup_prod
+-/
 
 #print Set.sups_assoc /-
 theorem sups_assoc : s ⊻ t ⊻ u = s ⊻ (t ⊻ u) :=
@@ -262,13 +292,17 @@ scoped[SetFamily] attribute [instance] Set.hasInfs
 
 variable {s s₁ s₂ t t₁ t₂ u} {a b c : α}
 
+#print Set.mem_infs /-
 @[simp]
 theorem mem_infs : c ∈ s ⊼ t ↔ ∃ a ∈ s, ∃ b ∈ t, a ⊓ b = c := by simp [(· ⊼ ·)]
 #align set.mem_infs Set.mem_infs
+-/
 
+#print Set.inf_mem_infs /-
 theorem inf_mem_infs : a ∈ s → b ∈ t → a ⊓ b ∈ s ⊼ t :=
   mem_image2_of_mem
 #align set.inf_mem_infs Set.inf_mem_infs
+-/
 
 #print Set.infs_subset /-
 theorem infs_subset : s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ ⊼ t₁ ⊆ s₂ ⊼ t₂ :=
@@ -288,22 +322,30 @@ theorem infs_subset_right : s₁ ⊆ s₂ → s₁ ⊼ t ⊆ s₂ ⊼ t :=
 #align set.infs_subset_right Set.infs_subset_right
 -/
 
+#print Set.image_subset_infs_left /-
 theorem image_subset_infs_left : b ∈ t → (fun a => a ⊓ b) '' s ⊆ s ⊼ t :=
   image_subset_image2_left
 #align set.image_subset_infs_left Set.image_subset_infs_left
+-/
 
+#print Set.image_subset_infs_right /-
 theorem image_subset_infs_right : a ∈ s → (· ⊓ ·) a '' t ⊆ s ⊼ t :=
   image_subset_image2_right
 #align set.image_subset_infs_right Set.image_subset_infs_right
+-/
 
+#print Set.forall_infs_iff /-
 theorem forall_infs_iff {p : α → Prop} : (∀ c ∈ s ⊼ t, p c) ↔ ∀ a ∈ s, ∀ b ∈ t, p (a ⊓ b) :=
   forall_image2_iff
 #align set.forall_infs_iff Set.forall_infs_iff
+-/
 
+#print Set.infs_subset_iff /-
 @[simp]
 theorem infs_subset_iff : s ⊼ t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a ⊓ b ∈ u :=
   image2_subset_iff
 #align set.infs_subset_iff Set.infs_subset_iff
+-/
 
 #print Set.infs_nonempty /-
 @[simp]
@@ -351,51 +393,71 @@ theorem infs_eq_empty : s ⊼ t = ∅ ↔ s = ∅ ∨ t = ∅ :=
 #align set.infs_eq_empty Set.infs_eq_empty
 -/
 
+#print Set.singleton_infs /-
 @[simp]
 theorem singleton_infs : {a} ⊼ t = t.image fun b => a ⊓ b :=
   image2_singleton_left
 #align set.singleton_infs Set.singleton_infs
+-/
 
+#print Set.infs_singleton /-
 @[simp]
 theorem infs_singleton : s ⊼ {b} = s.image fun a => a ⊓ b :=
   image2_singleton_right
 #align set.infs_singleton Set.infs_singleton
+-/
 
+#print Set.singleton_infs_singleton /-
 theorem singleton_infs_singleton : ({a} ⊼ {b} : Set α) = {a ⊓ b} :=
   image2_singleton
 #align set.singleton_infs_singleton Set.singleton_infs_singleton
+-/
 
+#print Set.infs_union_left /-
 theorem infs_union_left : (s₁ ∪ s₂) ⊼ t = s₁ ⊼ t ∪ s₂ ⊼ t :=
   image2_union_left
 #align set.infs_union_left Set.infs_union_left
+-/
 
+#print Set.infs_union_right /-
 theorem infs_union_right : s ⊼ (t₁ ∪ t₂) = s ⊼ t₁ ∪ s ⊼ t₂ :=
   image2_union_right
 #align set.infs_union_right Set.infs_union_right
+-/
 
+#print Set.infs_inter_subset_left /-
 theorem infs_inter_subset_left : (s₁ ∩ s₂) ⊼ t ⊆ s₁ ⊼ t ∩ s₂ ⊼ t :=
   image2_inter_subset_left
 #align set.infs_inter_subset_left Set.infs_inter_subset_left
+-/
 
+#print Set.infs_inter_subset_right /-
 theorem infs_inter_subset_right : s ⊼ (t₁ ∩ t₂) ⊆ s ⊼ t₁ ∩ s ⊼ t₂ :=
   image2_inter_subset_right
 #align set.infs_inter_subset_right Set.infs_inter_subset_right
+-/
 
 variable (s t u v)
 
+#print Set.iUnion_image_inf_left /-
 theorem iUnion_image_inf_left : (⋃ a ∈ s, (· ⊓ ·) a '' t) = s ⊼ t :=
   iUnion_image_left _
 #align set.Union_image_inf_left Set.iUnion_image_inf_left
+-/
 
+#print Set.iUnion_image_inf_right /-
 theorem iUnion_image_inf_right : (⋃ b ∈ t, (· ⊓ b) '' s) = s ⊼ t :=
   iUnion_image_right _
 #align set.Union_image_inf_right Set.iUnion_image_inf_right
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.image_inf_prod /-
 @[simp]
 theorem image_inf_prod (s t : Set α) : (s ×ˢ t).image (uncurry (· ⊓ ·)) = s ⊼ t :=
   image_uncurry_prod _ _ _
 #align set.image_inf_prod Set.image_inf_prod
+-/
 
 #print Set.infs_assoc /-
 theorem infs_assoc : s ⊼ t ⊼ u = s ⊼ (t ⊼ u) :=
@@ -465,6 +527,7 @@ end Set
 
 open scoped SetFamily
 
+#print upperClosure_sups /-
 @[simp]
 theorem upperClosure_sups [SemilatticeSup α] (s t : Set α) :
     upperClosure (s ⊻ t) = upperClosure s ⊔ upperClosure t :=
@@ -478,7 +541,9 @@ theorem upperClosure_sups [SemilatticeSup α] (s t : Set α) :
   · rintro ⟨⟨b, hb, hab⟩, c, hc, hac⟩
     exact ⟨_, ⟨b, hb, c, hc, rfl⟩, sup_le hab hac⟩
 #align upper_closure_sups upperClosure_sups
+-/
 
+#print lowerClosure_infs /-
 @[simp]
 theorem lowerClosure_infs [SemilatticeInf α] (s t : Set α) :
     lowerClosure (s ⊼ t) = lowerClosure s ⊓ lowerClosure t :=
@@ -492,4 +557,5 @@ theorem lowerClosure_infs [SemilatticeInf α] (s t : Set α) :
   · rintro ⟨⟨b, hb, hab⟩, c, hc, hac⟩
     exact ⟨_, ⟨b, hb, c, hc, rfl⟩, le_inf hab hac⟩
 #align lower_closure_infs lowerClosure_infs
+-/
 

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

@@ -429,7 +429,7 @@ theorem infs_infs_infs_comm : s ⊼ t ⊼ (u ⊼ v) = s ⊼ u ⊼ (t ⊼ v) :=
 
 end Infs
 
-open SetFamily
+open scoped SetFamily
 
 section DistribLattice
 
@@ -463,7 +463,7 @@ end DistribLattice
 
 end Set
 
-open SetFamily
+open scoped SetFamily
 
 @[simp]
 theorem upperClosure_sups [SemilatticeSup α] (s t : Set α) :

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

@@ -80,22 +80,10 @@ scoped[SetFamily] attribute [instance] Set.hasSups
 
 variable {s s₁ s₂ t t₁ t₂ u} {a b c : α}
 
-/- warning: set.mem_sups -> Set.mem_sups is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {c : α}, Iff (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) c (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)) (Exists.{succ u1} α (fun (a : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) => Exists.{succ u1} α (fun (b : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) => Eq.{succ u1} α (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b) c)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {c : α}, Iff (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) c (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)) (Exists.{succ u1} α (fun (a : α) => And (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) (Exists.{succ u1} α (fun (b : α) => And (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) (Eq.{succ u1} α (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b) c)))))
-Case conversion may be inaccurate. Consider using '#align set.mem_sups Set.mem_supsₓ'. -/
 @[simp]
 theorem mem_sups : c ∈ s ⊻ t ↔ ∃ a ∈ s, ∃ b ∈ t, a ⊔ b = c := by simp [(· ⊻ ·)]
 #align set.mem_sups Set.mem_sups
 
-/- warning: set.sup_mem_sups -> Set.sup_mem_sups is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t))
-Case conversion may be inaccurate. Consider using '#align set.sup_mem_sups Set.sup_mem_supsₓ'. -/
 theorem sup_mem_sups : a ∈ s → b ∈ t → a ⊔ b ∈ s ⊻ t :=
   mem_image2_of_mem
 #align set.sup_mem_sups Set.sup_mem_sups
@@ -118,42 +106,18 @@ theorem sups_subset_right : s₁ ⊆ s₂ → s₁ ⊻ t ⊆ s₂ ⊻ t :=
 #align set.sups_subset_right Set.sups_subset_right
 -/
 
-/- warning: set.image_subset_sups_left -> Set.image_subset_sups_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.image.{u1, u1} α α (fun (a : α) => Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b) s) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Set.image.{u1, u1} α α (fun (a : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b) s) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t))
-Case conversion may be inaccurate. Consider using '#align set.image_subset_sups_left Set.image_subset_sups_leftₓ'. -/
 theorem image_subset_sups_left : b ∈ t → (fun a => a ⊔ b) '' s ⊆ s ⊻ t :=
   image_subset_image2_left
 #align set.image_subset_sups_left Set.image_subset_sups_left
 
-/- warning: set.image_subset_sups_right -> Set.image_subset_sups_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {a : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.image.{u1, u1} α α (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a) t) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {a : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Set.image.{u1, u1} α α ((fun (x._@.Mathlib.Data.Set.Sups._hyg.1635 : α) (x._@.Mathlib.Data.Set.Sups._hyg.1637 : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) x._@.Mathlib.Data.Set.Sups._hyg.1635 x._@.Mathlib.Data.Set.Sups._hyg.1637) a) t) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t))
-Case conversion may be inaccurate. Consider using '#align set.image_subset_sups_right Set.image_subset_sups_rightₓ'. -/
 theorem image_subset_sups_right : a ∈ s → (· ⊔ ·) a '' t ⊆ s ⊻ t :=
   image_subset_image2_right
 #align set.image_subset_sups_right Set.image_subset_sups_right
 
-/- warning: set.forall_sups_iff -> Set.forall_sups_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {p : α -> Prop}, Iff (forall (c : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) c (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)) -> (p c)) (forall (a : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (forall (b : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) -> (p (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {p : α -> Prop}, Iff (forall (c : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) c (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)) -> (p c)) (forall (a : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (forall (b : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) -> (p (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b))))
-Case conversion may be inaccurate. Consider using '#align set.forall_sups_iff Set.forall_sups_iffₓ'. -/
 theorem forall_sups_iff {p : α → Prop} : (∀ c ∈ s ⊻ t, p c) ↔ ∀ a ∈ s, ∀ b ∈ t, p (a ⊔ b) :=
   forall_image2_iff
 #align set.forall_sups_iff Set.forall_sups_iff
 
-/- warning: set.sups_subset_iff -> Set.sups_subset_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {u : Set.{u1} α}, Iff (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t) u) (forall (a : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (forall (b : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b) u)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {u : Set.{u1} α}, Iff (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t) u) (forall (a : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (forall (b : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b) u)))
-Case conversion may be inaccurate. Consider using '#align set.sups_subset_iff Set.sups_subset_iffₓ'. -/
 @[simp]
 theorem sups_subset_iff : s ⊻ t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a ⊔ b ∈ u :=
   image2_subset_iff
@@ -205,106 +169,46 @@ theorem sups_eq_empty : s ⊻ t = ∅ ↔ s = ∅ ∨ t = ∅ :=
 #align set.sups_eq_empty Set.sups_eq_empty
 -/
 
-/- warning: set.singleton_sups -> Set.singleton_sups is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {t : Set.{u1} α} {a : α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) a) t) (Set.image.{u1, u1} α α (fun (b : α) => Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b) t)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {t : Set.{u1} α} {a : α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) a) t) (Set.image.{u1, u1} α α (fun (b : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b) t)
-Case conversion may be inaccurate. Consider using '#align set.singleton_sups Set.singleton_supsₓ'. -/
 @[simp]
 theorem singleton_sups : {a} ⊻ t = t.image fun b => a ⊔ b :=
   image2_singleton_left
 #align set.singleton_sups Set.singleton_sups
 
-/- warning: set.sups_singleton -> Set.sups_singleton is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {b : α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) b)) (Set.image.{u1, u1} α α (fun (a : α) => Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b) s)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {b : α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) b)) (Set.image.{u1, u1} α α (fun (a : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b) s)
-Case conversion may be inaccurate. Consider using '#align set.sups_singleton Set.sups_singletonₓ'. -/
 @[simp]
 theorem sups_singleton : s ⊻ {b} = s.image fun a => a ⊔ b :=
   image2_singleton_right
 #align set.sups_singleton Set.sups_singleton
 
-/- warning: set.singleton_sups_singleton -> Set.singleton_sups_singleton is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {a : α} {b : α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) a) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) b)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {a : α} {b : α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) a) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) b)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b))
-Case conversion may be inaccurate. Consider using '#align set.singleton_sups_singleton Set.singleton_sups_singletonₓ'. -/
 theorem singleton_sups_singleton : ({a} ⊻ {b} : Set α) = {a ⊔ b} :=
   image2_singleton
 #align set.singleton_sups_singleton Set.singleton_sups_singleton
 
-/- warning: set.sups_union_left -> Set.sups_union_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s₁ s₂) t) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s₁ t) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s₂ t))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s₁ s₂) t) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s₁ t) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s₂ t))
-Case conversion may be inaccurate. Consider using '#align set.sups_union_left Set.sups_union_leftₓ'. -/
 theorem sups_union_left : (s₁ ∪ s₂) ⊻ t = s₁ ⊻ t ∪ s₂ ⊻ t :=
   image2_union_left
 #align set.sups_union_left Set.sups_union_left
 
-/- warning: set.sups_union_right -> Set.sups_union_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t₁ : Set.{u1} α} {t₂ : Set.{u1} α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) t₁ t₂)) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t₁) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t₂))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t₁ : Set.{u1} α} {t₂ : Set.{u1} α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) t₁ t₂)) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t₁) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t₂))
-Case conversion may be inaccurate. Consider using '#align set.sups_union_right Set.sups_union_rightₓ'. -/
 theorem sups_union_right : s ⊻ (t₁ ∪ t₂) = s ⊻ t₁ ∪ s ⊻ t₂ :=
   image2_union_right
 #align set.sups_union_right Set.sups_union_right
 
-/- warning: set.sups_inter_subset_left -> Set.sups_inter_subset_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t : Set.{u1} α}, HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s₁ s₂) t) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s₁ t) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s₂ t))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t : Set.{u1} α}, HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s₁ s₂) t) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s₁ t) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s₂ t))
-Case conversion may be inaccurate. Consider using '#align set.sups_inter_subset_left Set.sups_inter_subset_leftₓ'. -/
 theorem sups_inter_subset_left : (s₁ ∩ s₂) ⊻ t ⊆ s₁ ⊻ t ∩ s₂ ⊻ t :=
   image2_inter_subset_left
 #align set.sups_inter_subset_left Set.sups_inter_subset_left
 
-/- warning: set.sups_inter_subset_right -> Set.sups_inter_subset_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t₁ : Set.{u1} α} {t₂ : Set.{u1} α}, HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) t₁ t₂)) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t₁) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t₂))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t₁ : Set.{u1} α} {t₂ : Set.{u1} α}, HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) t₁ t₂)) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t₁) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t₂))
-Case conversion may be inaccurate. Consider using '#align set.sups_inter_subset_right Set.sups_inter_subset_rightₓ'. -/
 theorem sups_inter_subset_right : s ⊻ (t₁ ∩ t₂) ⊆ s ⊻ t₁ ∩ s ⊻ t₂ :=
   image2_inter_subset_right
 #align set.sups_inter_subset_right Set.sups_inter_subset_right
 
 variable (s t u v)
 
-/- warning: set.Union_image_sup_left -> Set.iUnion_image_sup_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.iUnion.{u1, 0} α (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) => Set.image.{u1, u1} α α (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a) t))) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.iUnion.{u1, 0} α (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) => Set.image.{u1, u1} α α ((fun (x._@.Mathlib.Data.Set.Sups._hyg.2587 : α) (x._@.Mathlib.Data.Set.Sups._hyg.2589 : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) x._@.Mathlib.Data.Set.Sups._hyg.2587 x._@.Mathlib.Data.Set.Sups._hyg.2589) a) t))) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
-Case conversion may be inaccurate. Consider using '#align set.Union_image_sup_left Set.iUnion_image_sup_leftₓ'. -/
 theorem iUnion_image_sup_left : (⋃ a ∈ s, (· ⊔ ·) a '' t) = s ⊻ t :=
   iUnion_image_left _
 #align set.Union_image_sup_left Set.iUnion_image_sup_left
 
-/- warning: set.Union_image_sup_right -> Set.iUnion_image_sup_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (b : α) => Set.iUnion.{u1, 0} α (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) => Set.image.{u1, u1} α α (fun (_x : α) => Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) _x b) s))) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (b : α) => Set.iUnion.{u1, 0} α (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) => Set.image.{u1, u1} α α (fun (_x : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) _x b) s))) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
-Case conversion may be inaccurate. Consider using '#align set.Union_image_sup_right Set.iUnion_image_sup_rightₓ'. -/
 theorem iUnion_image_sup_right : (⋃ b ∈ t, (· ⊔ b) '' s) = s ⊻ t :=
   iUnion_image_right _
 #align set.Union_image_sup_right Set.iUnion_image_sup_right
 
-/- warning: set.image_sup_prod -> Set.image_sup_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.image.{u1, u1} (Prod.{u1, u1} α α) α (Function.uncurry.{u1, u1, u1} α α α (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1))) (Set.prod.{u1, u1} α α s t)) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.image2.{u1, u1, u1} α α α (fun (x : α) (x_1 : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) x x_1) s t) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
-Case conversion may be inaccurate. Consider using '#align set.image_sup_prod Set.image_sup_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem image_sup_prod (s t : Set α) : (s ×ˢ t).image (uncurry (· ⊔ ·)) = s ⊻ t :=
@@ -358,22 +262,10 @@ scoped[SetFamily] attribute [instance] Set.hasInfs
 
 variable {s s₁ s₂ t t₁ t₂ u} {a b c : α}
 
-/- warning: set.mem_infs -> Set.mem_infs is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {c : α}, Iff (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) c (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)) (Exists.{succ u1} α (fun (a : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) => Exists.{succ u1} α (fun (b : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) => Eq.{succ u1} α (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b) c)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {c : α}, Iff (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) c (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)) (Exists.{succ u1} α (fun (a : α) => And (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) (Exists.{succ u1} α (fun (b : α) => And (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) (Eq.{succ u1} α (Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b) c)))))
-Case conversion may be inaccurate. Consider using '#align set.mem_infs Set.mem_infsₓ'. -/
 @[simp]
 theorem mem_infs : c ∈ s ⊼ t ↔ ∃ a ∈ s, ∃ b ∈ t, a ⊓ b = c := by simp [(· ⊼ ·)]
 #align set.mem_infs Set.mem_infs
 
-/- warning: set.inf_mem_infs -> Set.inf_mem_infs is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t))
-Case conversion may be inaccurate. Consider using '#align set.inf_mem_infs Set.inf_mem_infsₓ'. -/
 theorem inf_mem_infs : a ∈ s → b ∈ t → a ⊓ b ∈ s ⊼ t :=
   mem_image2_of_mem
 #align set.inf_mem_infs Set.inf_mem_infs
@@ -396,42 +288,18 @@ theorem infs_subset_right : s₁ ⊆ s₂ → s₁ ⊼ t ⊆ s₂ ⊼ t :=
 #align set.infs_subset_right Set.infs_subset_right
 -/
 
-/- warning: set.image_subset_infs_left -> Set.image_subset_infs_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.image.{u1, u1} α α (fun (a : α) => Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b) s) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Set.image.{u1, u1} α α (fun (a : α) => Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b) s) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t))
-Case conversion may be inaccurate. Consider using '#align set.image_subset_infs_left Set.image_subset_infs_leftₓ'. -/
 theorem image_subset_infs_left : b ∈ t → (fun a => a ⊓ b) '' s ⊆ s ⊼ t :=
   image_subset_image2_left
 #align set.image_subset_infs_left Set.image_subset_infs_left
 
-/- warning: set.image_subset_infs_right -> Set.image_subset_infs_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {a : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.image.{u1, u1} α α (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a) t) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {a : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Set.image.{u1, u1} α α ((fun (x._@.Mathlib.Data.Set.Sups._hyg.3583 : α) (x._@.Mathlib.Data.Set.Sups._hyg.3585 : α) => Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) x._@.Mathlib.Data.Set.Sups._hyg.3583 x._@.Mathlib.Data.Set.Sups._hyg.3585) a) t) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t))
-Case conversion may be inaccurate. Consider using '#align set.image_subset_infs_right Set.image_subset_infs_rightₓ'. -/
 theorem image_subset_infs_right : a ∈ s → (· ⊓ ·) a '' t ⊆ s ⊼ t :=
   image_subset_image2_right
 #align set.image_subset_infs_right Set.image_subset_infs_right
 
-/- warning: set.forall_infs_iff -> Set.forall_infs_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {p : α -> Prop}, Iff (forall (c : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) c (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)) -> (p c)) (forall (a : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (forall (b : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) -> (p (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {p : α -> Prop}, Iff (forall (c : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) c (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)) -> (p c)) (forall (a : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (forall (b : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) -> (p (Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b))))
-Case conversion may be inaccurate. Consider using '#align set.forall_infs_iff Set.forall_infs_iffₓ'. -/
 theorem forall_infs_iff {p : α → Prop} : (∀ c ∈ s ⊼ t, p c) ↔ ∀ a ∈ s, ∀ b ∈ t, p (a ⊓ b) :=
   forall_image2_iff
 #align set.forall_infs_iff Set.forall_infs_iff
 
-/- warning: set.infs_subset_iff -> Set.infs_subset_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {u : Set.{u1} α}, Iff (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t) u) (forall (a : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (forall (b : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b) u)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {u : Set.{u1} α}, Iff (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t) u) (forall (a : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (forall (b : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b) u)))
-Case conversion may be inaccurate. Consider using '#align set.infs_subset_iff Set.infs_subset_iffₓ'. -/
 @[simp]
 theorem infs_subset_iff : s ⊼ t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a ⊓ b ∈ u :=
   image2_subset_iff
@@ -483,106 +351,46 @@ theorem infs_eq_empty : s ⊼ t = ∅ ↔ s = ∅ ∨ t = ∅ :=
 #align set.infs_eq_empty Set.infs_eq_empty
 -/
 
-/- warning: set.singleton_infs -> Set.singleton_infs is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {t : Set.{u1} α} {a : α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) a) t) (Set.image.{u1, u1} α α (fun (b : α) => Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b) t)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {t : Set.{u1} α} {a : α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) a) t) (Set.image.{u1, u1} α α (fun (b : α) => Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b) t)
-Case conversion may be inaccurate. Consider using '#align set.singleton_infs Set.singleton_infsₓ'. -/
 @[simp]
 theorem singleton_infs : {a} ⊼ t = t.image fun b => a ⊓ b :=
   image2_singleton_left
 #align set.singleton_infs Set.singleton_infs
 
-/- warning: set.infs_singleton -> Set.infs_singleton is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {b : α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) b)) (Set.image.{u1, u1} α α (fun (a : α) => Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b) s)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {b : α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) b)) (Set.image.{u1, u1} α α (fun (a : α) => Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b) s)
-Case conversion may be inaccurate. Consider using '#align set.infs_singleton Set.infs_singletonₓ'. -/
 @[simp]
 theorem infs_singleton : s ⊼ {b} = s.image fun a => a ⊓ b :=
   image2_singleton_right
 #align set.infs_singleton Set.infs_singleton
 
-/- warning: set.singleton_infs_singleton -> Set.singleton_infs_singleton is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {a : α} {b : α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) a) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) b)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {a : α} {b : α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) a) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) b)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) (Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b))
-Case conversion may be inaccurate. Consider using '#align set.singleton_infs_singleton Set.singleton_infs_singletonₓ'. -/
 theorem singleton_infs_singleton : ({a} ⊼ {b} : Set α) = {a ⊓ b} :=
   image2_singleton
 #align set.singleton_infs_singleton Set.singleton_infs_singleton
 
-/- warning: set.infs_union_left -> Set.infs_union_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s₁ s₂) t) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s₁ t) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s₂ t))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s₁ s₂) t) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s₁ t) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s₂ t))
-Case conversion may be inaccurate. Consider using '#align set.infs_union_left Set.infs_union_leftₓ'. -/
 theorem infs_union_left : (s₁ ∪ s₂) ⊼ t = s₁ ⊼ t ∪ s₂ ⊼ t :=
   image2_union_left
 #align set.infs_union_left Set.infs_union_left
 
-/- warning: set.infs_union_right -> Set.infs_union_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t₁ : Set.{u1} α} {t₂ : Set.{u1} α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) t₁ t₂)) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t₁) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t₂))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t₁ : Set.{u1} α} {t₂ : Set.{u1} α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) t₁ t₂)) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t₁) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t₂))
-Case conversion may be inaccurate. Consider using '#align set.infs_union_right Set.infs_union_rightₓ'. -/
 theorem infs_union_right : s ⊼ (t₁ ∪ t₂) = s ⊼ t₁ ∪ s ⊼ t₂ :=
   image2_union_right
 #align set.infs_union_right Set.infs_union_right
 
-/- warning: set.infs_inter_subset_left -> Set.infs_inter_subset_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t : Set.{u1} α}, HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s₁ s₂) t) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s₁ t) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s₂ t))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t : Set.{u1} α}, HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s₁ s₂) t) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s₁ t) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s₂ t))
-Case conversion may be inaccurate. Consider using '#align set.infs_inter_subset_left Set.infs_inter_subset_leftₓ'. -/
 theorem infs_inter_subset_left : (s₁ ∩ s₂) ⊼ t ⊆ s₁ ⊼ t ∩ s₂ ⊼ t :=
   image2_inter_subset_left
 #align set.infs_inter_subset_left Set.infs_inter_subset_left
 
-/- warning: set.infs_inter_subset_right -> Set.infs_inter_subset_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t₁ : Set.{u1} α} {t₂ : Set.{u1} α}, HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) t₁ t₂)) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t₁) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t₂))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t₁ : Set.{u1} α} {t₂ : Set.{u1} α}, HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) t₁ t₂)) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t₁) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t₂))
-Case conversion may be inaccurate. Consider using '#align set.infs_inter_subset_right Set.infs_inter_subset_rightₓ'. -/
 theorem infs_inter_subset_right : s ⊼ (t₁ ∩ t₂) ⊆ s ⊼ t₁ ∩ s ⊼ t₂ :=
   image2_inter_subset_right
 #align set.infs_inter_subset_right Set.infs_inter_subset_right
 
 variable (s t u v)
 
-/- warning: set.Union_image_inf_left -> Set.iUnion_image_inf_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.iUnion.{u1, 0} α (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) => Set.image.{u1, u1} α α (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a) t))) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.iUnion.{u1, 0} α (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) => Set.image.{u1, u1} α α ((fun (x._@.Mathlib.Data.Set.Sups._hyg.4535 : α) (x._@.Mathlib.Data.Set.Sups._hyg.4537 : α) => Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) x._@.Mathlib.Data.Set.Sups._hyg.4535 x._@.Mathlib.Data.Set.Sups._hyg.4537) a) t))) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
-Case conversion may be inaccurate. Consider using '#align set.Union_image_inf_left Set.iUnion_image_inf_leftₓ'. -/
 theorem iUnion_image_inf_left : (⋃ a ∈ s, (· ⊓ ·) a '' t) = s ⊼ t :=
   iUnion_image_left _
 #align set.Union_image_inf_left Set.iUnion_image_inf_left
 
-/- warning: set.Union_image_inf_right -> Set.iUnion_image_inf_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (b : α) => Set.iUnion.{u1, 0} α (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) => Set.image.{u1, u1} α α (fun (_x : α) => Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) _x b) s))) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (b : α) => Set.iUnion.{u1, 0} α (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) => Set.image.{u1, u1} α α (fun (_x : α) => Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) _x b) s))) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
-Case conversion may be inaccurate. Consider using '#align set.Union_image_inf_right Set.iUnion_image_inf_rightₓ'. -/
 theorem iUnion_image_inf_right : (⋃ b ∈ t, (· ⊓ b) '' s) = s ⊼ t :=
   iUnion_image_right _
 #align set.Union_image_inf_right Set.iUnion_image_inf_right
 
-/- warning: set.image_inf_prod -> Set.image_inf_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.image.{u1, u1} (Prod.{u1, u1} α α) α (Function.uncurry.{u1, u1, u1} α α α (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1))) (Set.prod.{u1, u1} α α s t)) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.image2.{u1, u1, u1} α α α (fun (x : α) (x_1 : α) => Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) x x_1) s t) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
-Case conversion may be inaccurate. Consider using '#align set.image_inf_prod Set.image_inf_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem image_inf_prod (s t : Set α) : (s ×ˢ t).image (uncurry (· ⊓ ·)) = s ⊼ t :=
@@ -657,12 +465,6 @@ end Set
 
 open SetFamily
 
-/- warning: upper_closure_sups -> upperClosure_sups is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (UpperSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)) (Sup.sup.{u1} (UpperSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (UpperSet.hasSup.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) s) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) t))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (UpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)) (Sup.sup.{u1} (UpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (UpperSet.instSupUpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) s) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) t))
-Case conversion may be inaccurate. Consider using '#align upper_closure_sups upperClosure_supsₓ'. -/
 @[simp]
 theorem upperClosure_sups [SemilatticeSup α] (s t : Set α) :
     upperClosure (s ⊻ t) = upperClosure s ⊔ upperClosure t :=
@@ -677,12 +479,6 @@ theorem upperClosure_sups [SemilatticeSup α] (s t : Set α) :
     exact ⟨_, ⟨b, hb, c, hc, rfl⟩, sup_le hab hac⟩
 #align upper_closure_sups upperClosure_sups
 
-/- warning: lower_closure_infs -> lowerClosure_infs is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (LowerSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)) (Inf.inf.{u1} (LowerSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (LowerSet.hasInf.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) s) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) t))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (LowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)) (Inf.inf.{u1} (LowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (LowerSet.instInfLowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) s) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) t))
-Case conversion may be inaccurate. Consider using '#align lower_closure_infs lowerClosure_infsₓ'. -/
 @[simp]
 theorem lowerClosure_infs [SemilatticeInf α] (s t : Set α) :
     lowerClosure (s ⊼ t) = lowerClosure s ⊓ lowerClosure t :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

@@ -659,7 +659,7 @@ open SetFamily
 
 /- warning: upper_closure_sups -> upperClosure_sups is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (UpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)) (Sup.sup.{u1} (UpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (UpperSet.hasSup.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) s) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) t))
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (UpperSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)) (Sup.sup.{u1} (UpperSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (UpperSet.hasSup.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) s) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) t))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (UpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)) (Sup.sup.{u1} (UpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (UpperSet.instSupUpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) s) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) t))
 Case conversion may be inaccurate. Consider using '#align upper_closure_sups upperClosure_supsₓ'. -/
@@ -679,7 +679,7 @@ theorem upperClosure_sups [SemilatticeSup α] (s t : Set α) :
 
 /- warning: lower_closure_infs -> lowerClosure_infs is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (LowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)) (Inf.inf.{u1} (LowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (LowerSet.hasInf.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) s) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) t))
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (LowerSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)) (Inf.inf.{u1} (LowerSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (LowerSet.hasInf.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) s) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) t))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (LowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)) (Inf.inf.{u1} (LowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (LowerSet.instInfLowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) s) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) t))
 Case conversion may be inaccurate. Consider using '#align lower_closure_infs lowerClosure_infsₓ'. -/

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

@@ -279,25 +279,25 @@ theorem sups_inter_subset_right : s ⊻ (t₁ ∩ t₂) ⊆ s ⊻ t₁ ∩ s ⊻
 
 variable (s t u v)
 
-/- warning: set.Union_image_sup_left -> Set.unionᵢ_image_sup_left is a dubious translation:
+/- warning: set.Union_image_sup_left -> Set.iUnion_image_sup_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α α (fun (a : α) => Set.unionᵢ.{u1, 0} α (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) => Set.image.{u1, u1} α α (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a) t))) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.iUnion.{u1, 0} α (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) => Set.image.{u1, u1} α α (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a) t))) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α α (fun (a : α) => Set.unionᵢ.{u1, 0} α (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) => Set.image.{u1, u1} α α ((fun (x._@.Mathlib.Data.Set.Sups._hyg.2587 : α) (x._@.Mathlib.Data.Set.Sups._hyg.2589 : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) x._@.Mathlib.Data.Set.Sups._hyg.2587 x._@.Mathlib.Data.Set.Sups._hyg.2589) a) t))) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
-Case conversion may be inaccurate. Consider using '#align set.Union_image_sup_left Set.unionᵢ_image_sup_leftₓ'. -/
-theorem unionᵢ_image_sup_left : (⋃ a ∈ s, (· ⊔ ·) a '' t) = s ⊻ t :=
-  unionᵢ_image_left _
-#align set.Union_image_sup_left Set.unionᵢ_image_sup_left
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.iUnion.{u1, 0} α (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) => Set.image.{u1, u1} α α ((fun (x._@.Mathlib.Data.Set.Sups._hyg.2587 : α) (x._@.Mathlib.Data.Set.Sups._hyg.2589 : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) x._@.Mathlib.Data.Set.Sups._hyg.2587 x._@.Mathlib.Data.Set.Sups._hyg.2589) a) t))) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
+Case conversion may be inaccurate. Consider using '#align set.Union_image_sup_left Set.iUnion_image_sup_leftₓ'. -/
+theorem iUnion_image_sup_left : (⋃ a ∈ s, (· ⊔ ·) a '' t) = s ⊻ t :=
+  iUnion_image_left _
+#align set.Union_image_sup_left Set.iUnion_image_sup_left
 
-/- warning: set.Union_image_sup_right -> Set.unionᵢ_image_sup_right is a dubious translation:
+/- warning: set.Union_image_sup_right -> Set.iUnion_image_sup_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α α (fun (b : α) => Set.unionᵢ.{u1, 0} α (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) => Set.image.{u1, u1} α α (fun (_x : α) => Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) _x b) s))) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (b : α) => Set.iUnion.{u1, 0} α (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) => Set.image.{u1, u1} α α (fun (_x : α) => Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) _x b) s))) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α α (fun (b : α) => Set.unionᵢ.{u1, 0} α (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) => Set.image.{u1, u1} α α (fun (_x : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) _x b) s))) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
-Case conversion may be inaccurate. Consider using '#align set.Union_image_sup_right Set.unionᵢ_image_sup_rightₓ'. -/
-theorem unionᵢ_image_sup_right : (⋃ b ∈ t, (· ⊔ b) '' s) = s ⊻ t :=
-  unionᵢ_image_right _
-#align set.Union_image_sup_right Set.unionᵢ_image_sup_right
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (b : α) => Set.iUnion.{u1, 0} α (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) => Set.image.{u1, u1} α α (fun (_x : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) _x b) s))) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
+Case conversion may be inaccurate. Consider using '#align set.Union_image_sup_right Set.iUnion_image_sup_rightₓ'. -/
+theorem iUnion_image_sup_right : (⋃ b ∈ t, (· ⊔ b) '' s) = s ⊻ t :=
+  iUnion_image_right _
+#align set.Union_image_sup_right Set.iUnion_image_sup_right
 
 /- warning: set.image_sup_prod -> Set.image_sup_prod is a dubious translation:
 lean 3 declaration is
@@ -557,25 +557,25 @@ theorem infs_inter_subset_right : s ⊼ (t₁ ∩ t₂) ⊆ s ⊼ t₁ ∩ s ⊼
 
 variable (s t u v)
 
-/- warning: set.Union_image_inf_left -> Set.unionᵢ_image_inf_left is a dubious translation:
+/- warning: set.Union_image_inf_left -> Set.iUnion_image_inf_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α α (fun (a : α) => Set.unionᵢ.{u1, 0} α (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) => Set.image.{u1, u1} α α (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a) t))) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.iUnion.{u1, 0} α (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) => Set.image.{u1, u1} α α (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a) t))) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α α (fun (a : α) => Set.unionᵢ.{u1, 0} α (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) => Set.image.{u1, u1} α α ((fun (x._@.Mathlib.Data.Set.Sups._hyg.4535 : α) (x._@.Mathlib.Data.Set.Sups._hyg.4537 : α) => Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) x._@.Mathlib.Data.Set.Sups._hyg.4535 x._@.Mathlib.Data.Set.Sups._hyg.4537) a) t))) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
-Case conversion may be inaccurate. Consider using '#align set.Union_image_inf_left Set.unionᵢ_image_inf_leftₓ'. -/
-theorem unionᵢ_image_inf_left : (⋃ a ∈ s, (· ⊓ ·) a '' t) = s ⊼ t :=
-  unionᵢ_image_left _
-#align set.Union_image_inf_left Set.unionᵢ_image_inf_left
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.iUnion.{u1, 0} α (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) => Set.image.{u1, u1} α α ((fun (x._@.Mathlib.Data.Set.Sups._hyg.4535 : α) (x._@.Mathlib.Data.Set.Sups._hyg.4537 : α) => Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) x._@.Mathlib.Data.Set.Sups._hyg.4535 x._@.Mathlib.Data.Set.Sups._hyg.4537) a) t))) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
+Case conversion may be inaccurate. Consider using '#align set.Union_image_inf_left Set.iUnion_image_inf_leftₓ'. -/
+theorem iUnion_image_inf_left : (⋃ a ∈ s, (· ⊓ ·) a '' t) = s ⊼ t :=
+  iUnion_image_left _
+#align set.Union_image_inf_left Set.iUnion_image_inf_left
 
-/- warning: set.Union_image_inf_right -> Set.unionᵢ_image_inf_right is a dubious translation:
+/- warning: set.Union_image_inf_right -> Set.iUnion_image_inf_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α α (fun (b : α) => Set.unionᵢ.{u1, 0} α (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) => Set.image.{u1, u1} α α (fun (_x : α) => Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) _x b) s))) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (b : α) => Set.iUnion.{u1, 0} α (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) => Set.image.{u1, u1} α α (fun (_x : α) => Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) _x b) s))) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α α (fun (b : α) => Set.unionᵢ.{u1, 0} α (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) => Set.image.{u1, u1} α α (fun (_x : α) => Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) _x b) s))) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
-Case conversion may be inaccurate. Consider using '#align set.Union_image_inf_right Set.unionᵢ_image_inf_rightₓ'. -/
-theorem unionᵢ_image_inf_right : (⋃ b ∈ t, (· ⊓ b) '' s) = s ⊼ t :=
-  unionᵢ_image_right _
-#align set.Union_image_inf_right Set.unionᵢ_image_inf_right
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (b : α) => Set.iUnion.{u1, 0} α (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) => Set.image.{u1, u1} α α (fun (_x : α) => Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) _x b) s))) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
+Case conversion may be inaccurate. Consider using '#align set.Union_image_inf_right Set.iUnion_image_inf_rightₓ'. -/
+theorem iUnion_image_inf_right : (⋃ b ∈ t, (· ⊓ b) '' s) = s ⊼ t :=
+  iUnion_image_right _
+#align set.Union_image_inf_right Set.iUnion_image_inf_right
 
 /- warning: set.image_inf_prod -> Set.image_inf_prod is a dubious translation:
 lean 3 declaration is

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
 
 ! This file was ported from Lean 3 source module data.set.sups
-! leanprover-community/mathlib commit 20715f4ac6819ef2453d9e5106ecd086a5dc2a5e
+! leanprover-community/mathlib commit 97eab48559068f3d6313da387714ef25768fb730
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.Order.UpperLower.Basic
 /-!
 # Set family operations
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 This file defines a few binary operations on `set α` for use in set family combinatorics.
 
 ## Main declarations

mathlib commit https://github.com/leanprover-community/mathlib/commit/57e09a1296bfb4330ddf6624f1028ba186117d82

@@ -37,15 +37,19 @@ open Function
 
 variable {α : Type _}
 
+#print HasSups /-
 /-- Notation typeclass for pointwise supremum `⊻`. -/
 class HasSups (α : Type _) where
   sups : α → α → α
 #align has_sups HasSups
+-/
 
+#print HasInfs /-
 /-- Notation typeclass for pointwise infimum `⊼`. -/
 class HasInfs (α : Type _) where
   infs : α → α → α
 #align has_infs HasInfs
+-/
 
 -- mathport name: «expr ⊻ »
 infixl:74
@@ -62,149 +66,277 @@ section Sups
 
 variable [SemilatticeSup α] (s s₁ s₂ t t₁ t₂ u v : Set α)
 
+#print Set.hasSups /-
 /-- `s ⊻ t` is the set of elements of the form `a ⊔ b` where `a ∈ s`, `b ∈ t`. -/
 protected def hasSups : HasSups (Set α) :=
   ⟨image2 (· ⊔ ·)⟩
 #align set.has_sups Set.hasSups
+-/
 
 scoped[SetFamily] attribute [instance] Set.hasSups
 
 variable {s s₁ s₂ t t₁ t₂ u} {a b c : α}
 
+/- warning: set.mem_sups -> Set.mem_sups is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {c : α}, Iff (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) c (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)) (Exists.{succ u1} α (fun (a : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) => Exists.{succ u1} α (fun (b : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) => Eq.{succ u1} α (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b) c)))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {c : α}, Iff (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) c (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)) (Exists.{succ u1} α (fun (a : α) => And (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) (Exists.{succ u1} α (fun (b : α) => And (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) (Eq.{succ u1} α (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b) c)))))
+Case conversion may be inaccurate. Consider using '#align set.mem_sups Set.mem_supsₓ'. -/
 @[simp]
 theorem mem_sups : c ∈ s ⊻ t ↔ ∃ a ∈ s, ∃ b ∈ t, a ⊔ b = c := by simp [(· ⊻ ·)]
 #align set.mem_sups Set.mem_sups
 
+/- warning: set.sup_mem_sups -> Set.sup_mem_sups is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t))
+Case conversion may be inaccurate. Consider using '#align set.sup_mem_sups Set.sup_mem_supsₓ'. -/
 theorem sup_mem_sups : a ∈ s → b ∈ t → a ⊔ b ∈ s ⊻ t :=
   mem_image2_of_mem
 #align set.sup_mem_sups Set.sup_mem_sups
 
+#print Set.sups_subset /-
 theorem sups_subset : s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ ⊻ t₁ ⊆ s₂ ⊻ t₂ :=
   image2_subset
 #align set.sups_subset Set.sups_subset
+-/
 
+#print Set.sups_subset_left /-
 theorem sups_subset_left : t₁ ⊆ t₂ → s ⊻ t₁ ⊆ s ⊻ t₂ :=
   image2_subset_left
 #align set.sups_subset_left Set.sups_subset_left
+-/
 
+#print Set.sups_subset_right /-
 theorem sups_subset_right : s₁ ⊆ s₂ → s₁ ⊻ t ⊆ s₂ ⊻ t :=
   image2_subset_right
 #align set.sups_subset_right Set.sups_subset_right
+-/
 
+/- warning: set.image_subset_sups_left -> Set.image_subset_sups_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.image.{u1, u1} α α (fun (a : α) => Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b) s) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Set.image.{u1, u1} α α (fun (a : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b) s) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t))
+Case conversion may be inaccurate. Consider using '#align set.image_subset_sups_left Set.image_subset_sups_leftₓ'. -/
 theorem image_subset_sups_left : b ∈ t → (fun a => a ⊔ b) '' s ⊆ s ⊻ t :=
   image_subset_image2_left
 #align set.image_subset_sups_left Set.image_subset_sups_left
 
+/- warning: set.image_subset_sups_right -> Set.image_subset_sups_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {a : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.image.{u1, u1} α α (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a) t) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {a : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Set.image.{u1, u1} α α ((fun (x._@.Mathlib.Data.Set.Sups._hyg.1635 : α) (x._@.Mathlib.Data.Set.Sups._hyg.1637 : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) x._@.Mathlib.Data.Set.Sups._hyg.1635 x._@.Mathlib.Data.Set.Sups._hyg.1637) a) t) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t))
+Case conversion may be inaccurate. Consider using '#align set.image_subset_sups_right Set.image_subset_sups_rightₓ'. -/
 theorem image_subset_sups_right : a ∈ s → (· ⊔ ·) a '' t ⊆ s ⊻ t :=
   image_subset_image2_right
 #align set.image_subset_sups_right Set.image_subset_sups_right
 
+/- warning: set.forall_sups_iff -> Set.forall_sups_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {p : α -> Prop}, Iff (forall (c : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) c (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)) -> (p c)) (forall (a : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (forall (b : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) -> (p (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {p : α -> Prop}, Iff (forall (c : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) c (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)) -> (p c)) (forall (a : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (forall (b : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) -> (p (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b))))
+Case conversion may be inaccurate. Consider using '#align set.forall_sups_iff Set.forall_sups_iffₓ'. -/
 theorem forall_sups_iff {p : α → Prop} : (∀ c ∈ s ⊻ t, p c) ↔ ∀ a ∈ s, ∀ b ∈ t, p (a ⊔ b) :=
   forall_image2_iff
 #align set.forall_sups_iff Set.forall_sups_iff
 
+/- warning: set.sups_subset_iff -> Set.sups_subset_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {u : Set.{u1} α}, Iff (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t) u) (forall (a : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (forall (b : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b) u)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {u : Set.{u1} α}, Iff (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t) u) (forall (a : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (forall (b : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b) u)))
+Case conversion may be inaccurate. Consider using '#align set.sups_subset_iff Set.sups_subset_iffₓ'. -/
 @[simp]
 theorem sups_subset_iff : s ⊻ t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a ⊔ b ∈ u :=
   image2_subset_iff
 #align set.sups_subset_iff Set.sups_subset_iff
 
+#print Set.sups_nonempty /-
 @[simp]
 theorem sups_nonempty : (s ⊻ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty :=
   image2_nonempty_iff
 #align set.sups_nonempty Set.sups_nonempty
+-/
 
+#print Set.Nonempty.sups /-
 protected theorem Nonempty.sups : s.Nonempty → t.Nonempty → (s ⊻ t).Nonempty :=
   Nonempty.image2
 #align set.nonempty.sups Set.Nonempty.sups
+-/
 
+#print Set.Nonempty.of_sups_left /-
 theorem Nonempty.of_sups_left : (s ⊻ t).Nonempty → s.Nonempty :=
   Nonempty.of_image2_left
 #align set.nonempty.of_sups_left Set.Nonempty.of_sups_left
+-/
 
+#print Set.Nonempty.of_sups_right /-
 theorem Nonempty.of_sups_right : (s ⊻ t).Nonempty → t.Nonempty :=
   Nonempty.of_image2_right
 #align set.nonempty.of_sups_right Set.Nonempty.of_sups_right
+-/
 
+#print Set.empty_sups /-
 @[simp]
 theorem empty_sups : ∅ ⊻ t = ∅ :=
   image2_empty_left
 #align set.empty_sups Set.empty_sups
+-/
 
+#print Set.sups_empty /-
 @[simp]
 theorem sups_empty : s ⊻ ∅ = ∅ :=
   image2_empty_right
 #align set.sups_empty Set.sups_empty
+-/
 
+#print Set.sups_eq_empty /-
 @[simp]
 theorem sups_eq_empty : s ⊻ t = ∅ ↔ s = ∅ ∨ t = ∅ :=
   image2_eq_empty_iff
 #align set.sups_eq_empty Set.sups_eq_empty
+-/
 
+/- warning: set.singleton_sups -> Set.singleton_sups is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {t : Set.{u1} α} {a : α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) a) t) (Set.image.{u1, u1} α α (fun (b : α) => Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b) t)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {t : Set.{u1} α} {a : α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) a) t) (Set.image.{u1, u1} α α (fun (b : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b) t)
+Case conversion may be inaccurate. Consider using '#align set.singleton_sups Set.singleton_supsₓ'. -/
 @[simp]
 theorem singleton_sups : {a} ⊻ t = t.image fun b => a ⊔ b :=
   image2_singleton_left
 #align set.singleton_sups Set.singleton_sups
 
+/- warning: set.sups_singleton -> Set.sups_singleton is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {b : α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) b)) (Set.image.{u1, u1} α α (fun (a : α) => Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b) s)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {b : α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) b)) (Set.image.{u1, u1} α α (fun (a : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b) s)
+Case conversion may be inaccurate. Consider using '#align set.sups_singleton Set.sups_singletonₓ'. -/
 @[simp]
 theorem sups_singleton : s ⊻ {b} = s.image fun a => a ⊔ b :=
   image2_singleton_right
 #align set.sups_singleton Set.sups_singleton
 
+/- warning: set.singleton_sups_singleton -> Set.singleton_sups_singleton is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {a : α} {b : α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) a) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) b)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {a : α} {b : α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) a) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) b)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b))
+Case conversion may be inaccurate. Consider using '#align set.singleton_sups_singleton Set.singleton_sups_singletonₓ'. -/
 theorem singleton_sups_singleton : ({a} ⊻ {b} : Set α) = {a ⊔ b} :=
   image2_singleton
 #align set.singleton_sups_singleton Set.singleton_sups_singleton
 
+/- warning: set.sups_union_left -> Set.sups_union_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s₁ s₂) t) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s₁ t) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s₂ t))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s₁ s₂) t) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s₁ t) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s₂ t))
+Case conversion may be inaccurate. Consider using '#align set.sups_union_left Set.sups_union_leftₓ'. -/
 theorem sups_union_left : (s₁ ∪ s₂) ⊻ t = s₁ ⊻ t ∪ s₂ ⊻ t :=
   image2_union_left
 #align set.sups_union_left Set.sups_union_left
 
+/- warning: set.sups_union_right -> Set.sups_union_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t₁ : Set.{u1} α} {t₂ : Set.{u1} α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) t₁ t₂)) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t₁) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t₂))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t₁ : Set.{u1} α} {t₂ : Set.{u1} α}, Eq.{succ u1} (Set.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) t₁ t₂)) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t₁) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t₂))
+Case conversion may be inaccurate. Consider using '#align set.sups_union_right Set.sups_union_rightₓ'. -/
 theorem sups_union_right : s ⊻ (t₁ ∪ t₂) = s ⊻ t₁ ∪ s ⊻ t₂ :=
   image2_union_right
 #align set.sups_union_right Set.sups_union_right
 
+/- warning: set.sups_inter_subset_left -> Set.sups_inter_subset_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t : Set.{u1} α}, HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s₁ s₂) t) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s₁ t) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s₂ t))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t : Set.{u1} α}, HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s₁ s₂) t) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s₁ t) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s₂ t))
+Case conversion may be inaccurate. Consider using '#align set.sups_inter_subset_left Set.sups_inter_subset_leftₓ'. -/
 theorem sups_inter_subset_left : (s₁ ∩ s₂) ⊻ t ⊆ s₁ ⊻ t ∩ s₂ ⊻ t :=
   image2_inter_subset_left
 #align set.sups_inter_subset_left Set.sups_inter_subset_left
 
+/- warning: set.sups_inter_subset_right -> Set.sups_inter_subset_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t₁ : Set.{u1} α} {t₂ : Set.{u1} α}, HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) t₁ t₂)) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t₁) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t₂))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] {s : Set.{u1} α} {t₁ : Set.{u1} α} {t₂ : Set.{u1} α}, HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) t₁ t₂)) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t₁) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t₂))
+Case conversion may be inaccurate. Consider using '#align set.sups_inter_subset_right Set.sups_inter_subset_rightₓ'. -/
 theorem sups_inter_subset_right : s ⊻ (t₁ ∩ t₂) ⊆ s ⊻ t₁ ∩ s ⊻ t₂ :=
   image2_inter_subset_right
 #align set.sups_inter_subset_right Set.sups_inter_subset_right
 
 variable (s t u v)
 
+/- warning: set.Union_image_sup_left -> Set.unionᵢ_image_sup_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α α (fun (a : α) => Set.unionᵢ.{u1, 0} α (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) => Set.image.{u1, u1} α α (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a) t))) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α α (fun (a : α) => Set.unionᵢ.{u1, 0} α (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) => Set.image.{u1, u1} α α ((fun (x._@.Mathlib.Data.Set.Sups._hyg.2587 : α) (x._@.Mathlib.Data.Set.Sups._hyg.2589 : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) x._@.Mathlib.Data.Set.Sups._hyg.2587 x._@.Mathlib.Data.Set.Sups._hyg.2589) a) t))) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
+Case conversion may be inaccurate. Consider using '#align set.Union_image_sup_left Set.unionᵢ_image_sup_leftₓ'. -/
 theorem unionᵢ_image_sup_left : (⋃ a ∈ s, (· ⊔ ·) a '' t) = s ⊻ t :=
   unionᵢ_image_left _
 #align set.Union_image_sup_left Set.unionᵢ_image_sup_left
 
+/- warning: set.Union_image_sup_right -> Set.unionᵢ_image_sup_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α α (fun (b : α) => Set.unionᵢ.{u1, 0} α (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) => Set.image.{u1, u1} α α (fun (_x : α) => Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) _x b) s))) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α α (fun (b : α) => Set.unionᵢ.{u1, 0} α (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) => Set.image.{u1, u1} α α (fun (_x : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) _x b) s))) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
+Case conversion may be inaccurate. Consider using '#align set.Union_image_sup_right Set.unionᵢ_image_sup_rightₓ'. -/
 theorem unionᵢ_image_sup_right : (⋃ b ∈ t, (· ⊔ b) '' s) = s ⊻ t :=
   unionᵢ_image_right _
 #align set.Union_image_sup_right Set.unionᵢ_image_sup_right
 
+/- warning: set.image_sup_prod -> Set.image_sup_prod is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.image.{u1, u1} (Prod.{u1, u1} α α) α (Function.uncurry.{u1, u1, u1} α α α (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1))) (Set.prod.{u1, u1} α α s t)) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.image2.{u1, u1, u1} α α α (fun (x : α) (x_1 : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) x x_1) s t) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)
+Case conversion may be inaccurate. Consider using '#align set.image_sup_prod Set.image_sup_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem image_sup_prod (s t : Set α) : (s ×ˢ t).image (uncurry (· ⊔ ·)) = s ⊻ t :=
   image_uncurry_prod _ _ _
 #align set.image_sup_prod Set.image_sup_prod
 
+#print Set.sups_assoc /-
 theorem sups_assoc : s ⊻ t ⊻ u = s ⊻ (t ⊻ u) :=
   image2_assoc fun _ _ _ => sup_assoc
 #align set.sups_assoc Set.sups_assoc
+-/
 
+#print Set.sups_comm /-
 theorem sups_comm : s ⊻ t = t ⊻ s :=
   image2_comm fun _ _ => sup_comm
 #align set.sups_comm Set.sups_comm
+-/
 
+#print Set.sups_left_comm /-
 theorem sups_left_comm : s ⊻ (t ⊻ u) = t ⊻ (s ⊻ u) :=
   image2_left_comm sup_left_comm
 #align set.sups_left_comm Set.sups_left_comm
+-/
 
+#print Set.sups_right_comm /-
 theorem sups_right_comm : s ⊻ t ⊻ u = s ⊻ u ⊻ t :=
   image2_right_comm sup_right_comm
 #align set.sups_right_comm Set.sups_right_comm
+-/
 
+#print Set.sups_sups_sups_comm /-
 theorem sups_sups_sups_comm : s ⊻ t ⊻ (u ⊻ v) = s ⊻ u ⊻ (t ⊻ v) :=
   image2_image2_image2_comm sup_sup_sup_comm
 #align set.sups_sups_sups_comm Set.sups_sups_sups_comm
+-/
 
 end Sups
 
@@ -212,149 +344,277 @@ section Infs
 
 variable [SemilatticeInf α] (s s₁ s₂ t t₁ t₂ u v : Set α)
 
+#print Set.hasInfs /-
 /-- `s ⊼ t` is the set of elements of the form `a ⊓ b` where `a ∈ s`, `b ∈ t`. -/
 protected def hasInfs : HasInfs (Set α) :=
   ⟨image2 (· ⊓ ·)⟩
 #align set.has_infs Set.hasInfs
+-/
 
 scoped[SetFamily] attribute [instance] Set.hasInfs
 
 variable {s s₁ s₂ t t₁ t₂ u} {a b c : α}
 
+/- warning: set.mem_infs -> Set.mem_infs is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {c : α}, Iff (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) c (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)) (Exists.{succ u1} α (fun (a : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) => Exists.{succ u1} α (fun (b : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) => Eq.{succ u1} α (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b) c)))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {c : α}, Iff (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) c (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)) (Exists.{succ u1} α (fun (a : α) => And (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) (Exists.{succ u1} α (fun (b : α) => And (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) (Eq.{succ u1} α (Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b) c)))))
+Case conversion may be inaccurate. Consider using '#align set.mem_infs Set.mem_infsₓ'. -/
 @[simp]
 theorem mem_infs : c ∈ s ⊼ t ↔ ∃ a ∈ s, ∃ b ∈ t, a ⊓ b = c := by simp [(· ⊼ ·)]
 #align set.mem_infs Set.mem_infs
 
+/- warning: set.inf_mem_infs -> Set.inf_mem_infs is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t))
+Case conversion may be inaccurate. Consider using '#align set.inf_mem_infs Set.inf_mem_infsₓ'. -/
 theorem inf_mem_infs : a ∈ s → b ∈ t → a ⊓ b ∈ s ⊼ t :=
   mem_image2_of_mem
 #align set.inf_mem_infs Set.inf_mem_infs
 
+#print Set.infs_subset /-
 theorem infs_subset : s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ ⊼ t₁ ⊆ s₂ ⊼ t₂ :=
   image2_subset
 #align set.infs_subset Set.infs_subset
+-/
 
+#print Set.infs_subset_left /-
 theorem infs_subset_left : t₁ ⊆ t₂ → s ⊼ t₁ ⊆ s ⊼ t₂ :=
   image2_subset_left
 #align set.infs_subset_left Set.infs_subset_left
+-/
 
+#print Set.infs_subset_right /-
 theorem infs_subset_right : s₁ ⊆ s₂ → s₁ ⊼ t ⊆ s₂ ⊼ t :=
   image2_subset_right
 #align set.infs_subset_right Set.infs_subset_right
+-/
 
+/- warning: set.image_subset_infs_left -> Set.image_subset_infs_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.image.{u1, u1} α α (fun (a : α) => Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b) s) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Set.image.{u1, u1} α α (fun (a : α) => Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b) s) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t))
+Case conversion may be inaccurate. Consider using '#align set.image_subset_infs_left Set.image_subset_infs_leftₓ'. -/
 theorem image_subset_infs_left : b ∈ t → (fun a => a ⊓ b) '' s ⊆ s ⊼ t :=
   image_subset_image2_left
 #align set.image_subset_infs_left Set.image_subset_infs_left
 
+/- warning: set.image_subset_infs_right -> Set.image_subset_infs_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {a : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.image.{u1, u1} α α (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a) t) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {a : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Set.image.{u1, u1} α α ((fun (x._@.Mathlib.Data.Set.Sups._hyg.3583 : α) (x._@.Mathlib.Data.Set.Sups._hyg.3585 : α) => Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) x._@.Mathlib.Data.Set.Sups._hyg.3583 x._@.Mathlib.Data.Set.Sups._hyg.3585) a) t) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t))
+Case conversion may be inaccurate. Consider using '#align set.image_subset_infs_right Set.image_subset_infs_rightₓ'. -/
 theorem image_subset_infs_right : a ∈ s → (· ⊓ ·) a '' t ⊆ s ⊼ t :=
   image_subset_image2_right
 #align set.image_subset_infs_right Set.image_subset_infs_right
 
+/- warning: set.forall_infs_iff -> Set.forall_infs_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {p : α -> Prop}, Iff (forall (c : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) c (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)) -> (p c)) (forall (a : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (forall (b : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) -> (p (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {p : α -> Prop}, Iff (forall (c : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) c (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)) -> (p c)) (forall (a : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (forall (b : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) -> (p (Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b))))
+Case conversion may be inaccurate. Consider using '#align set.forall_infs_iff Set.forall_infs_iffₓ'. -/
 theorem forall_infs_iff {p : α → Prop} : (∀ c ∈ s ⊼ t, p c) ↔ ∀ a ∈ s, ∀ b ∈ t, p (a ⊓ b) :=
   forall_image2_iff
 #align set.forall_infs_iff Set.forall_infs_iff
 
+/- warning: set.infs_subset_iff -> Set.infs_subset_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {u : Set.{u1} α}, Iff (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t) u) (forall (a : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (forall (b : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b) u)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t : Set.{u1} α} {u : Set.{u1} α}, Iff (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t) u) (forall (a : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (forall (b : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b) u)))
+Case conversion may be inaccurate. Consider using '#align set.infs_subset_iff Set.infs_subset_iffₓ'. -/
 @[simp]
 theorem infs_subset_iff : s ⊼ t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a ⊓ b ∈ u :=
   image2_subset_iff
 #align set.infs_subset_iff Set.infs_subset_iff
 
+#print Set.infs_nonempty /-
 @[simp]
 theorem infs_nonempty : (s ⊼ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty :=
   image2_nonempty_iff
 #align set.infs_nonempty Set.infs_nonempty
+-/
 
+#print Set.Nonempty.infs /-
 protected theorem Nonempty.infs : s.Nonempty → t.Nonempty → (s ⊼ t).Nonempty :=
   Nonempty.image2
 #align set.nonempty.infs Set.Nonempty.infs
+-/
 
+#print Set.Nonempty.of_infs_left /-
 theorem Nonempty.of_infs_left : (s ⊼ t).Nonempty → s.Nonempty :=
   Nonempty.of_image2_left
 #align set.nonempty.of_infs_left Set.Nonempty.of_infs_left
+-/
 
+#print Set.Nonempty.of_infs_right /-
 theorem Nonempty.of_infs_right : (s ⊼ t).Nonempty → t.Nonempty :=
   Nonempty.of_image2_right
 #align set.nonempty.of_infs_right Set.Nonempty.of_infs_right
+-/
 
+#print Set.empty_infs /-
 @[simp]
 theorem empty_infs : ∅ ⊼ t = ∅ :=
   image2_empty_left
 #align set.empty_infs Set.empty_infs
+-/
 
+#print Set.infs_empty /-
 @[simp]
 theorem infs_empty : s ⊼ ∅ = ∅ :=
   image2_empty_right
 #align set.infs_empty Set.infs_empty
+-/
 
+#print Set.infs_eq_empty /-
 @[simp]
 theorem infs_eq_empty : s ⊼ t = ∅ ↔ s = ∅ ∨ t = ∅ :=
   image2_eq_empty_iff
 #align set.infs_eq_empty Set.infs_eq_empty
+-/
 
+/- warning: set.singleton_infs -> Set.singleton_infs is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {t : Set.{u1} α} {a : α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) a) t) (Set.image.{u1, u1} α α (fun (b : α) => Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b) t)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {t : Set.{u1} α} {a : α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) a) t) (Set.image.{u1, u1} α α (fun (b : α) => Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b) t)
+Case conversion may be inaccurate. Consider using '#align set.singleton_infs Set.singleton_infsₓ'. -/
 @[simp]
 theorem singleton_infs : {a} ⊼ t = t.image fun b => a ⊓ b :=
   image2_singleton_left
 #align set.singleton_infs Set.singleton_infs
 
+/- warning: set.infs_singleton -> Set.infs_singleton is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {b : α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) b)) (Set.image.{u1, u1} α α (fun (a : α) => Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b) s)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {b : α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) b)) (Set.image.{u1, u1} α α (fun (a : α) => Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b) s)
+Case conversion may be inaccurate. Consider using '#align set.infs_singleton Set.infs_singletonₓ'. -/
 @[simp]
 theorem infs_singleton : s ⊼ {b} = s.image fun a => a ⊓ b :=
   image2_singleton_right
 #align set.infs_singleton Set.infs_singleton
 
+/- warning: set.singleton_infs_singleton -> Set.singleton_infs_singleton is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {a : α} {b : α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) a) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) b)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {a : α} {b : α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) a) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) b)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) (Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b))
+Case conversion may be inaccurate. Consider using '#align set.singleton_infs_singleton Set.singleton_infs_singletonₓ'. -/
 theorem singleton_infs_singleton : ({a} ⊼ {b} : Set α) = {a ⊓ b} :=
   image2_singleton
 #align set.singleton_infs_singleton Set.singleton_infs_singleton
 
+/- warning: set.infs_union_left -> Set.infs_union_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s₁ s₂) t) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s₁ t) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s₂ t))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s₁ s₂) t) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s₁ t) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s₂ t))
+Case conversion may be inaccurate. Consider using '#align set.infs_union_left Set.infs_union_leftₓ'. -/
 theorem infs_union_left : (s₁ ∪ s₂) ⊼ t = s₁ ⊼ t ∪ s₂ ⊼ t :=
   image2_union_left
 #align set.infs_union_left Set.infs_union_left
 
+/- warning: set.infs_union_right -> Set.infs_union_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t₁ : Set.{u1} α} {t₂ : Set.{u1} α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) t₁ t₂)) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t₁) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t₂))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t₁ : Set.{u1} α} {t₂ : Set.{u1} α}, Eq.{succ u1} (Set.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) t₁ t₂)) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t₁) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t₂))
+Case conversion may be inaccurate. Consider using '#align set.infs_union_right Set.infs_union_rightₓ'. -/
 theorem infs_union_right : s ⊼ (t₁ ∪ t₂) = s ⊼ t₁ ∪ s ⊼ t₂ :=
   image2_union_right
 #align set.infs_union_right Set.infs_union_right
 
+/- warning: set.infs_inter_subset_left -> Set.infs_inter_subset_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t : Set.{u1} α}, HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s₁ s₂) t) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s₁ t) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s₂ t))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t : Set.{u1} α}, HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s₁ s₂) t) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s₁ t) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s₂ t))
+Case conversion may be inaccurate. Consider using '#align set.infs_inter_subset_left Set.infs_inter_subset_leftₓ'. -/
 theorem infs_inter_subset_left : (s₁ ∩ s₂) ⊼ t ⊆ s₁ ⊼ t ∩ s₂ ⊼ t :=
   image2_inter_subset_left
 #align set.infs_inter_subset_left Set.infs_inter_subset_left
 
+/- warning: set.infs_inter_subset_right -> Set.infs_inter_subset_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t₁ : Set.{u1} α} {t₂ : Set.{u1} α}, HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) t₁ t₂)) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t₁) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t₂))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] {s : Set.{u1} α} {t₁ : Set.{u1} α} {t₂ : Set.{u1} α}, HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) t₁ t₂)) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t₁) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t₂))
+Case conversion may be inaccurate. Consider using '#align set.infs_inter_subset_right Set.infs_inter_subset_rightₓ'. -/
 theorem infs_inter_subset_right : s ⊼ (t₁ ∩ t₂) ⊆ s ⊼ t₁ ∩ s ⊼ t₂ :=
   image2_inter_subset_right
 #align set.infs_inter_subset_right Set.infs_inter_subset_right
 
 variable (s t u v)
 
+/- warning: set.Union_image_inf_left -> Set.unionᵢ_image_inf_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α α (fun (a : α) => Set.unionᵢ.{u1, 0} α (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) => Set.image.{u1, u1} α α (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a) t))) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α α (fun (a : α) => Set.unionᵢ.{u1, 0} α (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) => Set.image.{u1, u1} α α ((fun (x._@.Mathlib.Data.Set.Sups._hyg.4535 : α) (x._@.Mathlib.Data.Set.Sups._hyg.4537 : α) => Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) x._@.Mathlib.Data.Set.Sups._hyg.4535 x._@.Mathlib.Data.Set.Sups._hyg.4537) a) t))) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
+Case conversion may be inaccurate. Consider using '#align set.Union_image_inf_left Set.unionᵢ_image_inf_leftₓ'. -/
 theorem unionᵢ_image_inf_left : (⋃ a ∈ s, (· ⊓ ·) a '' t) = s ⊼ t :=
   unionᵢ_image_left _
 #align set.Union_image_inf_left Set.unionᵢ_image_inf_left
 
+/- warning: set.Union_image_inf_right -> Set.unionᵢ_image_inf_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α α (fun (b : α) => Set.unionᵢ.{u1, 0} α (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b t) => Set.image.{u1, u1} α α (fun (_x : α) => Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) _x b) s))) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.unionᵢ.{u1, succ u1} α α (fun (b : α) => Set.unionᵢ.{u1, 0} α (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b t) => Set.image.{u1, u1} α α (fun (_x : α) => Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) _x b) s))) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
+Case conversion may be inaccurate. Consider using '#align set.Union_image_inf_right Set.unionᵢ_image_inf_rightₓ'. -/
 theorem unionᵢ_image_inf_right : (⋃ b ∈ t, (· ⊓ b) '' s) = s ⊼ t :=
   unionᵢ_image_right _
 #align set.Union_image_inf_right Set.unionᵢ_image_inf_right
 
+/- warning: set.image_inf_prod -> Set.image_inf_prod is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.image.{u1, u1} (Prod.{u1, u1} α α) α (Function.uncurry.{u1, u1, u1} α α α (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1))) (Set.prod.{u1, u1} α α s t)) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.image2.{u1, u1, u1} α α α (fun (x : α) (x_1 : α) => Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) x x_1) s t) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)
+Case conversion may be inaccurate. Consider using '#align set.image_inf_prod Set.image_inf_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem image_inf_prod (s t : Set α) : (s ×ˢ t).image (uncurry (· ⊓ ·)) = s ⊼ t :=
   image_uncurry_prod _ _ _
 #align set.image_inf_prod Set.image_inf_prod
 
+#print Set.infs_assoc /-
 theorem infs_assoc : s ⊼ t ⊼ u = s ⊼ (t ⊼ u) :=
   image2_assoc fun _ _ _ => inf_assoc
 #align set.infs_assoc Set.infs_assoc
+-/
 
+#print Set.infs_comm /-
 theorem infs_comm : s ⊼ t = t ⊼ s :=
   image2_comm fun _ _ => inf_comm
 #align set.infs_comm Set.infs_comm
+-/
 
+#print Set.infs_left_comm /-
 theorem infs_left_comm : s ⊼ (t ⊼ u) = t ⊼ (s ⊼ u) :=
   image2_left_comm inf_left_comm
 #align set.infs_left_comm Set.infs_left_comm
+-/
 
+#print Set.infs_right_comm /-
 theorem infs_right_comm : s ⊼ t ⊼ u = s ⊼ u ⊼ t :=
   image2_right_comm inf_right_comm
 #align set.infs_right_comm Set.infs_right_comm
+-/
 
+#print Set.infs_infs_infs_comm /-
 theorem infs_infs_infs_comm : s ⊼ t ⊼ (u ⊼ v) = s ⊼ u ⊼ (t ⊼ v) :=
   image2_image2_image2_comm inf_inf_inf_comm
 #align set.infs_infs_infs_comm Set.infs_infs_infs_comm
+-/
 
 end Infs
 
@@ -364,21 +624,29 @@ section DistribLattice
 
 variable [DistribLattice α] (s t u : Set α)
 
+#print Set.sups_infs_subset_left /-
 theorem sups_infs_subset_left : s ⊻ t ⊼ u ⊆ (s ⊻ t) ⊼ (s ⊻ u) :=
   image2_distrib_subset_left fun _ _ _ => sup_inf_left
 #align set.sups_infs_subset_left Set.sups_infs_subset_left
+-/
 
+#print Set.sups_infs_subset_right /-
 theorem sups_infs_subset_right : t ⊼ u ⊻ s ⊆ (t ⊻ s) ⊼ (u ⊻ s) :=
   image2_distrib_subset_right fun _ _ _ => sup_inf_right
 #align set.sups_infs_subset_right Set.sups_infs_subset_right
+-/
 
+#print Set.infs_sups_subset_left /-
 theorem infs_sups_subset_left : s ⊼ (t ⊻ u) ⊆ s ⊼ t ⊻ s ⊼ u :=
   image2_distrib_subset_left fun _ _ _ => inf_sup_left
 #align set.infs_sups_subset_left Set.infs_sups_subset_left
+-/
 
+#print Set.infs_sups_subset_right /-
 theorem infs_sups_subset_right : (t ⊻ u) ⊼ s ⊆ t ⊼ s ⊻ u ⊼ s :=
   image2_distrib_subset_right fun _ _ _ => inf_sup_right
 #align set.infs_sups_subset_right Set.infs_sups_subset_right
+-/
 
 end DistribLattice
 
@@ -386,6 +654,12 @@ end Set
 
 open SetFamily
 
+/- warning: upper_closure_sups -> upperClosure_sups is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (UpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)) (Sup.sup.{u1} (UpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (UpperSet.hasSup.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) s) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) t))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (UpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) (HasSups.sups.{u1} (Set.{u1} α) (Set.hasSups.{u1} α _inst_1) s t)) (Sup.sup.{u1} (UpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (UpperSet.instSupUpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) s) (upperClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) t))
+Case conversion may be inaccurate. Consider using '#align upper_closure_sups upperClosure_supsₓ'. -/
 @[simp]
 theorem upperClosure_sups [SemilatticeSup α] (s t : Set α) :
     upperClosure (s ⊻ t) = upperClosure s ⊔ upperClosure t :=
@@ -400,6 +674,12 @@ theorem upperClosure_sups [SemilatticeSup α] (s t : Set α) :
     exact ⟨_, ⟨b, hb, c, hc, rfl⟩, sup_le hab hac⟩
 #align upper_closure_sups upperClosure_sups
 
+/- warning: lower_closure_infs -> lowerClosure_infs is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (LowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)) (Inf.inf.{u1} (LowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (LowerSet.hasInf.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) s) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) t))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (LowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) (HasInfs.infs.{u1} (Set.{u1} α) (Set.hasInfs.{u1} α _inst_1) s t)) (Inf.inf.{u1} (LowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (LowerSet.instInfLowerSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) s) (lowerClosure.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)) t))
+Case conversion may be inaccurate. Consider using '#align lower_closure_infs lowerClosure_infsₓ'. -/
 @[simp]
 theorem lowerClosure_infs [SemilatticeInf α] (s t : Set α) :
     lowerClosure (s ⊼ t) = lowerClosure s ⊓ lowerClosure t :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/1f4705ccdfe1e557fc54a0ce081a05e33d2e6240

We cannot literally use @[inherit_doc] in these cases, but we can slightly modify the underlying docstring or a turn a regular comment into a doc comment.

@@ -37,20 +37,22 @@ variable {F α β : Type*}
 
 /-- Notation typeclass for pointwise supremum `⊻`. -/
 class HasSups (α : Type*) where
+  /-- The point-wise supremum `a ⊔ b` of `a, b : α`. -/
   sups : α → α → α
 #align has_sups HasSups
 
 /-- Notation typeclass for pointwise infimum `⊼`. -/
 class HasInfs (α : Type*) where
+  /-- The point-wise infimum `a ⊓ b` of `a, b : α`. -/
   infs : α → α → α
 #align has_infs HasInfs
 
--- mathport name: «expr ⊻ »
+-- This notation is meant to have higher precedence than `⊔` and `⊓`, but still within the
+-- realm of other binary notation.
+@[inherit_doc]
 infixl:74 " ⊻ " => HasSups.sups
-  -- This notation is meant to have higher precedence than `⊔` and `⊓`, but still within the
-  -- realm of other binary notation
 
--- mathport name: «expr ⊼ »
+@[inherit_doc]
 infixl:75 " ⊼ " => HasInfs.infs
 
 namespace Set

Per the style guidelines, λ is disallowed in mathlib. This is close to exhaustive; I left some tactic code alone when it seemed to me that tactic could be upstreamed soon.

Notes

• In lines I was modifying anyway, I also converted => to ↦.
• Also contains some mild in-passing indentation fixes in Mathlib/Order/SupClosed.
• Some doc comments still contained Lean 3 syntax λ x, , which I also replaced.

@@ -173,7 +173,7 @@ theorem sups_inter_subset_right : s ⊻ (t₁ ∩ t₂) ⊆ s ⊻ t₁ ∩ s ⊻
 lemma image_sups (f : F) (s t : Set α) : f '' (s ⊻ t) = f '' s ⊻ f '' t :=
   image_image2_distrib <| map_sup f
 
-lemma subset_sups_self : s ⊆ s ⊻ s := λ _a ha ↦ mem_sups.2 ⟨_, ha, _, ha, sup_idem _⟩
+lemma subset_sups_self : s ⊆ s ⊻ s := fun _a ha ↦ mem_sups.2 ⟨_, ha, _, ha, sup_idem _⟩
 lemma sups_subset_self : s ⊻ s ⊆ s ↔ SupClosed s := sups_subset_iff
 
 @[simp] lemma sups_eq_self : s ⊻ s = s ↔ SupClosed s :=
@@ -335,7 +335,7 @@ theorem infs_inter_subset_right : s ⊼ (t₁ ∩ t₂) ⊆ s ⊼ t₁ ∩ s ⊼
 lemma image_infs (f : F) (s t : Set α) : f '' (s ⊼ t) = f '' s ⊼ f '' t :=
   image_image2_distrib <| map_inf f
 
-lemma subset_infs_self : s ⊆ s ⊼ s := λ _a ha ↦ mem_infs.2 ⟨_, ha, _, ha, inf_idem _⟩
+lemma subset_infs_self : s ⊆ s ⊼ s := fun _a ha ↦ mem_infs.2 ⟨_, ha, _, ha, inf_idem _⟩
 lemma infs_self_subset : s ⊼ s ⊆ s ↔ InfClosed s := infs_subset_iff
 
 @[simp] lemma infs_self : s ⊼ s = s ↔ InfClosed s :=

Those lemmas have historically been very annoying to use in rw since all their arguments were implicit. One too many people complained about it on Zulip, so I'm changing them.

Downstream code broken by this change can fix it by adding appropriately many _s.

Also marks CauSeq.ext @[ext].

Order.BoundedOrder

• top_sup_eq
• sup_top_eq
• bot_sup_eq
• sup_bot_eq
• top_inf_eq
• inf_top_eq
• bot_inf_eq
• inf_bot_eq

Order.Lattice

• sup_idem
• sup_comm
• sup_assoc
• sup_left_idem
• sup_right_idem
• inf_idem
• inf_comm
• inf_assoc
• inf_left_idem
• inf_right_idem
• sup_inf_left
• sup_inf_right
• inf_sup_left
• inf_sup_right

Order.MinMax

• max_min_distrib_left
• max_min_distrib_right
• min_max_distrib_left
• min_max_distrib_right

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -173,7 +173,7 @@ theorem sups_inter_subset_right : s ⊻ (t₁ ∩ t₂) ⊆ s ⊻ t₁ ∩ s ⊻
 lemma image_sups (f : F) (s t : Set α) : f '' (s ⊻ t) = f '' s ⊻ f '' t :=
   image_image2_distrib <| map_sup f
 
-lemma subset_sups_self : s ⊆ s ⊻ s := λ _a ha ↦ mem_sups.2 ⟨_, ha, _, ha, sup_idem⟩
+lemma subset_sups_self : s ⊆ s ⊻ s := λ _a ha ↦ mem_sups.2 ⟨_, ha, _, ha, sup_idem _⟩
 lemma sups_subset_self : s ⊻ s ⊆ s ↔ SupClosed s := sups_subset_iff
 
 @[simp] lemma sups_eq_self : s ⊻ s = s ↔ SupClosed s :=
@@ -193,19 +193,13 @@ theorem iUnion_image_sup_right : ⋃ b ∈ t, (· ⊔ b) '' s = s ⊻ t :=
 #align set.Union_image_sup_right Set.iUnion_image_sup_right
 
 @[simp]
-theorem image_sup_prod (s t : Set α) : Set.image2 (fun x x_1 => x ⊔ x_1) s t = s ⊻ t := by
-  have : (s ×ˢ t).image (uncurry (· ⊔ ·)) = Set.image2 (fun x x_1 => x ⊔ x_1) s t := by
-    simp only [ge_iff_le, image_uncurry_prod]
-  rw [← this]
-  exact image_uncurry_prod _ _ _
+theorem image_sup_prod (s t : Set α) : Set.image2 (· ⊔ ·) s t = s ⊻ t := rfl
 #align set.image_sup_prod Set.image_sup_prod
 
-theorem sups_assoc : s ⊻ t ⊻ u = s ⊻ (t ⊻ u) :=
-  image2_assoc fun _ _ _ => sup_assoc
+theorem sups_assoc : s ⊻ t ⊻ u = s ⊻ (t ⊻ u) := image2_assoc sup_assoc
 #align set.sups_assoc Set.sups_assoc
 
-theorem sups_comm : s ⊻ t = t ⊻ s :=
-  image2_comm fun _ _ => sup_comm
+theorem sups_comm : s ⊻ t = t ⊻ s := image2_comm sup_comm
 #align set.sups_comm Set.sups_comm
 
 theorem sups_left_comm : s ⊻ (t ⊻ u) = t ⊻ (s ⊻ u) :=
@@ -341,7 +335,7 @@ theorem infs_inter_subset_right : s ⊼ (t₁ ∩ t₂) ⊆ s ⊼ t₁ ∩ s ⊼
 lemma image_infs (f : F) (s t : Set α) : f '' (s ⊼ t) = f '' s ⊼ f '' t :=
   image_image2_distrib <| map_inf f
 
-lemma subset_infs_self : s ⊆ s ⊼ s := λ _a ha ↦ mem_infs.2 ⟨_, ha, _, ha, inf_idem⟩
+lemma subset_infs_self : s ⊆ s ⊼ s := λ _a ha ↦ mem_infs.2 ⟨_, ha, _, ha, inf_idem _⟩
 lemma infs_self_subset : s ⊼ s ⊆ s ↔ InfClosed s := infs_subset_iff
 
 @[simp] lemma infs_self : s ⊼ s = s ↔ InfClosed s :=
@@ -368,12 +362,10 @@ theorem image_inf_prod (s t : Set α) : Set.image2 (fun x x_1 => x ⊓ x_1) s t
   exact image_uncurry_prod _ _ _
 #align set.image_inf_prod Set.image_inf_prod
 
-theorem infs_assoc : s ⊼ t ⊼ u = s ⊼ (t ⊼ u) :=
-  image2_assoc fun _ _ _ => inf_assoc
+theorem infs_assoc : s ⊼ t ⊼ u = s ⊼ (t ⊼ u) := image2_assoc inf_assoc
 #align set.infs_assoc Set.infs_assoc
 
-theorem infs_comm : s ⊼ t = t ⊼ s :=
-  image2_comm fun _ _ => inf_comm
+theorem infs_comm : s ⊼ t = t ⊼ s := image2_comm inf_comm
 #align set.infs_comm Set.infs_comm
 
 theorem infs_left_comm : s ⊼ (t ⊼ u) = t ⊼ (s ⊼ u) :=
@@ -397,19 +389,19 @@ section DistribLattice
 variable [DistribLattice α] (s t u : Set α)
 
 theorem sups_infs_subset_left : s ⊻ t ⊼ u ⊆ (s ⊻ t) ⊼ (s ⊻ u) :=
-  image2_distrib_subset_left fun _ _ _ => sup_inf_left
+  image2_distrib_subset_left sup_inf_left
 #align set.sups_infs_subset_left Set.sups_infs_subset_left
 
 theorem sups_infs_subset_right : t ⊼ u ⊻ s ⊆ (t ⊻ s) ⊼ (u ⊻ s) :=
-  image2_distrib_subset_right fun _ _ _ => sup_inf_right
+  image2_distrib_subset_right sup_inf_right
 #align set.sups_infs_subset_right Set.sups_infs_subset_right
 
 theorem infs_sups_subset_left : s ⊼ (t ⊻ u) ⊆ s ⊼ t ⊻ s ⊼ u :=
-  image2_distrib_subset_left fun _ _ _ => inf_sup_left
+  image2_distrib_subset_left inf_sup_left
 #align set.infs_sups_subset_left Set.infs_sups_subset_left
 
 theorem infs_sups_subset_right : (t ⊻ u) ⊼ s ⊆ t ⊼ s ⊻ u ⊼ s :=
-  image2_distrib_subset_right fun _ _ _ => inf_sup_right
+  image2_distrib_subset_right inf_sup_right
 #align set.infs_sups_subset_right Set.infs_sups_subset_right
 
 end DistribLattice

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

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

@@ -65,7 +65,7 @@ protected def hasSups : HasSups (Set α) :=
 #align set.has_sups Set.hasSups
 
 scoped[SetFamily] attribute [instance] Set.hasSups
--- porting note: opening SetFamily, because otherwise the Set.hasSups does not seem to be an
+-- Porting note: opening SetFamily, because otherwise the Set.hasSups does not seem to be an
 -- instance
 open SetFamily
 
@@ -233,7 +233,7 @@ protected def hasInfs : HasInfs (Set α) :=
 #align set.has_infs Set.hasInfs
 
 scoped[SetFamily] attribute [instance] Set.hasInfs
--- porting note: opening SetFamily, because otherwise the Set.hasSups does not seem to be an
+-- Porting note: opening SetFamily, because otherwise the Set.hasSups does not seem to be an
 -- instance
 open SetFamily
 

The FunLike hierarchy is very big and gets scanned through each time we need a coercion (via the CoeFun instance). It looks like unbundled inheritance suits Lean 4 better here. The only class that still extends FunLike is EquivLike, since that has a custom coe_injective' field that is easier to implement. All other classes should take FunLike or EquivLike as a parameter.

Zulip thread

Important changes

Previously, morphism classes would be Type-valued and extend FunLike:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  extends FunLike F A B :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

After this PR, they should be Prop-valued and take FunLike as a parameter:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  [FunLike F A B] : Prop :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

(Note that A B stay marked as outParam even though they are not purely required to be so due to the FunLike parameter already filling them in. This is required to see through type synonyms, which is important in the category theory library. Also, I think keeping them as outParam is slightly faster.)

Similarly, MyEquivClass should take EquivLike as a parameter.

As a result, every mention of [MyHomClass F A B] should become [FunLike F A B] [MyHomClass F A B].

Remaining issues

Slower (failing) search

While overall this gives some great speedups, there are some cases that are noticeably slower. In particular, a failing application of a lemma such as map_mul is more expensive. This is due to suboptimal processing of arguments. For example:

variable [FunLike F M N] [Mul M] [Mul N] (f : F) (x : M) (y : M)

theorem map_mul [MulHomClass F M N] : f (x * y) = f x * f y

example [AddHomClass F A B] : f (x * y) = f x * f y := map_mul f _ _

Before this PR, applying map_mul f gives the goals [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Since M and N are out_params, [MulHomClass F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found.

After this PR, the goals become [FunLike F ?M ?N] [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Now [FunLike F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found, before trying MulHomClass F M N which fails. Since the Mul hierarchy is very big, this can be slow to fail, especially when there is no such Mul instance.

A long-term but harder to achieve solution would be to specify the order in which instance goals get solved. For example, we'd like to change the arguments to map_mul to look like [FunLike F M N] [Mul M] [Mul N] [highPriority <| MulHomClass F M N] because MulHomClass fails or succeeds much faster than the others.

As a consequence, the simpNF linter is much slower since by design it tries and fails to apply many map_ lemmas. The same issue occurs a few times in existing calls to simp [map_mul], where map_mul is tried "too soon" and fails. Thanks to the speedup of leanprover/lean4#2478 the impact is very limited, only in files that already were close to the timeout.

simp not firing sometimes

This affects map_smulₛₗ and related definitions. For simp lemmas Lean apparently uses a slightly different mechanism to find instances, so that rw can find every argument to map_smulₛₗ successfully but simp can't: leanprover/lean4#3701.

Missing instances due to unification failing

Especially in the category theory library, we might sometimes have a type A which is also accessible as a synonym (Bundled A hA).1. Instance synthesis doesn't always work if we have f : A →* B but x * y : (Bundled A hA).1 or vice versa. This seems to be mostly fixed by keeping A B as outParams in MulHomClass F A B. (Presumably because Lean will do a definitional check A =?= (Bundled A hA).1 instead of using the syntax in the discrimination tree.)

Workaround for issues

The timeouts can be worked around for now by specifying which map_mul we mean, either as map_mul f for some explicit f, or as e.g. MonoidHomClass.map_mul.

map_smulₛₗ not firing as simp lemma can be worked around by going back to the pre-FunLike situation and making LinearMap.map_smulₛₗ a simp lemma instead of the generic map_smulₛₗ. Writing simp [map_smulₛₗ _] also works.

Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Scott Morrison <scott@tqft.net> Co-authored-by: Anne Baanen <Vierkantor@users.noreply.github.com>

@@ -56,7 +56,8 @@ infixl:75 " ⊼ " => HasInfs.infs
 namespace Set
 
 section Sups
-variable [SemilatticeSup α] [SemilatticeSup β] [SupHomClass F α β] (s s₁ s₂ t t₁ t₂ u v : Set α)
+variable [SemilatticeSup α] [SemilatticeSup β] [FunLike F α β] [SupHomClass F α β]
+variable (s s₁ s₂ t t₁ t₂ u v : Set α)
 
 /-- `s ⊻ t` is the set of elements of the form `a ⊔ b` where `a ∈ s`, `b ∈ t`. -/
 protected def hasSups : HasSups (Set α) :=
@@ -223,7 +224,8 @@ end Sups
 
 section Infs
 
-variable [SemilatticeInf α] [SemilatticeInf β] [InfHomClass F α β] (s s₁ s₂ t t₁ t₂ u v : Set α)
+variable [SemilatticeInf α] [SemilatticeInf β] [FunLike F α β] [InfHomClass F α β]
+variable (s s₁ s₂ t t₁ t₂ u v : Set α)
 
 /-- `s ⊼ t` is the set of elements of the form `a ⊓ b` where `a ∈ s`, `b ∈ t`. -/
 protected def hasInfs : HasInfs (Set α) :=

See Zulip thread for the discussion.

@@ -170,7 +170,7 @@ theorem sups_inter_subset_right : s ⊻ (t₁ ∩ t₂) ⊆ s ⊻ t₁ ∩ s ⊻
 #align set.sups_inter_subset_right Set.sups_inter_subset_right
 
 lemma image_sups (f : F) (s t : Set α) : f '' (s ⊻ t) = f '' s ⊻ f '' t :=
-  image_image2_distrib $ map_sup f
+  image_image2_distrib <| map_sup f
 
 lemma subset_sups_self : s ⊆ s ⊻ s := λ _a ha ↦ mem_sups.2 ⟨_, ha, _, ha, sup_idem⟩
 lemma sups_subset_self : s ⊻ s ⊆ s ↔ SupClosed s := sups_subset_iff
@@ -337,7 +337,7 @@ theorem infs_inter_subset_right : s ⊼ (t₁ ∩ t₂) ⊆ s ⊼ t₁ ∩ s ⊼
 #align set.infs_inter_subset_right Set.infs_inter_subset_right
 
 lemma image_infs (f : F) (s t : Set α) : f '' (s ⊼ t) = f '' s ⊼ f '' t :=
-  image_image2_distrib $ map_inf f
+  image_image2_distrib <| map_inf f
 
 lemma subset_infs_self : s ⊆ s ⊼ s := λ _a ha ↦ mem_infs.2 ⟨_, ha, _, ha, inf_idem⟩
 lemma infs_self_subset : s ⊼ s ⊆ s ↔ InfClosed s := infs_subset_iff

I used the regex \(\(· (.) ·\) (.)\), replacing with ($2 $1 ·).

@@ -261,7 +261,7 @@ theorem image_subset_infs_left : b ∈ t → (fun a => a ⊓ b) '' s ⊆ s ⊼ t
   image_subset_image2_left
 #align set.image_subset_infs_left Set.image_subset_infs_left
 
-theorem image_subset_infs_right : a ∈ s → (· ⊓ ·) a '' t ⊆ s ⊼ t :=
+theorem image_subset_infs_right : a ∈ s → (a ⊓ ·) '' t ⊆ s ⊼ t :=
   image_subset_image2_right
 #align set.image_subset_infs_right Set.image_subset_infs_right
 
@@ -350,7 +350,7 @@ lemma sep_infs_le (s t : Set α) (a : α) :
 
 variable (s t u)
 
-theorem iUnion_image_inf_left : ⋃ a ∈ s, (· ⊓ ·) a '' t = s ⊼ t :=
+theorem iUnion_image_inf_left : ⋃ a ∈ s, (a ⊓ ·) '' t = s ⊼ t :=
   iUnion_image_left _
 #align set.Union_image_inf_left Set.iUnion_image_inf_left
 

@@ -5,6 +5,7 @@ Authors: Yaël Dillies
 -/
 import Mathlib.Data.Set.NAry
 import Mathlib.Order.UpperLower.Basic
+import Mathlib.Order.SupClosed
 
 #align_import data.set.sups from "leanprover-community/mathlib"@"20715f4ac6819ef2453d9e5106ecd086a5dc2a5e"
 
@@ -20,7 +21,7 @@ This file defines a few binary operations on `Set α` for use in set family comb
 
 ## Notation
 
-We define the following notation in locale `set_family`:
+We define the following notation in locale `SetFamily`:
 * `s ⊻ t`
 * `s ⊼ t`
 
@@ -32,7 +33,7 @@ We define the following notation in locale `set_family`:
 
 open Function
 
-variable {α : Type*}
+variable {F α β : Type*}
 
 /-- Notation typeclass for pointwise supremum `⊻`. -/
 class HasSups (α : Type*) where
@@ -45,8 +46,7 @@ class HasInfs (α : Type*) where
 #align has_infs HasInfs
 
 -- mathport name: «expr ⊻ »
-infixl:74
-  " ⊻ " => HasSups.sups
+infixl:74 " ⊻ " => HasSups.sups
   -- This notation is meant to have higher precedence than `⊔` and `⊓`, but still within the
   -- realm of other binary notation
 
@@ -56,8 +56,7 @@ infixl:75 " ⊼ " => HasInfs.infs
 namespace Set
 
 section Sups
-
-variable [SemilatticeSup α] (s s₁ s₂ t t₁ t₂ u v : Set α)
+variable [SemilatticeSup α] [SemilatticeSup β] [SupHomClass F α β] (s s₁ s₂ t t₁ t₂ u v : Set α)
 
 /-- `s ⊻ t` is the set of elements of the form `a ⊔ b` where `a ∈ s`, `b ∈ t`. -/
 protected def hasSups : HasSups (Set α) :=
@@ -170,6 +169,18 @@ theorem sups_inter_subset_right : s ⊻ (t₁ ∩ t₂) ⊆ s ⊻ t₁ ∩ s ⊻
   image2_inter_subset_right
 #align set.sups_inter_subset_right Set.sups_inter_subset_right
 
+lemma image_sups (f : F) (s t : Set α) : f '' (s ⊻ t) = f '' s ⊻ f '' t :=
+  image_image2_distrib $ map_sup f
+
+lemma subset_sups_self : s ⊆ s ⊻ s := λ _a ha ↦ mem_sups.2 ⟨_, ha, _, ha, sup_idem⟩
+lemma sups_subset_self : s ⊻ s ⊆ s ↔ SupClosed s := sups_subset_iff
+
+@[simp] lemma sups_eq_self : s ⊻ s = s ↔ SupClosed s :=
+  subset_sups_self.le.le_iff_eq.symm.trans sups_subset_self
+
+lemma sep_sups_le (s t : Set α) (a : α) :
+    {b ∈ s ⊻ t | b ≤ a} = {b ∈ s | b ≤ a} ⊻ {b ∈ t | b ≤ a} := by ext; aesop
+
 variable (s t u)
 
 theorem iUnion_image_sup_left : ⋃ a ∈ s, (· ⊔ ·) a '' t = s ⊻ t :=
@@ -212,7 +223,7 @@ end Sups
 
 section Infs
 
-variable [SemilatticeInf α] (s s₁ s₂ t t₁ t₂ u v : Set α)
+variable [SemilatticeInf α] [SemilatticeInf β] [InfHomClass F α β] (s s₁ s₂ t t₁ t₂ u v : Set α)
 
 /-- `s ⊼ t` is the set of elements of the form `a ⊓ b` where `a ∈ s`, `b ∈ t`. -/
 protected def hasInfs : HasInfs (Set α) :=
@@ -325,6 +336,18 @@ theorem infs_inter_subset_right : s ⊼ (t₁ ∩ t₂) ⊆ s ⊼ t₁ ∩ s ⊼
   image2_inter_subset_right
 #align set.infs_inter_subset_right Set.infs_inter_subset_right
 
+lemma image_infs (f : F) (s t : Set α) : f '' (s ⊼ t) = f '' s ⊼ f '' t :=
+  image_image2_distrib $ map_inf f
+
+lemma subset_infs_self : s ⊆ s ⊼ s := λ _a ha ↦ mem_infs.2 ⟨_, ha, _, ha, inf_idem⟩
+lemma infs_self_subset : s ⊼ s ⊆ s ↔ InfClosed s := infs_subset_iff
+
+@[simp] lemma infs_self : s ⊼ s = s ↔ InfClosed s :=
+  subset_infs_self.le.le_iff_eq.symm.trans infs_self_subset
+
+lemma sep_infs_le (s t : Set α) (a : α) :
+    {b ∈ s ⊼ t | a ≤ b} = {b ∈ s | a ≤ b} ⊼ {b ∈ t | a ≤ b} := by ext; aesop
+
 variable (s t u)
 
 theorem iUnion_image_inf_left : ⋃ a ∈ s, (· ⊓ ·) a '' t = s ⊼ t :=

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

This has nice performance benefits.

@@ -32,15 +32,15 @@ We define the following notation in locale `set_family`:
 
 open Function
 
-variable {α : Type _}
+variable {α : Type*}
 
 /-- Notation typeclass for pointwise supremum `⊻`. -/
-class HasSups (α : Type _) where
+class HasSups (α : Type*) where
   sups : α → α → α
 #align has_sups HasSups
 
 /-- Notation typeclass for pointwise infimum `⊼`. -/
-class HasInfs (α : Type _) where
+class HasInfs (α : Type*) where
   infs : α → α → α
 #align has_infs HasInfs
 

• 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) 2022 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
-
-! This file was ported from Lean 3 source module data.set.sups
-! leanprover-community/mathlib commit 20715f4ac6819ef2453d9e5106ecd086a5dc2a5e
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Set.NAry
 import Mathlib.Order.UpperLower.Basic
 
+#align_import data.set.sups from "leanprover-community/mathlib"@"20715f4ac6819ef2453d9e5106ecd086a5dc2a5e"
+
 /-!
 # Set family operations
 

@@ -175,11 +175,11 @@ theorem sups_inter_subset_right : s ⊻ (t₁ ∩ t₂) ⊆ s ⊻ t₁ ∩ s ⊻
 
 variable (s t u)
 
-theorem iUnion_image_sup_left : (⋃ a ∈ s, (· ⊔ ·) a '' t) = s ⊻ t :=
+theorem iUnion_image_sup_left : ⋃ a ∈ s, (· ⊔ ·) a '' t = s ⊻ t :=
   iUnion_image_left _
 #align set.Union_image_sup_left Set.iUnion_image_sup_left
 
-theorem iUnion_image_sup_right : (⋃ b ∈ t, (· ⊔ b) '' s) = s ⊻ t :=
+theorem iUnion_image_sup_right : ⋃ b ∈ t, (· ⊔ b) '' s = s ⊻ t :=
   iUnion_image_right _
 #align set.Union_image_sup_right Set.iUnion_image_sup_right
 
@@ -330,11 +330,11 @@ theorem infs_inter_subset_right : s ⊼ (t₁ ∩ t₂) ⊆ s ⊼ t₁ ∩ s ⊼
 
 variable (s t u)
 
-theorem iUnion_image_inf_left : (⋃ a ∈ s, (· ⊓ ·) a '' t) = s ⊼ t :=
+theorem iUnion_image_inf_left : ⋃ a ∈ s, (· ⊓ ·) a '' t = s ⊼ t :=
   iUnion_image_left _
 #align set.Union_image_inf_left Set.iUnion_image_inf_left
 
-theorem iUnion_image_inf_right : (⋃ b ∈ t, (· ⊓ b) '' s) = s ⊼ t :=
+theorem iUnion_image_inf_right : ⋃ b ∈ t, (· ⊓ b) '' s = s ⊼ t :=
   iUnion_image_right _
 #align set.Union_image_inf_right Set.iUnion_image_inf_right
 

• Run a non-interactive version of fix-comments.py on all files.
• Go through the diff and manually add/discard/edit chunks.

@@ -14,7 +14,7 @@ import Mathlib.Order.UpperLower.Basic
 /-!
 # Set family operations
 
-This file defines a few binary operations on `set α` for use in set family combinatorics.
+This file defines a few binary operations on `Set α` for use in set family combinatorics.
 
 ## Main declarations
 

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>

@@ -175,13 +175,13 @@ theorem sups_inter_subset_right : s ⊻ (t₁ ∩ t₂) ⊆ s ⊻ t₁ ∩ s ⊻
 
 variable (s t u)
 
-theorem unionᵢ_image_sup_left : (⋃ a ∈ s, (· ⊔ ·) a '' t) = s ⊻ t :=
-  unionᵢ_image_left _
-#align set.Union_image_sup_left Set.unionᵢ_image_sup_left
+theorem iUnion_image_sup_left : (⋃ a ∈ s, (· ⊔ ·) a '' t) = s ⊻ t :=
+  iUnion_image_left _
+#align set.Union_image_sup_left Set.iUnion_image_sup_left
 
-theorem unionᵢ_image_sup_right : (⋃ b ∈ t, (· ⊔ b) '' s) = s ⊻ t :=
-  unionᵢ_image_right _
-#align set.Union_image_sup_right Set.unionᵢ_image_sup_right
+theorem iUnion_image_sup_right : (⋃ b ∈ t, (· ⊔ b) '' s) = s ⊻ t :=
+  iUnion_image_right _
+#align set.Union_image_sup_right Set.iUnion_image_sup_right
 
 @[simp]
 theorem image_sup_prod (s t : Set α) : Set.image2 (fun x x_1 => x ⊔ x_1) s t = s ⊻ t := by
@@ -330,13 +330,13 @@ theorem infs_inter_subset_right : s ⊼ (t₁ ∩ t₂) ⊆ s ⊼ t₁ ∩ s ⊼
 
 variable (s t u)
 
-theorem unionᵢ_image_inf_left : (⋃ a ∈ s, (· ⊓ ·) a '' t) = s ⊼ t :=
-  unionᵢ_image_left _
-#align set.Union_image_inf_left Set.unionᵢ_image_inf_left
+theorem iUnion_image_inf_left : (⋃ a ∈ s, (· ⊓ ·) a '' t) = s ⊼ t :=
+  iUnion_image_left _
+#align set.Union_image_inf_left Set.iUnion_image_inf_left
 
-theorem unionᵢ_image_inf_right : (⋃ b ∈ t, (· ⊓ b) '' s) = s ⊼ t :=
-  unionᵢ_image_right _
-#align set.Union_image_inf_right Set.unionᵢ_image_inf_right
+theorem iUnion_image_inf_right : (⋃ b ∈ t, (· ⊓ b) '' s) = s ⊼ t :=
+  iUnion_image_right _
+#align set.Union_image_inf_right Set.iUnion_image_inf_right
 
 @[simp]
 theorem image_inf_prod (s t : Set α) : Set.image2 (fun x x_1 => x ⊓ x_1) s t = s ⊼ t := by

Co-authored-by: Moritz Firsching <firsching@google.com> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>