order.conditionally_complete_lattice.finset ⟷ Mathlib.Order.ConditionallyCompleteLattice.Finset

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

@@ -49,52 +49,52 @@ section ConditionallyCompleteLinearOrder
 
 variable [ConditionallyCompleteLinearOrder α] {s t : Set α} {a b : α}
 
-#print Finset.Nonempty.cSup_eq_max' /-
-theorem Finset.Nonempty.cSup_eq_max' {s : Finset α} (h : s.Nonempty) : sSup ↑s = s.max' h :=
+#print Finset.Nonempty.csSup_eq_max' /-
+theorem Finset.Nonempty.csSup_eq_max' {s : Finset α} (h : s.Nonempty) : sSup ↑s = s.max' h :=
   eq_of_forall_ge_iff fun a => (csSup_le_iff s.BddAbove h.to_set).trans (s.max'_le_iff h).symm
-#align finset.nonempty.cSup_eq_max' Finset.Nonempty.cSup_eq_max'
+#align finset.nonempty.cSup_eq_max' Finset.Nonempty.csSup_eq_max'
 -/
 
-#print Finset.Nonempty.cInf_eq_min' /-
-theorem Finset.Nonempty.cInf_eq_min' {s : Finset α} (h : s.Nonempty) : sInf ↑s = s.min' h :=
-  @Finset.Nonempty.cSup_eq_max' αᵒᵈ _ s h
-#align finset.nonempty.cInf_eq_min' Finset.Nonempty.cInf_eq_min'
+#print Finset.Nonempty.csInf_eq_min' /-
+theorem Finset.Nonempty.csInf_eq_min' {s : Finset α} (h : s.Nonempty) : sInf ↑s = s.min' h :=
+  @Finset.Nonempty.csSup_eq_max' αᵒᵈ _ s h
+#align finset.nonempty.cInf_eq_min' Finset.Nonempty.csInf_eq_min'
 -/
 
-#print Finset.Nonempty.cSup_mem /-
-theorem Finset.Nonempty.cSup_mem {s : Finset α} (h : s.Nonempty) : sSup (s : Set α) ∈ s := by
+#print Finset.Nonempty.csSup_mem /-
+theorem Finset.Nonempty.csSup_mem {s : Finset α} (h : s.Nonempty) : sSup (s : Set α) ∈ s := by
   rw [h.cSup_eq_max']; exact s.max'_mem _
-#align finset.nonempty.cSup_mem Finset.Nonempty.cSup_mem
+#align finset.nonempty.cSup_mem Finset.Nonempty.csSup_mem
 -/
 
-#print Finset.Nonempty.cInf_mem /-
-theorem Finset.Nonempty.cInf_mem {s : Finset α} (h : s.Nonempty) : sInf (s : Set α) ∈ s :=
-  @Finset.Nonempty.cSup_mem αᵒᵈ _ _ h
-#align finset.nonempty.cInf_mem Finset.Nonempty.cInf_mem
+#print Finset.Nonempty.csInf_mem /-
+theorem Finset.Nonempty.csInf_mem {s : Finset α} (h : s.Nonempty) : sInf (s : Set α) ∈ s :=
+  @Finset.Nonempty.csSup_mem αᵒᵈ _ _ h
+#align finset.nonempty.cInf_mem Finset.Nonempty.csInf_mem
 -/
 
-#print Set.Nonempty.cSup_mem /-
-theorem Set.Nonempty.cSup_mem (h : s.Nonempty) (hs : s.Finite) : sSup s ∈ s := by
-  lift s to Finset α using hs; exact Finset.Nonempty.cSup_mem h
-#align set.nonempty.cSup_mem Set.Nonempty.cSup_mem
+#print Set.Nonempty.csSup_mem /-
+theorem Set.Nonempty.csSup_mem (h : s.Nonempty) (hs : s.Finite) : sSup s ∈ s := by
+  lift s to Finset α using hs; exact Finset.Nonempty.csSup_mem h
+#align set.nonempty.cSup_mem Set.Nonempty.csSup_mem
 -/
 
-#print Set.Nonempty.cInf_mem /-
-theorem Set.Nonempty.cInf_mem (h : s.Nonempty) (hs : s.Finite) : sInf s ∈ s :=
-  @Set.Nonempty.cSup_mem αᵒᵈ _ _ h hs
-#align set.nonempty.cInf_mem Set.Nonempty.cInf_mem
+#print Set.Nonempty.csInf_mem /-
+theorem Set.Nonempty.csInf_mem (h : s.Nonempty) (hs : s.Finite) : sInf s ∈ s :=
+  @Set.Nonempty.csSup_mem αᵒᵈ _ _ h hs
+#align set.nonempty.cInf_mem Set.Nonempty.csInf_mem
 -/
 
-#print Set.Finite.cSup_lt_iff /-
-theorem Set.Finite.cSup_lt_iff (hs : s.Finite) (h : s.Nonempty) : sSup s < a ↔ ∀ x ∈ s, x < a :=
-  ⟨fun h x hx => (le_csSup hs.BddAbove hx).trans_lt h, fun H => H _ <| h.cSup_mem hs⟩
-#align set.finite.cSup_lt_iff Set.Finite.cSup_lt_iff
+#print Set.Finite.csSup_lt_iff /-
+theorem Set.Finite.csSup_lt_iff (hs : s.Finite) (h : s.Nonempty) : sSup s < a ↔ ∀ x ∈ s, x < a :=
+  ⟨fun h x hx => (le_csSup hs.BddAbove hx).trans_lt h, fun H => H _ <| h.csSup_mem hs⟩
+#align set.finite.cSup_lt_iff Set.Finite.csSup_lt_iff
 -/
 
-#print Set.Finite.lt_cInf_iff /-
-theorem Set.Finite.lt_cInf_iff (hs : s.Finite) (h : s.Nonempty) : a < sInf s ↔ ∀ x ∈ s, a < x :=
-  @Set.Finite.cSup_lt_iff αᵒᵈ _ _ _ hs h
-#align set.finite.lt_cInf_iff Set.Finite.lt_cInf_iff
+#print Set.Finite.lt_csInf_iff /-
+theorem Set.Finite.lt_csInf_iff (hs : s.Finite) (h : s.Nonempty) : a < sInf s ↔ ∀ x ∈ s, a < x :=
+  @Set.Finite.csSup_lt_iff αᵒᵈ _ _ _ hs h
+#align set.finite.lt_cInf_iff Set.Finite.lt_csInf_iff
 -/
 
 end ConditionallyCompleteLinearOrder

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

@@ -25,18 +25,22 @@ section ConditionallyCompleteLattice
 
 variable [ConditionallyCompleteLattice α] {s t : Set α} {a b : α}
 
-#print Finset.Nonempty.sup'_eq_cSup_image /-
-theorem Finset.Nonempty.sup'_eq_cSup_image {s : Finset β} (hs : s.Nonempty) (f : β → α) :
+/- warning: finset.nonempty.sup'_eq_cSup_image clashes with finset.sup'_eq_cSup_image -> Finset.sup'_eq_csSup_image
+Case conversion may be inaccurate. Consider using '#align finset.nonempty.sup'_eq_cSup_image Finset.sup'_eq_csSup_imageₓ'. -/
+#print Finset.sup'_eq_csSup_image /-
+theorem Finset.sup'_eq_csSup_image {s : Finset β} (hs : s.Nonempty) (f : β → α) :
     s.sup' hs f = sSup (f '' s) :=
   eq_of_forall_ge_iff fun a => by
     simp [csSup_le_iff (s.finite_to_set.image f).BddAbove (hs.to_set.image f)]
-#align finset.nonempty.sup'_eq_cSup_image Finset.Nonempty.sup'_eq_cSup_image
+#align finset.nonempty.sup'_eq_cSup_image Finset.sup'_eq_csSup_image
 -/
 
-#print Finset.Nonempty.sup'_id_eq_cSup /-
-theorem Finset.Nonempty.sup'_id_eq_cSup {s : Finset α} (hs : s.Nonempty) : s.sup' hs id = sSup s :=
-  by rw [hs.sup'_eq_cSup_image, image_id]
-#align finset.nonempty.sup'_id_eq_cSup Finset.Nonempty.sup'_id_eq_cSup
+/- warning: finset.nonempty.sup'_id_eq_cSup clashes with finset.sup'_id_eq_cSup -> Finset.sup'_id_eq_csSup
+Case conversion may be inaccurate. Consider using '#align finset.nonempty.sup'_id_eq_cSup Finset.sup'_id_eq_csSupₓ'. -/
+#print Finset.sup'_id_eq_csSup /-
+theorem Finset.sup'_id_eq_csSup {s : Finset α} (hs : s.Nonempty) : s.sup' hs id = sSup s := by
+  rw [hs.sup'_eq_cSup_image, image_id]
+#align finset.nonempty.sup'_id_eq_cSup Finset.sup'_id_eq_csSup
 -/
 
 end ConditionallyCompleteLattice

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

@@ -3,8 +3,8 @@ Copyright (c) 2018 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel
 -/
-import Mathbin.Order.ConditionallyCompleteLattice.Basic
-import Mathbin.Data.Set.Finite
+import Order.ConditionallyCompleteLattice.Basic
+import Data.Set.Finite
 
 #align_import order.conditionally_complete_lattice.finset from "leanprover-community/mathlib"@"327c3c0d9232d80e250dc8f65e7835b82b266ea5"
 

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

@@ -2,15 +2,12 @@
 Copyright (c) 2018 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel
-
-! This file was ported from Lean 3 source module order.conditionally_complete_lattice.finset
-! leanprover-community/mathlib commit 327c3c0d9232d80e250dc8f65e7835b82b266ea5
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.ConditionallyCompleteLattice.Basic
 import Mathbin.Data.Set.Finite
 
+#align_import order.conditionally_complete_lattice.finset from "leanprover-community/mathlib"@"327c3c0d9232d80e250dc8f65e7835b82b266ea5"
+
 /-!
 # Conditionally complete lattices and finite sets.
 

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

@@ -28,15 +28,19 @@ section ConditionallyCompleteLattice
 
 variable [ConditionallyCompleteLattice α] {s t : Set α} {a b : α}
 
+#print Finset.Nonempty.sup'_eq_cSup_image /-
 theorem Finset.Nonempty.sup'_eq_cSup_image {s : Finset β} (hs : s.Nonempty) (f : β → α) :
     s.sup' hs f = sSup (f '' s) :=
   eq_of_forall_ge_iff fun a => by
     simp [csSup_le_iff (s.finite_to_set.image f).BddAbove (hs.to_set.image f)]
 #align finset.nonempty.sup'_eq_cSup_image Finset.Nonempty.sup'_eq_cSup_image
+-/
 
+#print Finset.Nonempty.sup'_id_eq_cSup /-
 theorem Finset.Nonempty.sup'_id_eq_cSup {s : Finset α} (hs : s.Nonempty) : s.sup' hs id = sSup s :=
   by rw [hs.sup'_eq_cSup_image, image_id]
 #align finset.nonempty.sup'_id_eq_cSup Finset.Nonempty.sup'_id_eq_cSup
+-/
 
 end ConditionallyCompleteLattice
 
@@ -44,37 +48,53 @@ section ConditionallyCompleteLinearOrder
 
 variable [ConditionallyCompleteLinearOrder α] {s t : Set α} {a b : α}
 
+#print Finset.Nonempty.cSup_eq_max' /-
 theorem Finset.Nonempty.cSup_eq_max' {s : Finset α} (h : s.Nonempty) : sSup ↑s = s.max' h :=
   eq_of_forall_ge_iff fun a => (csSup_le_iff s.BddAbove h.to_set).trans (s.max'_le_iff h).symm
 #align finset.nonempty.cSup_eq_max' Finset.Nonempty.cSup_eq_max'
+-/
 
+#print Finset.Nonempty.cInf_eq_min' /-
 theorem Finset.Nonempty.cInf_eq_min' {s : Finset α} (h : s.Nonempty) : sInf ↑s = s.min' h :=
   @Finset.Nonempty.cSup_eq_max' αᵒᵈ _ s h
 #align finset.nonempty.cInf_eq_min' Finset.Nonempty.cInf_eq_min'
+-/
 
+#print Finset.Nonempty.cSup_mem /-
 theorem Finset.Nonempty.cSup_mem {s : Finset α} (h : s.Nonempty) : sSup (s : Set α) ∈ s := by
   rw [h.cSup_eq_max']; exact s.max'_mem _
 #align finset.nonempty.cSup_mem Finset.Nonempty.cSup_mem
+-/
 
+#print Finset.Nonempty.cInf_mem /-
 theorem Finset.Nonempty.cInf_mem {s : Finset α} (h : s.Nonempty) : sInf (s : Set α) ∈ s :=
   @Finset.Nonempty.cSup_mem αᵒᵈ _ _ h
 #align finset.nonempty.cInf_mem Finset.Nonempty.cInf_mem
+-/
 
+#print Set.Nonempty.cSup_mem /-
 theorem Set.Nonempty.cSup_mem (h : s.Nonempty) (hs : s.Finite) : sSup s ∈ s := by
   lift s to Finset α using hs; exact Finset.Nonempty.cSup_mem h
 #align set.nonempty.cSup_mem Set.Nonempty.cSup_mem
+-/
 
+#print Set.Nonempty.cInf_mem /-
 theorem Set.Nonempty.cInf_mem (h : s.Nonempty) (hs : s.Finite) : sInf s ∈ s :=
   @Set.Nonempty.cSup_mem αᵒᵈ _ _ h hs
 #align set.nonempty.cInf_mem Set.Nonempty.cInf_mem
+-/
 
+#print Set.Finite.cSup_lt_iff /-
 theorem Set.Finite.cSup_lt_iff (hs : s.Finite) (h : s.Nonempty) : sSup s < a ↔ ∀ x ∈ s, x < a :=
   ⟨fun h x hx => (le_csSup hs.BddAbove hx).trans_lt h, fun H => H _ <| h.cSup_mem hs⟩
 #align set.finite.cSup_lt_iff Set.Finite.cSup_lt_iff
+-/
 
+#print Set.Finite.lt_cInf_iff /-
 theorem Set.Finite.lt_cInf_iff (hs : s.Finite) (h : s.Nonempty) : a < sInf s ↔ ∀ x ∈ s, a < x :=
   @Set.Finite.cSup_lt_iff αᵒᵈ _ _ _ hs h
 #align set.finite.lt_cInf_iff Set.Finite.lt_cInf_iff
+-/
 
 end ConditionallyCompleteLinearOrder
 
@@ -88,6 +108,7 @@ non-empty. As a result, we can translate between the two.
 
 namespace Finset
 
+#print Finset.sup'_eq_csSup_image /-
 theorem sup'_eq_csSup_image [ConditionallyCompleteLattice β] (s : Finset α) (H) (f : α → β) :
     s.sup' H f = sSup (f '' s) := by
   apply le_antisymm
@@ -99,20 +120,27 @@ theorem sup'_eq_csSup_image [ConditionallyCompleteLattice β] (s : Finset α) (H
     rintro _ ⟨a, ha, rfl⟩
     exact Finset.le_sup' _ ha
 #align finset.sup'_eq_cSup_image Finset.sup'_eq_csSup_image
+-/
 
+#print Finset.inf'_eq_csInf_image /-
 theorem inf'_eq_csInf_image [ConditionallyCompleteLattice β] (s : Finset α) (H) (f : α → β) :
     s.inf' H f = sInf (f '' s) :=
   @sup'_eq_csSup_image _ βᵒᵈ _ _ H _
 #align finset.inf'_eq_cInf_image Finset.inf'_eq_csInf_image
+-/
 
+#print Finset.sup'_id_eq_csSup /-
 theorem sup'_id_eq_csSup [ConditionallyCompleteLattice α] (s : Finset α) (H) :
     s.sup' H id = sSup s := by rw [sup'_eq_cSup_image s H, Set.image_id]
 #align finset.sup'_id_eq_cSup Finset.sup'_id_eq_csSup
+-/
 
+#print Finset.inf'_id_eq_csInf /-
 theorem inf'_id_eq_csInf [ConditionallyCompleteLattice α] (s : Finset α) (H) :
     s.inf' H id = sInf s :=
   @sup'_id_eq_csSup αᵒᵈ _ _ H
 #align finset.inf'_id_eq_cInf Finset.inf'_id_eq_csInf
+-/
 
 end Finset
 

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

@@ -28,24 +28,12 @@ section ConditionallyCompleteLattice
 
 variable [ConditionallyCompleteLattice α] {s t : Set α} {a b : α}
 
-/- warning: finset.nonempty.sup'_eq_cSup_image -> Finset.Nonempty.sup'_eq_cSup_image is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] {s : Finset.{u2} β} (hs : Finset.Nonempty.{u2} β s) (f : β -> α), Eq.{succ u1} α (Finset.sup'.{u1, u2} α β (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s hs f) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α _inst_1) (Set.image.{u2, u1} β α f ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Finset.{u2} β) (Set.{u2} β) (HasLiftT.mk.{succ u2, succ u2} (Finset.{u2} β) (Set.{u2} β) (CoeTCₓ.coe.{succ u2, succ u2} (Finset.{u2} β) (Set.{u2} β) (Finset.Set.hasCoeT.{u2} β))) s)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] {s : Finset.{u2} β} (hs : Finset.Nonempty.{u2} β s) (f : β -> α), Eq.{succ u1} α (Finset.sup'.{u1, u2} α β (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s hs f) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α _inst_1) (Set.image.{u2, u1} β α f (Finset.toSet.{u2} β s)))
-Case conversion may be inaccurate. Consider using '#align finset.nonempty.sup'_eq_cSup_image Finset.Nonempty.sup'_eq_cSup_imageₓ'. -/
 theorem Finset.Nonempty.sup'_eq_cSup_image {s : Finset β} (hs : s.Nonempty) (f : β → α) :
     s.sup' hs f = sSup (f '' s) :=
   eq_of_forall_ge_iff fun a => by
     simp [csSup_le_iff (s.finite_to_set.image f).BddAbove (hs.to_set.image f)]
 #align finset.nonempty.sup'_eq_cSup_image Finset.Nonempty.sup'_eq_cSup_image
 
-/- warning: finset.nonempty.sup'_id_eq_cSup -> Finset.Nonempty.sup'_id_eq_cSup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] {s : Finset.{u1} α} (hs : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (Finset.sup'.{u1, u1} α α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s hs (id.{succ u1} α)) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] {s : Finset.{u1} α} (hs : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (Finset.sup'.{u1, u1} α α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s hs (id.{succ u1} α)) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α _inst_1) (Finset.toSet.{u1} α s))
-Case conversion may be inaccurate. Consider using '#align finset.nonempty.sup'_id_eq_cSup Finset.Nonempty.sup'_id_eq_cSupₓ'. -/
 theorem Finset.Nonempty.sup'_id_eq_cSup {s : Finset α} (hs : s.Nonempty) : s.sup' hs id = sSup s :=
   by rw [hs.sup'_eq_cSup_image, image_id]
 #align finset.nonempty.sup'_id_eq_cSup Finset.Nonempty.sup'_id_eq_cSup
@@ -56,82 +44,34 @@ section ConditionallyCompleteLinearOrder
 
 variable [ConditionallyCompleteLinearOrder α] {s t : Set α} {a b : α}
 
-/- warning: finset.nonempty.cSup_eq_max' -> Finset.Nonempty.cSup_eq_max' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α} (h : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)) (Finset.max'.{u1} α (ConditionallyCompleteLinearOrder.toLinearOrder.{u1} α _inst_1) s h)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α} (h : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Finset.toSet.{u1} α s)) (Finset.max'.{u1} α (instLinearOrder.{u1} α _inst_1) s h)
-Case conversion may be inaccurate. Consider using '#align finset.nonempty.cSup_eq_max' Finset.Nonempty.cSup_eq_max'ₓ'. -/
 theorem Finset.Nonempty.cSup_eq_max' {s : Finset α} (h : s.Nonempty) : sSup ↑s = s.max' h :=
   eq_of_forall_ge_iff fun a => (csSup_le_iff s.BddAbove h.to_set).trans (s.max'_le_iff h).symm
 #align finset.nonempty.cSup_eq_max' Finset.Nonempty.cSup_eq_max'
 
-/- warning: finset.nonempty.cInf_eq_min' -> Finset.Nonempty.cInf_eq_min' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α} (h : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)) (Finset.min'.{u1} α (ConditionallyCompleteLinearOrder.toLinearOrder.{u1} α _inst_1) s h)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α} (h : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Finset.toSet.{u1} α s)) (Finset.min'.{u1} α (instLinearOrder.{u1} α _inst_1) s h)
-Case conversion may be inaccurate. Consider using '#align finset.nonempty.cInf_eq_min' Finset.Nonempty.cInf_eq_min'ₓ'. -/
 theorem Finset.Nonempty.cInf_eq_min' {s : Finset α} (h : s.Nonempty) : sInf ↑s = s.min' h :=
   @Finset.Nonempty.cSup_eq_max' αᵒᵈ _ s h
 #align finset.nonempty.cInf_eq_min' Finset.Nonempty.cInf_eq_min'
 
-/- warning: finset.nonempty.cSup_mem -> Finset.Nonempty.cSup_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α}, (Finset.Nonempty.{u1} α s) -> (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)) s)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α}, (Finset.Nonempty.{u1} α s) -> (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Finset.toSet.{u1} α s)) s)
-Case conversion may be inaccurate. Consider using '#align finset.nonempty.cSup_mem Finset.Nonempty.cSup_memₓ'. -/
 theorem Finset.Nonempty.cSup_mem {s : Finset α} (h : s.Nonempty) : sSup (s : Set α) ∈ s := by
   rw [h.cSup_eq_max']; exact s.max'_mem _
 #align finset.nonempty.cSup_mem Finset.Nonempty.cSup_mem
 
-/- warning: finset.nonempty.cInf_mem -> Finset.Nonempty.cInf_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α}, (Finset.Nonempty.{u1} α s) -> (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)) s)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α}, (Finset.Nonempty.{u1} α s) -> (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Finset.toSet.{u1} α s)) s)
-Case conversion may be inaccurate. Consider using '#align finset.nonempty.cInf_mem Finset.Nonempty.cInf_memₓ'. -/
 theorem Finset.Nonempty.cInf_mem {s : Finset α} (h : s.Nonempty) : sInf (s : Set α) ∈ s :=
   @Finset.Nonempty.cSup_mem αᵒᵈ _ _ h
 #align finset.nonempty.cInf_mem Finset.Nonempty.cInf_mem
 
-/- warning: set.nonempty.cSup_mem -> Set.Nonempty.cSup_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (Set.Finite.{u1} α s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) s)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (Set.Finite.{u1} α s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) s)
-Case conversion may be inaccurate. Consider using '#align set.nonempty.cSup_mem Set.Nonempty.cSup_memₓ'. -/
 theorem Set.Nonempty.cSup_mem (h : s.Nonempty) (hs : s.Finite) : sSup s ∈ s := by
   lift s to Finset α using hs; exact Finset.Nonempty.cSup_mem h
 #align set.nonempty.cSup_mem Set.Nonempty.cSup_mem
 
-/- warning: set.nonempty.cInf_mem -> Set.Nonempty.cInf_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (Set.Finite.{u1} α s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) s)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (Set.Finite.{u1} α s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) s)
-Case conversion may be inaccurate. Consider using '#align set.nonempty.cInf_mem Set.Nonempty.cInf_memₓ'. -/
 theorem Set.Nonempty.cInf_mem (h : s.Nonempty) (hs : s.Finite) : sInf s ∈ s :=
   @Set.Nonempty.cSup_mem αᵒᵈ _ _ h hs
 #align set.nonempty.cInf_mem Set.Nonempty.cInf_mem
 
-/- warning: set.finite.cSup_lt_iff -> Set.Finite.cSup_lt_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} {a : α}, (Set.Finite.{u1} α s) -> (Set.Nonempty.{u1} α s) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) a) (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x a)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} {a : α}, (Set.Finite.{u1} α s) -> (Set.Nonempty.{u1} α s) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) a) (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x a)))
-Case conversion may be inaccurate. Consider using '#align set.finite.cSup_lt_iff Set.Finite.cSup_lt_iffₓ'. -/
 theorem Set.Finite.cSup_lt_iff (hs : s.Finite) (h : s.Nonempty) : sSup s < a ↔ ∀ x ∈ s, x < a :=
   ⟨fun h x hx => (le_csSup hs.BddAbove hx).trans_lt h, fun H => H _ <| h.cSup_mem hs⟩
 #align set.finite.cSup_lt_iff Set.Finite.cSup_lt_iff
 
-/- warning: set.finite.lt_cInf_iff -> Set.Finite.lt_cInf_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} {a : α}, (Set.Finite.{u1} α s) -> (Set.Nonempty.{u1} α s) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s)) (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a x)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} {a : α}, (Set.Finite.{u1} α s) -> (Set.Nonempty.{u1} α s) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s)) (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a x)))
-Case conversion may be inaccurate. Consider using '#align set.finite.lt_cInf_iff Set.Finite.lt_cInf_iffₓ'. -/
 theorem Set.Finite.lt_cInf_iff (hs : s.Finite) (h : s.Nonempty) : a < sInf s ↔ ∀ x ∈ s, a < x :=
   @Set.Finite.cSup_lt_iff αᵒᵈ _ _ _ hs h
 #align set.finite.lt_cInf_iff Set.Finite.lt_cInf_iff
@@ -148,12 +88,6 @@ non-empty. As a result, we can translate between the two.
 
 namespace Finset
 
-/- warning: finset.sup'_eq_cSup_image -> Finset.sup'_eq_csSup_image is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u2} β] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s) (f : α -> β), Eq.{succ u2} β (Finset.sup'.{u2, u1} β α (Lattice.toSemilatticeSup.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β _inst_1)) s H f) (SupSet.sSup.{u2} β (ConditionallyCompleteLattice.toHasSup.{u2} β _inst_1) (Set.image.{u1, u2} α β f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u2} β] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s) (f : α -> β), Eq.{succ u2} β (Finset.sup'.{u2, u1} β α (Lattice.toSemilatticeSup.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β _inst_1)) s H f) (SupSet.sSup.{u2} β (ConditionallyCompleteLattice.toSupSet.{u2} β _inst_1) (Set.image.{u1, u2} α β f (Finset.toSet.{u1} α s)))
-Case conversion may be inaccurate. Consider using '#align finset.sup'_eq_cSup_image Finset.sup'_eq_csSup_imageₓ'. -/
 theorem sup'_eq_csSup_image [ConditionallyCompleteLattice β] (s : Finset α) (H) (f : α → β) :
     s.sup' H f = sSup (f '' s) := by
   apply le_antisymm
@@ -166,33 +100,15 @@ theorem sup'_eq_csSup_image [ConditionallyCompleteLattice β] (s : Finset α) (H
     exact Finset.le_sup' _ ha
 #align finset.sup'_eq_cSup_image Finset.sup'_eq_csSup_image
 
-/- warning: finset.inf'_eq_cInf_image -> Finset.inf'_eq_csInf_image is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u2} β] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s) (f : α -> β), Eq.{succ u2} β (Finset.inf'.{u2, u1} β α (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β _inst_1)) s H f) (InfSet.sInf.{u2} β (ConditionallyCompleteLattice.toHasInf.{u2} β _inst_1) (Set.image.{u1, u2} α β f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u2} β] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s) (f : α -> β), Eq.{succ u2} β (Finset.inf'.{u2, u1} β α (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β _inst_1)) s H f) (InfSet.sInf.{u2} β (ConditionallyCompleteLattice.toInfSet.{u2} β _inst_1) (Set.image.{u1, u2} α β f (Finset.toSet.{u1} α s)))
-Case conversion may be inaccurate. Consider using '#align finset.inf'_eq_cInf_image Finset.inf'_eq_csInf_imageₓ'. -/
 theorem inf'_eq_csInf_image [ConditionallyCompleteLattice β] (s : Finset α) (H) (f : α → β) :
     s.inf' H f = sInf (f '' s) :=
   @sup'_eq_csSup_image _ βᵒᵈ _ _ H _
 #align finset.inf'_eq_cInf_image Finset.inf'_eq_csInf_image
 
-/- warning: finset.sup'_id_eq_cSup -> Finset.sup'_id_eq_csSup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (Finset.sup'.{u1, u1} α α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s H (id.{succ u1} α)) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (Finset.sup'.{u1, u1} α α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s H (id.{succ u1} α)) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α _inst_1) (Finset.toSet.{u1} α s))
-Case conversion may be inaccurate. Consider using '#align finset.sup'_id_eq_cSup Finset.sup'_id_eq_csSupₓ'. -/
 theorem sup'_id_eq_csSup [ConditionallyCompleteLattice α] (s : Finset α) (H) :
     s.sup' H id = sSup s := by rw [sup'_eq_cSup_image s H, Set.image_id]
 #align finset.sup'_id_eq_cSup Finset.sup'_id_eq_csSup
 
-/- warning: finset.inf'_id_eq_cInf -> Finset.inf'_id_eq_csInf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (Finset.inf'.{u1, u1} α α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s H (id.{succ u1} α)) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (Finset.inf'.{u1, u1} α α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s H (id.{succ u1} α)) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α _inst_1) (Finset.toSet.{u1} α s))
-Case conversion may be inaccurate. Consider using '#align finset.inf'_id_eq_cInf Finset.inf'_id_eq_csInfₓ'. -/
 theorem inf'_id_eq_csInf [ConditionallyCompleteLattice α] (s : Finset α) (H) :
     s.inf' H id = sInf s :=
   @sup'_id_eq_csSup αᵒᵈ _ _ H

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

@@ -82,10 +82,8 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α}, (Finset.Nonempty.{u1} α s) -> (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Finset.toSet.{u1} α s)) s)
 Case conversion may be inaccurate. Consider using '#align finset.nonempty.cSup_mem Finset.Nonempty.cSup_memₓ'. -/
-theorem Finset.Nonempty.cSup_mem {s : Finset α} (h : s.Nonempty) : sSup (s : Set α) ∈ s :=
-  by
-  rw [h.cSup_eq_max']
-  exact s.max'_mem _
+theorem Finset.Nonempty.cSup_mem {s : Finset α} (h : s.Nonempty) : sSup (s : Set α) ∈ s := by
+  rw [h.cSup_eq_max']; exact s.max'_mem _
 #align finset.nonempty.cSup_mem Finset.Nonempty.cSup_mem
 
 /- warning: finset.nonempty.cInf_mem -> Finset.Nonempty.cInf_mem is a dubious translation:
@@ -104,10 +102,8 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (Set.Finite.{u1} α s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) s)
 Case conversion may be inaccurate. Consider using '#align set.nonempty.cSup_mem Set.Nonempty.cSup_memₓ'. -/
-theorem Set.Nonempty.cSup_mem (h : s.Nonempty) (hs : s.Finite) : sSup s ∈ s :=
-  by
-  lift s to Finset α using hs
-  exact Finset.Nonempty.cSup_mem h
+theorem Set.Nonempty.cSup_mem (h : s.Nonempty) (hs : s.Finite) : sSup s ∈ s := by
+  lift s to Finset α using hs; exact Finset.Nonempty.cSup_mem h
 #align set.nonempty.cSup_mem Set.Nonempty.cSup_mem
 
 /- warning: set.nonempty.cInf_mem -> Set.Nonempty.cInf_mem is a dubious translation:

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

@@ -122,7 +122,7 @@ theorem Set.Nonempty.cInf_mem (h : s.Nonempty) (hs : s.Finite) : sInf s ∈ s :=
 
 /- warning: set.finite.cSup_lt_iff -> Set.Finite.cSup_lt_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} {a : α}, (Set.Finite.{u1} α s) -> (Set.Nonempty.{u1} α s) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) a) (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x a)))
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} {a : α}, (Set.Finite.{u1} α s) -> (Set.Nonempty.{u1} α s) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) a) (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x a)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} {a : α}, (Set.Finite.{u1} α s) -> (Set.Nonempty.{u1} α s) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) a) (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x a)))
 Case conversion may be inaccurate. Consider using '#align set.finite.cSup_lt_iff Set.Finite.cSup_lt_iffₓ'. -/
@@ -132,7 +132,7 @@ theorem Set.Finite.cSup_lt_iff (hs : s.Finite) (h : s.Nonempty) : sSup s < a ↔
 
 /- warning: set.finite.lt_cInf_iff -> Set.Finite.lt_cInf_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} {a : α}, (Set.Finite.{u1} α s) -> (Set.Nonempty.{u1} α s) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s)) (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a x)))
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} {a : α}, (Set.Finite.{u1} α s) -> (Set.Nonempty.{u1} α s) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s)) (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a x)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} {a : α}, (Set.Finite.{u1} α s) -> (Set.Nonempty.{u1} α s) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s)) (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a x)))
 Case conversion may be inaccurate. Consider using '#align set.finite.lt_cInf_iff Set.Finite.lt_cInf_iffₓ'. -/

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

@@ -30,23 +30,23 @@ variable [ConditionallyCompleteLattice α] {s t : Set α} {a b : α}
 
 /- warning: finset.nonempty.sup'_eq_cSup_image -> Finset.Nonempty.sup'_eq_cSup_image is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] {s : Finset.{u2} β} (hs : Finset.Nonempty.{u2} β s) (f : β -> α), Eq.{succ u1} α (Finset.sup'.{u1, u2} α β (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s hs f) (SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α _inst_1) (Set.image.{u2, u1} β α f ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Finset.{u2} β) (Set.{u2} β) (HasLiftT.mk.{succ u2, succ u2} (Finset.{u2} β) (Set.{u2} β) (CoeTCₓ.coe.{succ u2, succ u2} (Finset.{u2} β) (Set.{u2} β) (Finset.Set.hasCoeT.{u2} β))) s)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] {s : Finset.{u2} β} (hs : Finset.Nonempty.{u2} β s) (f : β -> α), Eq.{succ u1} α (Finset.sup'.{u1, u2} α β (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s hs f) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α _inst_1) (Set.image.{u2, u1} β α f ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Finset.{u2} β) (Set.{u2} β) (HasLiftT.mk.{succ u2, succ u2} (Finset.{u2} β) (Set.{u2} β) (CoeTCₓ.coe.{succ u2, succ u2} (Finset.{u2} β) (Set.{u2} β) (Finset.Set.hasCoeT.{u2} β))) s)))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] {s : Finset.{u2} β} (hs : Finset.Nonempty.{u2} β s) (f : β -> α), Eq.{succ u1} α (Finset.sup'.{u1, u2} α β (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s hs f) (SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α _inst_1) (Set.image.{u2, u1} β α f (Finset.toSet.{u2} β s)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] {s : Finset.{u2} β} (hs : Finset.Nonempty.{u2} β s) (f : β -> α), Eq.{succ u1} α (Finset.sup'.{u1, u2} α β (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s hs f) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α _inst_1) (Set.image.{u2, u1} β α f (Finset.toSet.{u2} β s)))
 Case conversion may be inaccurate. Consider using '#align finset.nonempty.sup'_eq_cSup_image Finset.Nonempty.sup'_eq_cSup_imageₓ'. -/
 theorem Finset.Nonempty.sup'_eq_cSup_image {s : Finset β} (hs : s.Nonempty) (f : β → α) :
-    s.sup' hs f = supₛ (f '' s) :=
+    s.sup' hs f = sSup (f '' s) :=
   eq_of_forall_ge_iff fun a => by
-    simp [csupₛ_le_iff (s.finite_to_set.image f).BddAbove (hs.to_set.image f)]
+    simp [csSup_le_iff (s.finite_to_set.image f).BddAbove (hs.to_set.image f)]
 #align finset.nonempty.sup'_eq_cSup_image Finset.Nonempty.sup'_eq_cSup_image
 
 /- warning: finset.nonempty.sup'_id_eq_cSup -> Finset.Nonempty.sup'_id_eq_cSup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] {s : Finset.{u1} α} (hs : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (Finset.sup'.{u1, u1} α α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s hs (id.{succ u1} α)) (SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s))
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] {s : Finset.{u1} α} (hs : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (Finset.sup'.{u1, u1} α α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s hs (id.{succ u1} α)) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] {s : Finset.{u1} α} (hs : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (Finset.sup'.{u1, u1} α α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s hs (id.{succ u1} α)) (SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α _inst_1) (Finset.toSet.{u1} α s))
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] {s : Finset.{u1} α} (hs : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (Finset.sup'.{u1, u1} α α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s hs (id.{succ u1} α)) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α _inst_1) (Finset.toSet.{u1} α s))
 Case conversion may be inaccurate. Consider using '#align finset.nonempty.sup'_id_eq_cSup Finset.Nonempty.sup'_id_eq_cSupₓ'. -/
-theorem Finset.Nonempty.sup'_id_eq_cSup {s : Finset α} (hs : s.Nonempty) : s.sup' hs id = supₛ s :=
+theorem Finset.Nonempty.sup'_id_eq_cSup {s : Finset α} (hs : s.Nonempty) : s.sup' hs id = sSup s :=
   by rw [hs.sup'_eq_cSup_image, image_id]
 #align finset.nonempty.sup'_id_eq_cSup Finset.Nonempty.sup'_id_eq_cSup
 
@@ -58,31 +58,31 @@ variable [ConditionallyCompleteLinearOrder α] {s t : Set α} {a b : α}
 
 /- warning: finset.nonempty.cSup_eq_max' -> Finset.Nonempty.cSup_eq_max' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α} (h : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)) (Finset.max'.{u1} α (ConditionallyCompleteLinearOrder.toLinearOrder.{u1} α _inst_1) s h)
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α} (h : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)) (Finset.max'.{u1} α (ConditionallyCompleteLinearOrder.toLinearOrder.{u1} α _inst_1) s h)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α} (h : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Finset.toSet.{u1} α s)) (Finset.max'.{u1} α (instLinearOrder.{u1} α _inst_1) s h)
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α} (h : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Finset.toSet.{u1} α s)) (Finset.max'.{u1} α (instLinearOrder.{u1} α _inst_1) s h)
 Case conversion may be inaccurate. Consider using '#align finset.nonempty.cSup_eq_max' Finset.Nonempty.cSup_eq_max'ₓ'. -/
-theorem Finset.Nonempty.cSup_eq_max' {s : Finset α} (h : s.Nonempty) : supₛ ↑s = s.max' h :=
-  eq_of_forall_ge_iff fun a => (csupₛ_le_iff s.BddAbove h.to_set).trans (s.max'_le_iff h).symm
+theorem Finset.Nonempty.cSup_eq_max' {s : Finset α} (h : s.Nonempty) : sSup ↑s = s.max' h :=
+  eq_of_forall_ge_iff fun a => (csSup_le_iff s.BddAbove h.to_set).trans (s.max'_le_iff h).symm
 #align finset.nonempty.cSup_eq_max' Finset.Nonempty.cSup_eq_max'
 
 /- warning: finset.nonempty.cInf_eq_min' -> Finset.Nonempty.cInf_eq_min' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α} (h : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (InfSet.infₛ.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)) (Finset.min'.{u1} α (ConditionallyCompleteLinearOrder.toLinearOrder.{u1} α _inst_1) s h)
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α} (h : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)) (Finset.min'.{u1} α (ConditionallyCompleteLinearOrder.toLinearOrder.{u1} α _inst_1) s h)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α} (h : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (InfSet.infₛ.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Finset.toSet.{u1} α s)) (Finset.min'.{u1} α (instLinearOrder.{u1} α _inst_1) s h)
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α} (h : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Finset.toSet.{u1} α s)) (Finset.min'.{u1} α (instLinearOrder.{u1} α _inst_1) s h)
 Case conversion may be inaccurate. Consider using '#align finset.nonempty.cInf_eq_min' Finset.Nonempty.cInf_eq_min'ₓ'. -/
-theorem Finset.Nonempty.cInf_eq_min' {s : Finset α} (h : s.Nonempty) : infₛ ↑s = s.min' h :=
+theorem Finset.Nonempty.cInf_eq_min' {s : Finset α} (h : s.Nonempty) : sInf ↑s = s.min' h :=
   @Finset.Nonempty.cSup_eq_max' αᵒᵈ _ s h
 #align finset.nonempty.cInf_eq_min' Finset.Nonempty.cInf_eq_min'
 
 /- warning: finset.nonempty.cSup_mem -> Finset.Nonempty.cSup_mem is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α}, (Finset.Nonempty.{u1} α s) -> (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) (SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)) s)
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α}, (Finset.Nonempty.{u1} α s) -> (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)) s)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α}, (Finset.Nonempty.{u1} α s) -> (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Finset.toSet.{u1} α s)) s)
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α}, (Finset.Nonempty.{u1} α s) -> (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Finset.toSet.{u1} α s)) s)
 Case conversion may be inaccurate. Consider using '#align finset.nonempty.cSup_mem Finset.Nonempty.cSup_memₓ'. -/
-theorem Finset.Nonempty.cSup_mem {s : Finset α} (h : s.Nonempty) : supₛ (s : Set α) ∈ s :=
+theorem Finset.Nonempty.cSup_mem {s : Finset α} (h : s.Nonempty) : sSup (s : Set α) ∈ s :=
   by
   rw [h.cSup_eq_max']
   exact s.max'_mem _
@@ -90,21 +90,21 @@ theorem Finset.Nonempty.cSup_mem {s : Finset α} (h : s.Nonempty) : supₛ (s :
 
 /- warning: finset.nonempty.cInf_mem -> Finset.Nonempty.cInf_mem is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α}, (Finset.Nonempty.{u1} α s) -> (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) (InfSet.infₛ.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)) s)
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α}, (Finset.Nonempty.{u1} α s) -> (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)) s)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α}, (Finset.Nonempty.{u1} α s) -> (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (InfSet.infₛ.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Finset.toSet.{u1} α s)) s)
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Finset.{u1} α}, (Finset.Nonempty.{u1} α s) -> (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Finset.toSet.{u1} α s)) s)
 Case conversion may be inaccurate. Consider using '#align finset.nonempty.cInf_mem Finset.Nonempty.cInf_memₓ'. -/
-theorem Finset.Nonempty.cInf_mem {s : Finset α} (h : s.Nonempty) : infₛ (s : Set α) ∈ s :=
+theorem Finset.Nonempty.cInf_mem {s : Finset α} (h : s.Nonempty) : sInf (s : Set α) ∈ s :=
   @Finset.Nonempty.cSup_mem αᵒᵈ _ _ h
 #align finset.nonempty.cInf_mem Finset.Nonempty.cInf_mem
 
 /- warning: set.nonempty.cSup_mem -> Set.Nonempty.cSup_mem is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (Set.Finite.{u1} α s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) s)
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (Set.Finite.{u1} α s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) s)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (Set.Finite.{u1} α s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) s)
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (Set.Finite.{u1} α s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) s)
 Case conversion may be inaccurate. Consider using '#align set.nonempty.cSup_mem Set.Nonempty.cSup_memₓ'. -/
-theorem Set.Nonempty.cSup_mem (h : s.Nonempty) (hs : s.Finite) : supₛ s ∈ s :=
+theorem Set.Nonempty.cSup_mem (h : s.Nonempty) (hs : s.Finite) : sSup s ∈ s :=
   by
   lift s to Finset α using hs
   exact Finset.Nonempty.cSup_mem h
@@ -112,31 +112,31 @@ theorem Set.Nonempty.cSup_mem (h : s.Nonempty) (hs : s.Finite) : supₛ s ∈ s
 
 /- warning: set.nonempty.cInf_mem -> Set.Nonempty.cInf_mem is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (Set.Finite.{u1} α s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (InfSet.infₛ.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) s)
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (Set.Finite.{u1} α s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) s)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (Set.Finite.{u1} α s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (InfSet.infₛ.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) s)
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (Set.Finite.{u1} α s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) s)
 Case conversion may be inaccurate. Consider using '#align set.nonempty.cInf_mem Set.Nonempty.cInf_memₓ'. -/
-theorem Set.Nonempty.cInf_mem (h : s.Nonempty) (hs : s.Finite) : infₛ s ∈ s :=
+theorem Set.Nonempty.cInf_mem (h : s.Nonempty) (hs : s.Finite) : sInf s ∈ s :=
   @Set.Nonempty.cSup_mem αᵒᵈ _ _ h hs
 #align set.nonempty.cInf_mem Set.Nonempty.cInf_mem
 
 /- warning: set.finite.cSup_lt_iff -> Set.Finite.cSup_lt_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} {a : α}, (Set.Finite.{u1} α s) -> (Set.Nonempty.{u1} α s) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) a) (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x a)))
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} {a : α}, (Set.Finite.{u1} α s) -> (Set.Nonempty.{u1} α s) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) a) (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x a)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} {a : α}, (Set.Finite.{u1} α s) -> (Set.Nonempty.{u1} α s) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) a) (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x a)))
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} {a : α}, (Set.Finite.{u1} α s) -> (Set.Nonempty.{u1} α s) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s) a) (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x a)))
 Case conversion may be inaccurate. Consider using '#align set.finite.cSup_lt_iff Set.Finite.cSup_lt_iffₓ'. -/
-theorem Set.Finite.cSup_lt_iff (hs : s.Finite) (h : s.Nonempty) : supₛ s < a ↔ ∀ x ∈ s, x < a :=
-  ⟨fun h x hx => (le_csupₛ hs.BddAbove hx).trans_lt h, fun H => H _ <| h.cSup_mem hs⟩
+theorem Set.Finite.cSup_lt_iff (hs : s.Finite) (h : s.Nonempty) : sSup s < a ↔ ∀ x ∈ s, x < a :=
+  ⟨fun h x hx => (le_csSup hs.BddAbove hx).trans_lt h, fun H => H _ <| h.cSup_mem hs⟩
 #align set.finite.cSup_lt_iff Set.Finite.cSup_lt_iff
 
 /- warning: set.finite.lt_cInf_iff -> Set.Finite.lt_cInf_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} {a : α}, (Set.Finite.{u1} α s) -> (Set.Nonempty.{u1} α s) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a (InfSet.infₛ.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s)) (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a x)))
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} {a : α}, (Set.Finite.{u1} α s) -> (Set.Nonempty.{u1} α s) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s)) (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a x)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} {a : α}, (Set.Finite.{u1} α s) -> (Set.Nonempty.{u1} α s) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a (InfSet.infₛ.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s)) (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a x)))
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} {a : α}, (Set.Finite.{u1} α s) -> (Set.Nonempty.{u1} α s) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) s)) (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a x)))
 Case conversion may be inaccurate. Consider using '#align set.finite.lt_cInf_iff Set.Finite.lt_cInf_iffₓ'. -/
-theorem Set.Finite.lt_cInf_iff (hs : s.Finite) (h : s.Nonempty) : a < infₛ s ↔ ∀ x ∈ s, a < x :=
+theorem Set.Finite.lt_cInf_iff (hs : s.Finite) (h : s.Nonempty) : a < sInf s ↔ ∀ x ∈ s, a < x :=
   @Set.Finite.cSup_lt_iff αᵒᵈ _ _ _ hs h
 #align set.finite.lt_cInf_iff Set.Finite.lt_cInf_iff
 
@@ -152,55 +152,55 @@ non-empty. As a result, we can translate between the two.
 
 namespace Finset
 
-/- warning: finset.sup'_eq_cSup_image -> Finset.sup'_eq_csupₛ_image is a dubious translation:
+/- warning: finset.sup'_eq_cSup_image -> Finset.sup'_eq_csSup_image is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u2} β] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s) (f : α -> β), Eq.{succ u2} β (Finset.sup'.{u2, u1} β α (Lattice.toSemilatticeSup.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β _inst_1)) s H f) (SupSet.supₛ.{u2} β (ConditionallyCompleteLattice.toHasSup.{u2} β _inst_1) (Set.image.{u1, u2} α β f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u2} β] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s) (f : α -> β), Eq.{succ u2} β (Finset.sup'.{u2, u1} β α (Lattice.toSemilatticeSup.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β _inst_1)) s H f) (SupSet.sSup.{u2} β (ConditionallyCompleteLattice.toHasSup.{u2} β _inst_1) (Set.image.{u1, u2} α β f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u2} β] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s) (f : α -> β), Eq.{succ u2} β (Finset.sup'.{u2, u1} β α (Lattice.toSemilatticeSup.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β _inst_1)) s H f) (SupSet.supₛ.{u2} β (ConditionallyCompleteLattice.toSupSet.{u2} β _inst_1) (Set.image.{u1, u2} α β f (Finset.toSet.{u1} α s)))
-Case conversion may be inaccurate. Consider using '#align finset.sup'_eq_cSup_image Finset.sup'_eq_csupₛ_imageₓ'. -/
-theorem sup'_eq_csupₛ_image [ConditionallyCompleteLattice β] (s : Finset α) (H) (f : α → β) :
-    s.sup' H f = supₛ (f '' s) := by
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u2} β] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s) (f : α -> β), Eq.{succ u2} β (Finset.sup'.{u2, u1} β α (Lattice.toSemilatticeSup.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β _inst_1)) s H f) (SupSet.sSup.{u2} β (ConditionallyCompleteLattice.toSupSet.{u2} β _inst_1) (Set.image.{u1, u2} α β f (Finset.toSet.{u1} α s)))
+Case conversion may be inaccurate. Consider using '#align finset.sup'_eq_cSup_image Finset.sup'_eq_csSup_imageₓ'. -/
+theorem sup'_eq_csSup_image [ConditionallyCompleteLattice β] (s : Finset α) (H) (f : α → β) :
+    s.sup' H f = sSup (f '' s) := by
   apply le_antisymm
   · refine' Finset.sup'_le _ _ fun a ha => _
-    refine' le_csupₛ ⟨s.sup' H f, _⟩ ⟨a, ha, rfl⟩
+    refine' le_csSup ⟨s.sup' H f, _⟩ ⟨a, ha, rfl⟩
     rintro i ⟨j, hj, rfl⟩
     exact Finset.le_sup' _ hj
-  · apply csupₛ_le ((coe_nonempty.mpr H).image _)
+  · apply csSup_le ((coe_nonempty.mpr H).image _)
     rintro _ ⟨a, ha, rfl⟩
     exact Finset.le_sup' _ ha
-#align finset.sup'_eq_cSup_image Finset.sup'_eq_csupₛ_image
+#align finset.sup'_eq_cSup_image Finset.sup'_eq_csSup_image
 
-/- warning: finset.inf'_eq_cInf_image -> Finset.inf'_eq_cinfₛ_image is a dubious translation:
+/- warning: finset.inf'_eq_cInf_image -> Finset.inf'_eq_csInf_image is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u2} β] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s) (f : α -> β), Eq.{succ u2} β (Finset.inf'.{u2, u1} β α (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β _inst_1)) s H f) (InfSet.infₛ.{u2} β (ConditionallyCompleteLattice.toHasInf.{u2} β _inst_1) (Set.image.{u1, u2} α β f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u2} β] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s) (f : α -> β), Eq.{succ u2} β (Finset.inf'.{u2, u1} β α (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β _inst_1)) s H f) (InfSet.sInf.{u2} β (ConditionallyCompleteLattice.toHasInf.{u2} β _inst_1) (Set.image.{u1, u2} α β f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u2} β] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s) (f : α -> β), Eq.{succ u2} β (Finset.inf'.{u2, u1} β α (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β _inst_1)) s H f) (InfSet.infₛ.{u2} β (ConditionallyCompleteLattice.toInfSet.{u2} β _inst_1) (Set.image.{u1, u2} α β f (Finset.toSet.{u1} α s)))
-Case conversion may be inaccurate. Consider using '#align finset.inf'_eq_cInf_image Finset.inf'_eq_cinfₛ_imageₓ'. -/
-theorem inf'_eq_cinfₛ_image [ConditionallyCompleteLattice β] (s : Finset α) (H) (f : α → β) :
-    s.inf' H f = infₛ (f '' s) :=
-  @sup'_eq_csupₛ_image _ βᵒᵈ _ _ H _
-#align finset.inf'_eq_cInf_image Finset.inf'_eq_cinfₛ_image
-
-/- warning: finset.sup'_id_eq_cSup -> Finset.sup'_id_eq_csupₛ is a dubious translation:
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLattice.{u2} β] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s) (f : α -> β), Eq.{succ u2} β (Finset.inf'.{u2, u1} β α (Lattice.toSemilatticeInf.{u2} β (ConditionallyCompleteLattice.toLattice.{u2} β _inst_1)) s H f) (InfSet.sInf.{u2} β (ConditionallyCompleteLattice.toInfSet.{u2} β _inst_1) (Set.image.{u1, u2} α β f (Finset.toSet.{u1} α s)))
+Case conversion may be inaccurate. Consider using '#align finset.inf'_eq_cInf_image Finset.inf'_eq_csInf_imageₓ'. -/
+theorem inf'_eq_csInf_image [ConditionallyCompleteLattice β] (s : Finset α) (H) (f : α → β) :
+    s.inf' H f = sInf (f '' s) :=
+  @sup'_eq_csSup_image _ βᵒᵈ _ _ H _
+#align finset.inf'_eq_cInf_image Finset.inf'_eq_csInf_image
+
+/- warning: finset.sup'_id_eq_cSup -> Finset.sup'_id_eq_csSup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (Finset.sup'.{u1, u1} α α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s H (id.{succ u1} α)) (SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s))
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (Finset.sup'.{u1, u1} α α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s H (id.{succ u1} α)) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (Finset.sup'.{u1, u1} α α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s H (id.{succ u1} α)) (SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α _inst_1) (Finset.toSet.{u1} α s))
-Case conversion may be inaccurate. Consider using '#align finset.sup'_id_eq_cSup Finset.sup'_id_eq_csupₛₓ'. -/
-theorem sup'_id_eq_csupₛ [ConditionallyCompleteLattice α] (s : Finset α) (H) :
-    s.sup' H id = supₛ s := by rw [sup'_eq_cSup_image s H, Set.image_id]
-#align finset.sup'_id_eq_cSup Finset.sup'_id_eq_csupₛ
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (Finset.sup'.{u1, u1} α α (Lattice.toSemilatticeSup.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s H (id.{succ u1} α)) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α _inst_1) (Finset.toSet.{u1} α s))
+Case conversion may be inaccurate. Consider using '#align finset.sup'_id_eq_cSup Finset.sup'_id_eq_csSupₓ'. -/
+theorem sup'_id_eq_csSup [ConditionallyCompleteLattice α] (s : Finset α) (H) :
+    s.sup' H id = sSup s := by rw [sup'_eq_cSup_image s H, Set.image_id]
+#align finset.sup'_id_eq_cSup Finset.sup'_id_eq_csSup
 
-/- warning: finset.inf'_id_eq_cInf -> Finset.inf'_id_eq_cinfₛ is a dubious translation:
+/- warning: finset.inf'_id_eq_cInf -> Finset.inf'_id_eq_csInf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (Finset.inf'.{u1, u1} α α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s H (id.{succ u1} α)) (InfSet.infₛ.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s))
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (Finset.inf'.{u1, u1} α α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s H (id.{succ u1} α)) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (Finset.inf'.{u1, u1} α α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s H (id.{succ u1} α)) (InfSet.infₛ.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α _inst_1) (Finset.toSet.{u1} α s))
-Case conversion may be inaccurate. Consider using '#align finset.inf'_id_eq_cInf Finset.inf'_id_eq_cinfₛₓ'. -/
-theorem inf'_id_eq_cinfₛ [ConditionallyCompleteLattice α] (s : Finset α) (H) :
-    s.inf' H id = infₛ s :=
-  @sup'_id_eq_csupₛ αᵒᵈ _ _ H
-#align finset.inf'_id_eq_cInf Finset.inf'_id_eq_cinfₛ
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLattice.{u1} α] (s : Finset.{u1} α) (H : Finset.Nonempty.{u1} α s), Eq.{succ u1} α (Finset.inf'.{u1, u1} α α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α _inst_1)) s H (id.{succ u1} α)) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α _inst_1) (Finset.toSet.{u1} α s))
+Case conversion may be inaccurate. Consider using '#align finset.inf'_id_eq_cInf Finset.inf'_id_eq_csInfₓ'. -/
+theorem inf'_id_eq_csInf [ConditionallyCompleteLattice α] (s : Finset α) (H) :
+    s.inf' H id = sInf s :=
+  @sup'_id_eq_csSup αᵒᵈ _ _ H
+#align finset.inf'_id_eq_cInf Finset.inf'_id_eq_csInf
 
 end Finset
 

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

Does the following renames:

• cSup_eq_max' -> csSup_eq_max'
• cInf_eq_min' -> csInf_eq_min'
• cSup_mem -> csSup_mem
• cInf_mem -> csInf_mem
• cSup_lt_iff -> csSup_lt_iff
• lt_cInf_iff -> lt_csInf_iff

@@ -22,39 +22,39 @@ section ConditionallyCompleteLinearOrder
 
 variable [ConditionallyCompleteLinearOrder α] {s t : Set α} {a b : α}
 
-theorem Finset.Nonempty.cSup_eq_max' {s : Finset α} (h : s.Nonempty) : sSup ↑s = s.max' h :=
+theorem Finset.Nonempty.csSup_eq_max' {s : Finset α} (h : s.Nonempty) : sSup ↑s = s.max' h :=
   eq_of_forall_ge_iff fun _ => (csSup_le_iff s.bddAbove h.to_set).trans (s.max'_le_iff h).symm
-#align finset.nonempty.cSup_eq_max' Finset.Nonempty.cSup_eq_max'
+#align finset.nonempty.cSup_eq_max' Finset.Nonempty.csSup_eq_max'
 
-theorem Finset.Nonempty.cInf_eq_min' {s : Finset α} (h : s.Nonempty) : sInf ↑s = s.min' h :=
-  @Finset.Nonempty.cSup_eq_max' αᵒᵈ _ s h
-#align finset.nonempty.cInf_eq_min' Finset.Nonempty.cInf_eq_min'
+theorem Finset.Nonempty.csInf_eq_min' {s : Finset α} (h : s.Nonempty) : sInf ↑s = s.min' h :=
+  @Finset.Nonempty.csSup_eq_max' αᵒᵈ _ s h
+#align finset.nonempty.cInf_eq_min' Finset.Nonempty.csInf_eq_min'
 
-theorem Finset.Nonempty.cSup_mem {s : Finset α} (h : s.Nonempty) : sSup (s : Set α) ∈ s := by
-  rw [h.cSup_eq_max']
+theorem Finset.Nonempty.csSup_mem {s : Finset α} (h : s.Nonempty) : sSup (s : Set α) ∈ s := by
+  rw [h.csSup_eq_max']
   exact s.max'_mem _
-#align finset.nonempty.cSup_mem Finset.Nonempty.cSup_mem
+#align finset.nonempty.cSup_mem Finset.Nonempty.csSup_mem
 
-theorem Finset.Nonempty.cInf_mem {s : Finset α} (h : s.Nonempty) : sInf (s : Set α) ∈ s :=
-  @Finset.Nonempty.cSup_mem αᵒᵈ _ _ h
-#align finset.nonempty.cInf_mem Finset.Nonempty.cInf_mem
+theorem Finset.Nonempty.csInf_mem {s : Finset α} (h : s.Nonempty) : sInf (s : Set α) ∈ s :=
+  @Finset.Nonempty.csSup_mem αᵒᵈ _ _ h
+#align finset.nonempty.cInf_mem Finset.Nonempty.csInf_mem
 
-theorem Set.Nonempty.cSup_mem (h : s.Nonempty) (hs : s.Finite) : sSup s ∈ s := by
+theorem Set.Nonempty.csSup_mem (h : s.Nonempty) (hs : s.Finite) : sSup s ∈ s := by
   lift s to Finset α using hs
-  exact Finset.Nonempty.cSup_mem h
-#align set.nonempty.cSup_mem Set.Nonempty.cSup_mem
+  exact Finset.Nonempty.csSup_mem h
+#align set.nonempty.cSup_mem Set.Nonempty.csSup_mem
 
-theorem Set.Nonempty.cInf_mem (h : s.Nonempty) (hs : s.Finite) : sInf s ∈ s :=
-  @Set.Nonempty.cSup_mem αᵒᵈ _ _ h hs
-#align set.nonempty.cInf_mem Set.Nonempty.cInf_mem
+theorem Set.Nonempty.csInf_mem (h : s.Nonempty) (hs : s.Finite) : sInf s ∈ s :=
+  @Set.Nonempty.csSup_mem αᵒᵈ _ _ h hs
+#align set.nonempty.cInf_mem Set.Nonempty.csInf_mem
 
-theorem Set.Finite.cSup_lt_iff (hs : s.Finite) (h : s.Nonempty) : sSup s < a ↔ ∀ x ∈ s, x < a :=
-  ⟨fun h _ hx => (le_csSup hs.bddAbove hx).trans_lt h, fun H => H _ <| h.cSup_mem hs⟩
-#align set.finite.cSup_lt_iff Set.Finite.cSup_lt_iff
+theorem Set.Finite.csSup_lt_iff (hs : s.Finite) (h : s.Nonempty) : sSup s < a ↔ ∀ x ∈ s, x < a :=
+  ⟨fun h _ hx => (le_csSup hs.bddAbove hx).trans_lt h, fun H => H _ <| h.csSup_mem hs⟩
+#align set.finite.cSup_lt_iff Set.Finite.csSup_lt_iff
 
-theorem Set.Finite.lt_cInf_iff (hs : s.Finite) (h : s.Nonempty) : a < sInf s ↔ ∀ x ∈ s, a < x :=
-  @Set.Finite.cSup_lt_iff αᵒᵈ _ _ _ hs h
-#align set.finite.lt_cInf_iff Set.Finite.lt_cInf_iff
+theorem Set.Finite.lt_csInf_iff (hs : s.Finite) (h : s.Nonempty) : a < sInf s ↔ ∀ x ∈ s, a < x :=
+  @Set.Finite.csSup_lt_iff αᵒᵈ _ _ _ hs h
+#align set.finite.lt_cInf_iff Set.Finite.lt_csInf_iff
 
 end ConditionallyCompleteLinearOrder
 

Also adds:

• Lemmas linking the $L^\infty$ norm via WithLp to the standard one on products
• A new BoundedSMul.of_nnnorm_smul_le which eliminates all the positivity juggling.

In theory we could generalize even further to non-unital rings, but that would require more generalization of WithLp, and is trivial for someone to do later; the proofs here will still work.

@@ -66,6 +66,8 @@ non-empty. As a result, we can translate between the two.
 -/
 
 namespace Finset
+
+section ConditionallyCompleteLattice
 variable [ConditionallyCompleteLattice α]
 
 theorem sup'_eq_csSup_image (s : Finset ι) (H : s.Nonempty) (f : ι → α) :
@@ -97,4 +99,16 @@ lemma sup'_univ_eq_ciSup (f : ι → α) : univ.sup' univ_nonempty f = ⨆ i, f
 lemma inf'_univ_eq_ciInf (f : ι → α) : univ.inf' univ_nonempty f = ⨅ i, f i := by
   simp [inf'_eq_csInf_image, iInf]
 
+end ConditionallyCompleteLattice
+
+section ConditionallyCompleteLinearOrderBot
+variable [ConditionallyCompleteLinearOrderBot α]
+
+lemma sup_univ_eq_ciSup [Fintype ι] (f : ι → α) : univ.sup f = ⨆ i, f i :=
+  le_antisymm
+    (Finset.sup_le fun _ _ => le_ciSup (finite_range _).bddAbove _)
+    (ciSup_le' fun _ => Finset.le_sup (mem_univ _))
+
+end ConditionallyCompleteLinearOrderBot
+
 end Finset

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

@@ -16,24 +16,7 @@ import Mathlib.Data.Set.Finite
 
 open Set
 
-variable {α β γ : Type*}
-
-section ConditionallyCompleteLattice
-
-variable [ConditionallyCompleteLattice α] {s t : Set α} {a b : α}
-
-theorem Finset.Nonempty.sup'_eq_cSup_image {s : Finset β} (hs : s.Nonempty) (f : β → α) :
-    s.sup' hs f = sSup (f '' s) :=
-  eq_of_forall_ge_iff fun a => by
-    simp [csSup_le_iff (s.finite_toSet.image f).bddAbove (hs.to_set.image f)]
-#align finset.nonempty.sup'_eq_cSup_image Finset.Nonempty.sup'_eq_cSup_image
-
-theorem Finset.Nonempty.sup'_id_eq_cSup {s : Finset α} (hs : s.Nonempty) :
-    s.sup' hs id = sSup s := by
-  rw [hs.sup'_eq_cSup_image, Set.image_id]
-#align finset.nonempty.sup'_id_eq_cSup Finset.Nonempty.sup'_id_eq_cSup
-
-end ConditionallyCompleteLattice
+variable {ι α β γ : Type*}
 
 section ConditionallyCompleteLinearOrder
 
@@ -76,34 +59,31 @@ theorem Set.Finite.lt_cInf_iff (hs : s.Finite) (h : s.Nonempty) : a < sInf s ↔
 end ConditionallyCompleteLinearOrder
 
 /-!
-### Relation between `Sup` / `Inf` and `Finset.sup'` / `Finset.inf'`
+### Relation between `sSup` / `sInf` and `Finset.sup'` / `Finset.inf'`
 
 Like the `Sup` of a `ConditionallyCompleteLattice`, `Finset.sup'` also requires the set to be
 non-empty. As a result, we can translate between the two.
 -/
 
-
 namespace Finset
-variable {ι : Type*} [ConditionallyCompleteLattice α]
-
-theorem sup'_eq_csSup_image (s : Finset ι) (H) (f : ι → α) : s.sup' H f = sSup (f '' s) := by
-  apply le_antisymm
-  · refine' Finset.sup'_le _ _ fun a ha => _
-    refine' le_csSup ⟨s.sup' H f, _⟩ ⟨a, ha, rfl⟩
-    rintro i ⟨j, hj, rfl⟩
-    exact Finset.le_sup' _ hj
-  · apply csSup_le ((coe_nonempty.mpr H).image _)
-    rintro _ ⟨a, ha, rfl⟩
-    exact Finset.le_sup' _ ha
+variable [ConditionallyCompleteLattice α]
+
+theorem sup'_eq_csSup_image (s : Finset ι) (H : s.Nonempty) (f : ι → α) :
+    s.sup' H f = sSup (f '' s) :=
+  eq_of_forall_ge_iff fun a => by
+    simp [csSup_le_iff (s.finite_toSet.image f).bddAbove (H.to_set.image f)]
 #align finset.sup'_eq_cSup_image Finset.sup'_eq_csSup_image
+#align finset.nonempty.sup'_eq_cSup_image Finset.sup'_eq_csSup_image
 
-theorem inf'_eq_csInf_image (s : Finset ι) (hs) (f : ι → α) : s.inf' hs f = sInf (f '' s) :=
-  sup'_eq_csSup_image (α := αᵒᵈ) _ hs _
+theorem inf'_eq_csInf_image (s : Finset ι) (H : s.Nonempty) (f : ι → α) :
+    s.inf' H f = sInf (f '' s) :=
+  sup'_eq_csSup_image (α := αᵒᵈ) _ H _
 #align finset.inf'_eq_cInf_image Finset.inf'_eq_csInf_image
 
 theorem sup'_id_eq_csSup (s : Finset α) (hs) : s.sup' hs id = sSup s := by
   rw [sup'_eq_csSup_image s hs, Set.image_id]
 #align finset.sup'_id_eq_cSup Finset.sup'_id_eq_csSup
+#align finset.nonempty.sup'_id_eq_cSup Finset.sup'_id_eq_csSup
 
 theorem inf'_id_eq_csInf (s : Finset α) (hs) : s.inf' hs id = sInf s :=
   sup'_id_eq_csSup (α := αᵒᵈ) _ hs

and other simple order lemmas

From LeanAPAP and LeanCamCombi

@@ -84,9 +84,9 @@ non-empty. As a result, we can translate between the two.
 
 
 namespace Finset
+variable {ι : Type*} [ConditionallyCompleteLattice α]
 
-theorem sup'_eq_csSup_image [ConditionallyCompleteLattice β] (s : Finset α) (H) (f : α → β) :
-    s.sup' H f = sSup (f '' s) := by
+theorem sup'_eq_csSup_image (s : Finset ι) (H) (f : ι → α) : s.sup' H f = sSup (f '' s) := by
   apply le_antisymm
   · refine' Finset.sup'_le _ _ fun a ha => _
     refine' le_csSup ⟨s.sup' H f, _⟩ ⟨a, ha, rfl⟩
@@ -97,18 +97,24 @@ theorem sup'_eq_csSup_image [ConditionallyCompleteLattice β] (s : Finset α) (H
     exact Finset.le_sup' _ ha
 #align finset.sup'_eq_cSup_image Finset.sup'_eq_csSup_image
 
-theorem inf'_eq_csInf_image [ConditionallyCompleteLattice β] (s : Finset α) (H) (f : α → β) :
-    s.inf' H f = sInf (f '' s) :=
-  @sup'_eq_csSup_image _ βᵒᵈ _ _ H _
+theorem inf'_eq_csInf_image (s : Finset ι) (hs) (f : ι → α) : s.inf' hs f = sInf (f '' s) :=
+  sup'_eq_csSup_image (α := αᵒᵈ) _ hs _
 #align finset.inf'_eq_cInf_image Finset.inf'_eq_csInf_image
 
-theorem sup'_id_eq_csSup [ConditionallyCompleteLattice α] (s : Finset α) (H) :
-    s.sup' H id = sSup s := by rw [sup'_eq_csSup_image s H, Set.image_id]
+theorem sup'_id_eq_csSup (s : Finset α) (hs) : s.sup' hs id = sSup s := by
+  rw [sup'_eq_csSup_image s hs, Set.image_id]
 #align finset.sup'_id_eq_cSup Finset.sup'_id_eq_csSup
 
-theorem inf'_id_eq_csInf [ConditionallyCompleteLattice α] (s : Finset α) (H) :
-    s.inf' H id = sInf s :=
-  @sup'_id_eq_csSup αᵒᵈ _ _ H
+theorem inf'_id_eq_csInf (s : Finset α) (hs) : s.inf' hs id = sInf s :=
+  sup'_id_eq_csSup (α := αᵒᵈ) _ hs
 #align finset.inf'_id_eq_cInf Finset.inf'_id_eq_csInf
 
+variable [Fintype ι] [Nonempty ι]
+
+lemma sup'_univ_eq_ciSup (f : ι → α) : univ.sup' univ_nonempty f = ⨆ i, f i := by
+  simp [sup'_eq_csSup_image, iSup]
+
+lemma inf'_univ_eq_ciInf (f : ι → α) : univ.inf' univ_nonempty f = ⨅ i, f i := by
+  simp [inf'_eq_csInf_image, iInf]
+
 end Finset

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

@@ -28,8 +28,9 @@ theorem Finset.Nonempty.sup'_eq_cSup_image {s : Finset β} (hs : s.Nonempty) (f
     simp [csSup_le_iff (s.finite_toSet.image f).bddAbove (hs.to_set.image f)]
 #align finset.nonempty.sup'_eq_cSup_image Finset.Nonempty.sup'_eq_cSup_image
 
-theorem Finset.Nonempty.sup'_id_eq_cSup {s : Finset α} (hs : s.Nonempty) : s.sup' hs id = sSup s :=
-  by rw [hs.sup'_eq_cSup_image, Set.image_id]
+theorem Finset.Nonempty.sup'_id_eq_cSup {s : Finset α} (hs : s.Nonempty) :
+    s.sup' hs id = sSup s := by
+  rw [hs.sup'_eq_cSup_image, Set.image_id]
 #align finset.nonempty.sup'_id_eq_cSup Finset.Nonempty.sup'_id_eq_cSup
 
 end ConditionallyCompleteLattice

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

This has nice performance benefits.

@@ -16,7 +16,7 @@ import Mathlib.Data.Set.Finite
 
 open Set
 
-variable {α β γ : Type _}
+variable {α β γ : Type*}
 
 section ConditionallyCompleteLattice
 

• 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) 2018 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel
-
-! This file was ported from Lean 3 source module order.conditionally_complete_lattice.finset
-! leanprover-community/mathlib commit 2445c98ae4b87eabebdde552593519b9b6dc350c
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.ConditionallyCompleteLattice.Basic
 import Mathlib.Data.Set.Finite
 
+#align_import order.conditionally_complete_lattice.finset from "leanprover-community/mathlib"@"2445c98ae4b87eabebdde552593519b9b6dc350c"
+
 /-!
 # Conditionally complete lattices and finite sets.
 

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>

@@ -26,12 +26,12 @@ section ConditionallyCompleteLattice
 variable [ConditionallyCompleteLattice α] {s t : Set α} {a b : α}
 
 theorem Finset.Nonempty.sup'_eq_cSup_image {s : Finset β} (hs : s.Nonempty) (f : β → α) :
-    s.sup' hs f = supₛ (f '' s) :=
+    s.sup' hs f = sSup (f '' s) :=
   eq_of_forall_ge_iff fun a => by
-    simp [csupₛ_le_iff (s.finite_toSet.image f).bddAbove (hs.to_set.image f)]
+    simp [csSup_le_iff (s.finite_toSet.image f).bddAbove (hs.to_set.image f)]
 #align finset.nonempty.sup'_eq_cSup_image Finset.Nonempty.sup'_eq_cSup_image
 
-theorem Finset.Nonempty.sup'_id_eq_cSup {s : Finset α} (hs : s.Nonempty) : s.sup' hs id = supₛ s :=
+theorem Finset.Nonempty.sup'_id_eq_cSup {s : Finset α} (hs : s.Nonempty) : s.sup' hs id = sSup s :=
   by rw [hs.sup'_eq_cSup_image, Set.image_id]
 #align finset.nonempty.sup'_id_eq_cSup Finset.Nonempty.sup'_id_eq_cSup
 
@@ -41,37 +41,37 @@ section ConditionallyCompleteLinearOrder
 
 variable [ConditionallyCompleteLinearOrder α] {s t : Set α} {a b : α}
 
-theorem Finset.Nonempty.cSup_eq_max' {s : Finset α} (h : s.Nonempty) : supₛ ↑s = s.max' h :=
-  eq_of_forall_ge_iff fun _ => (csupₛ_le_iff s.bddAbove h.to_set).trans (s.max'_le_iff h).symm
+theorem Finset.Nonempty.cSup_eq_max' {s : Finset α} (h : s.Nonempty) : sSup ↑s = s.max' h :=
+  eq_of_forall_ge_iff fun _ => (csSup_le_iff s.bddAbove h.to_set).trans (s.max'_le_iff h).symm
 #align finset.nonempty.cSup_eq_max' Finset.Nonempty.cSup_eq_max'
 
-theorem Finset.Nonempty.cInf_eq_min' {s : Finset α} (h : s.Nonempty) : infₛ ↑s = s.min' h :=
+theorem Finset.Nonempty.cInf_eq_min' {s : Finset α} (h : s.Nonempty) : sInf ↑s = s.min' h :=
   @Finset.Nonempty.cSup_eq_max' αᵒᵈ _ s h
 #align finset.nonempty.cInf_eq_min' Finset.Nonempty.cInf_eq_min'
 
-theorem Finset.Nonempty.cSup_mem {s : Finset α} (h : s.Nonempty) : supₛ (s : Set α) ∈ s := by
+theorem Finset.Nonempty.cSup_mem {s : Finset α} (h : s.Nonempty) : sSup (s : Set α) ∈ s := by
   rw [h.cSup_eq_max']
   exact s.max'_mem _
 #align finset.nonempty.cSup_mem Finset.Nonempty.cSup_mem
 
-theorem Finset.Nonempty.cInf_mem {s : Finset α} (h : s.Nonempty) : infₛ (s : Set α) ∈ s :=
+theorem Finset.Nonempty.cInf_mem {s : Finset α} (h : s.Nonempty) : sInf (s : Set α) ∈ s :=
   @Finset.Nonempty.cSup_mem αᵒᵈ _ _ h
 #align finset.nonempty.cInf_mem Finset.Nonempty.cInf_mem
 
-theorem Set.Nonempty.cSup_mem (h : s.Nonempty) (hs : s.Finite) : supₛ s ∈ s := by
+theorem Set.Nonempty.cSup_mem (h : s.Nonempty) (hs : s.Finite) : sSup s ∈ s := by
   lift s to Finset α using hs
   exact Finset.Nonempty.cSup_mem h
 #align set.nonempty.cSup_mem Set.Nonempty.cSup_mem
 
-theorem Set.Nonempty.cInf_mem (h : s.Nonempty) (hs : s.Finite) : infₛ s ∈ s :=
+theorem Set.Nonempty.cInf_mem (h : s.Nonempty) (hs : s.Finite) : sInf s ∈ s :=
   @Set.Nonempty.cSup_mem αᵒᵈ _ _ h hs
 #align set.nonempty.cInf_mem Set.Nonempty.cInf_mem
 
-theorem Set.Finite.cSup_lt_iff (hs : s.Finite) (h : s.Nonempty) : supₛ s < a ↔ ∀ x ∈ s, x < a :=
-  ⟨fun h _ hx => (le_csupₛ hs.bddAbove hx).trans_lt h, fun H => H _ <| h.cSup_mem hs⟩
+theorem Set.Finite.cSup_lt_iff (hs : s.Finite) (h : s.Nonempty) : sSup s < a ↔ ∀ x ∈ s, x < a :=
+  ⟨fun h _ hx => (le_csSup hs.bddAbove hx).trans_lt h, fun H => H _ <| h.cSup_mem hs⟩
 #align set.finite.cSup_lt_iff Set.Finite.cSup_lt_iff
 
-theorem Set.Finite.lt_cInf_iff (hs : s.Finite) (h : s.Nonempty) : a < infₛ s ↔ ∀ x ∈ s, a < x :=
+theorem Set.Finite.lt_cInf_iff (hs : s.Finite) (h : s.Nonempty) : a < sInf s ↔ ∀ x ∈ s, a < x :=
   @Set.Finite.cSup_lt_iff αᵒᵈ _ _ _ hs h
 #align set.finite.lt_cInf_iff Set.Finite.lt_cInf_iff
 
@@ -87,30 +87,30 @@ non-empty. As a result, we can translate between the two.
 
 namespace Finset
 
-theorem sup'_eq_csupₛ_image [ConditionallyCompleteLattice β] (s : Finset α) (H) (f : α → β) :
-    s.sup' H f = supₛ (f '' s) := by
+theorem sup'_eq_csSup_image [ConditionallyCompleteLattice β] (s : Finset α) (H) (f : α → β) :
+    s.sup' H f = sSup (f '' s) := by
   apply le_antisymm
   · refine' Finset.sup'_le _ _ fun a ha => _
-    refine' le_csupₛ ⟨s.sup' H f, _⟩ ⟨a, ha, rfl⟩
+    refine' le_csSup ⟨s.sup' H f, _⟩ ⟨a, ha, rfl⟩
     rintro i ⟨j, hj, rfl⟩
     exact Finset.le_sup' _ hj
-  · apply csupₛ_le ((coe_nonempty.mpr H).image _)
+  · apply csSup_le ((coe_nonempty.mpr H).image _)
     rintro _ ⟨a, ha, rfl⟩
     exact Finset.le_sup' _ ha
-#align finset.sup'_eq_cSup_image Finset.sup'_eq_csupₛ_image
+#align finset.sup'_eq_cSup_image Finset.sup'_eq_csSup_image
 
-theorem inf'_eq_cinfₛ_image [ConditionallyCompleteLattice β] (s : Finset α) (H) (f : α → β) :
-    s.inf' H f = infₛ (f '' s) :=
-  @sup'_eq_csupₛ_image _ βᵒᵈ _ _ H _
-#align finset.inf'_eq_cInf_image Finset.inf'_eq_cinfₛ_image
+theorem inf'_eq_csInf_image [ConditionallyCompleteLattice β] (s : Finset α) (H) (f : α → β) :
+    s.inf' H f = sInf (f '' s) :=
+  @sup'_eq_csSup_image _ βᵒᵈ _ _ H _
+#align finset.inf'_eq_cInf_image Finset.inf'_eq_csInf_image
 
-theorem sup'_id_eq_csupₛ [ConditionallyCompleteLattice α] (s : Finset α) (H) :
-    s.sup' H id = supₛ s := by rw [sup'_eq_csupₛ_image s H, Set.image_id]
-#align finset.sup'_id_eq_cSup Finset.sup'_id_eq_csupₛ
+theorem sup'_id_eq_csSup [ConditionallyCompleteLattice α] (s : Finset α) (H) :
+    s.sup' H id = sSup s := by rw [sup'_eq_csSup_image s H, Set.image_id]
+#align finset.sup'_id_eq_cSup Finset.sup'_id_eq_csSup
 
-theorem inf'_id_eq_cinfₛ [ConditionallyCompleteLattice α] (s : Finset α) (H) :
-    s.inf' H id = infₛ s :=
-  @sup'_id_eq_csupₛ αᵒᵈ _ _ H
-#align finset.inf'_id_eq_cInf Finset.inf'_id_eq_cinfₛ
+theorem inf'_id_eq_csInf [ConditionallyCompleteLattice α] (s : Finset α) (H) :
+    s.inf' H id = sInf s :=
+  @sup'_id_eq_csSup αᵒᵈ _ _ H
+#align finset.inf'_id_eq_cInf Finset.inf'_id_eq_csInf
 
 end Finset

port of order.partial.sups

Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Johan Commelin <johan@commelin.net>

@@ -87,7 +87,7 @@ non-empty. As a result, we can translate between the two.
 
 namespace Finset
 
-theorem sup'_eq_cSup_image [ConditionallyCompleteLattice β] (s : Finset α) (H) (f : α → β) :
+theorem sup'_eq_csupₛ_image [ConditionallyCompleteLattice β] (s : Finset α) (H) (f : α → β) :
     s.sup' H f = supₛ (f '' s) := by
   apply le_antisymm
   · refine' Finset.sup'_le _ _ fun a ha => _
@@ -97,20 +97,20 @@ theorem sup'_eq_cSup_image [ConditionallyCompleteLattice β] (s : Finset α) (H)
   · apply csupₛ_le ((coe_nonempty.mpr H).image _)
     rintro _ ⟨a, ha, rfl⟩
     exact Finset.le_sup' _ ha
-#align finset.sup'_eq_cSup_image Finset.sup'_eq_cSup_image
+#align finset.sup'_eq_cSup_image Finset.sup'_eq_csupₛ_image
 
-theorem inf'_eq_cInf_image [ConditionallyCompleteLattice β] (s : Finset α) (H) (f : α → β) :
+theorem inf'_eq_cinfₛ_image [ConditionallyCompleteLattice β] (s : Finset α) (H) (f : α → β) :
     s.inf' H f = infₛ (f '' s) :=
-  @sup'_eq_cSup_image _ βᵒᵈ _ _ H _
-#align finset.inf'_eq_cInf_image Finset.inf'_eq_cInf_image
+  @sup'_eq_csupₛ_image _ βᵒᵈ _ _ H _
+#align finset.inf'_eq_cInf_image Finset.inf'_eq_cinfₛ_image
 
-theorem sup'_id_eq_cSup [ConditionallyCompleteLattice α] (s : Finset α) (H) :
-    s.sup' H id = supₛ s := by rw [sup'_eq_cSup_image s H, Set.image_id]
-#align finset.sup'_id_eq_cSup Finset.sup'_id_eq_cSup
+theorem sup'_id_eq_csupₛ [ConditionallyCompleteLattice α] (s : Finset α) (H) :
+    s.sup' H id = supₛ s := by rw [sup'_eq_csupₛ_image s H, Set.image_id]
+#align finset.sup'_id_eq_cSup Finset.sup'_id_eq_csupₛ
 
-theorem inf'_id_eq_cInf [ConditionallyCompleteLattice α] (s : Finset α) (H) :
+theorem inf'_id_eq_cinfₛ [ConditionallyCompleteLattice α] (s : Finset α) (H) :
     s.inf' H id = infₛ s :=
-  @sup'_id_eq_cSup αᵒᵈ _ _ H
-#align finset.inf'_id_eq_cInf Finset.inf'_id_eq_cInf
+  @sup'_id_eq_csupₛ αᵒᵈ _ _ H
+#align finset.inf'_id_eq_cInf Finset.inf'_id_eq_cinfₛ
 
 end Finset

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