order.complete_lattice_intervals ⟷ Mathlib.Order.CompleteLatticeIntervals

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Heather Macbeth
 -/
 import Order.ConditionallyCompleteLattice.Basic
-import Data.Set.Intervals.OrdConnected
+import Order.Interval.Set.OrdConnected
 
 #align_import order.complete_lattice_intervals from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"
 

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

@@ -125,19 +125,19 @@ noncomputable def subsetConditionallyCompleteLinearOrder [Inhabited s]
     le_cSup := by
       rintro t c h_bdd hct
       have := (Subtype.mono_coe s).le_csSup_image hct h_bdd
-      rwa [subset_sSup_of_within s (h_Sup ⟨c, hct⟩ h_bdd)] at this 
+      rwa [subset_sSup_of_within s (h_Sup ⟨c, hct⟩ h_bdd)] at this
     cSup_le := by
       rintro t B ht hB
       have := (Subtype.mono_coe s).csSup_image_le ht hB
-      rwa [subset_sSup_of_within s (h_Sup ht ⟨B, hB⟩)] at this 
+      rwa [subset_sSup_of_within s (h_Sup ht ⟨B, hB⟩)] at this
     le_cInf := by
       intro t B ht hB
       have := (Subtype.mono_coe s).le_csInf_image ht hB
-      rwa [subset_sInf_of_within s (h_Inf ht ⟨B, hB⟩)] at this 
+      rwa [subset_sInf_of_within s (h_Inf ht ⟨B, hB⟩)] at this
     cInf_le := by
       rintro t c h_bdd hct
       have := (Subtype.mono_coe s).csInf_image_le hct h_bdd
-      rwa [subset_sInf_of_within s (h_Inf ⟨c, hct⟩ h_bdd)] at this  }
+      rwa [subset_sInf_of_within s (h_Inf ⟨c, hct⟩ h_bdd)] at this }
 #align subset_conditionally_complete_linear_order subsetConditionallyCompleteLinearOrder
 -/
 

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

@@ -3,8 +3,8 @@ Copyright (c) 2022 Heather Macbeth. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Heather Macbeth
 -/
-import Mathbin.Order.ConditionallyCompleteLattice.Basic
-import Mathbin.Data.Set.Intervals.OrdConnected
+import Order.ConditionallyCompleteLattice.Basic
+import Data.Set.Intervals.OrdConnected
 
 #align_import order.complete_lattice_intervals from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"
 

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

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Heather Macbeth. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Heather Macbeth
-
-! This file was ported from Lean 3 source module order.complete_lattice_intervals
-! leanprover-community/mathlib commit c3291da49cfa65f0d43b094750541c0731edc932
-! 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.Intervals.OrdConnected
 
+#align_import order.complete_lattice_intervals from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"
+
 /-! # Subtypes of conditionally complete linear orders
 
 > THIS FILE IS SYNCHRONIZED WITH MATHLIB4.

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

@@ -106,6 +106,7 @@ attribute [local instance] subsetSupSet
 
 attribute [local instance] subsetInfSet
 
+#print subsetConditionallyCompleteLinearOrder /-
 /-- For a nonempty subset of a conditionally complete linear order to be a conditionally complete
 linear order, it suffices that it contain the `Sup` of all its nonempty bounded-above subsets, and
 the `Inf` of all its nonempty bounded-below subsets.
@@ -141,9 +142,11 @@ noncomputable def subsetConditionallyCompleteLinearOrder [Inhabited s]
       have := (Subtype.mono_coe s).csInf_image_le hct h_bdd
       rwa [subset_sInf_of_within s (h_Inf ⟨c, hct⟩ h_bdd)] at this  }
 #align subset_conditionally_complete_linear_order subsetConditionallyCompleteLinearOrder
+-/
 
 section OrdConnected
 
+#print sSup_within_of_ordConnected /-
 /-- The `Sup` function on a nonempty `ord_connected` set `s` in a conditionally complete linear
 order takes values within `s`, for all nonempty bounded-above subsets of `s`. -/
 theorem sSup_within_of_ordConnected {s : Set α} [hs : OrdConnected s] ⦃t : Set s⦄ (ht : t.Nonempty)
@@ -155,7 +158,9 @@ theorem sSup_within_of_ordConnected {s : Set α} [hs : OrdConnected s] ⦃t : Se
   · exact (Subtype.mono_coe s).le_csSup_image hct ⟨B, hB⟩
   · exact (Subtype.mono_coe s).csSup_image_le ⟨c, hct⟩ hB
 #align Sup_within_of_ord_connected sSup_within_of_ordConnected
+-/
 
+#print sInf_within_of_ordConnected /-
 /-- The `Inf` function on a nonempty `ord_connected` set `s` in a conditionally complete linear
 order takes values within `s`, for all nonempty bounded-below subsets of `s`. -/
 theorem sInf_within_of_ordConnected {s : Set α} [hs : OrdConnected s] ⦃t : Set s⦄ (ht : t.Nonempty)
@@ -167,6 +172,7 @@ theorem sInf_within_of_ordConnected {s : Set α} [hs : OrdConnected s] ⦃t : Se
   · exact (Subtype.mono_coe s).le_csInf_image ⟨c, hct⟩ hB
   · exact (Subtype.mono_coe s).csInf_image_le hct ⟨B, hB⟩
 #align Inf_within_of_ord_connected sInf_within_of_ordConnected
+-/
 
 #print ordConnectedSubsetConditionallyCompleteLinearOrder /-
 /-- A nonempty `ord_connected` set in a conditionally complete linear order is naturally a

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

@@ -127,19 +127,19 @@ noncomputable def subsetConditionallyCompleteLinearOrder [Inhabited s]
     le_cSup := by
       rintro t c h_bdd hct
       have := (Subtype.mono_coe s).le_csSup_image hct h_bdd
-      rwa [subset_sSup_of_within s (h_Sup ⟨c, hct⟩ h_bdd)] at this
+      rwa [subset_sSup_of_within s (h_Sup ⟨c, hct⟩ h_bdd)] at this 
     cSup_le := by
       rintro t B ht hB
       have := (Subtype.mono_coe s).csSup_image_le ht hB
-      rwa [subset_sSup_of_within s (h_Sup ht ⟨B, hB⟩)] at this
+      rwa [subset_sSup_of_within s (h_Sup ht ⟨B, hB⟩)] at this 
     le_cInf := by
       intro t B ht hB
       have := (Subtype.mono_coe s).le_csInf_image ht hB
-      rwa [subset_sInf_of_within s (h_Inf ht ⟨B, hB⟩)] at this
+      rwa [subset_sInf_of_within s (h_Inf ht ⟨B, hB⟩)] at this 
     cInf_le := by
       rintro t c h_bdd hct
       have := (Subtype.mono_coe s).csInf_image_le hct h_bdd
-      rwa [subset_sInf_of_within s (h_Inf ⟨c, hct⟩ h_bdd)] at this }
+      rwa [subset_sInf_of_within s (h_Inf ⟨c, hct⟩ h_bdd)] at this  }
 #align subset_conditionally_complete_linear_order subsetConditionallyCompleteLinearOrder
 
 section OrdConnected

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

@@ -28,7 +28,7 @@ default values for `Sup` and `Inf`.
 -/
 
 
-open Classical
+open scoped Classical
 
 open Set
 

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

@@ -106,12 +106,6 @@ attribute [local instance] subsetSupSet
 
 attribute [local instance] subsetInfSet
 
-/- warning: subset_conditionally_complete_linear_order -> subsetConditionallyCompleteLinearOrder is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (s : Set.{u1} α) [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : Inhabited.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)], (forall {t : Set.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)}, (Set.Nonempty.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) t) -> (BddAbove.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)) t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) t)) s)) -> (forall {t : Set.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)}, (Set.Nonempty.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) t) -> (BddBelow.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)) t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) t)) s)) -> (ConditionallyCompleteLinearOrder.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s))
-but is expected to have type
-  forall {α : Type.{u1}} (s : Set.{u1} α) [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : Inhabited.{succ u1} (Set.Elem.{u1} α s)], (forall {t : Set.{u1} (Set.Elem.{u1} α s)}, (Set.Nonempty.{u1} (Set.Elem.{u1} α s) t) -> (BddAbove.{u1} (Set.Elem.{u1} α s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (Set.Elem.{u1} α s) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t)) s)) -> (forall {t : Set.{u1} (Set.Elem.{u1} α s)}, (Set.Nonempty.{u1} (Set.Elem.{u1} α s) t) -> (BddBelow.{u1} (Set.Elem.{u1} α s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (Set.Elem.{u1} α s) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t)) s)) -> (ConditionallyCompleteLinearOrder.{u1} (Set.Elem.{u1} α s))
-Case conversion may be inaccurate. Consider using '#align subset_conditionally_complete_linear_order subsetConditionallyCompleteLinearOrderₓ'. -/
 /-- For a nonempty subset of a conditionally complete linear order to be a conditionally complete
 linear order, it suffices that it contain the `Sup` of all its nonempty bounded-above subsets, and
 the `Inf` of all its nonempty bounded-below subsets.
@@ -150,12 +144,6 @@ noncomputable def subsetConditionallyCompleteLinearOrder [Inhabited s]
 
 section OrdConnected
 
-/- warning: Sup_within_of_ord_connected -> sSup_within_of_ordConnected is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} [hs : Set.OrdConnected.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) s] {{t : Set.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)}}, (Set.Nonempty.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) t) -> (BddAbove.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)) t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) t)) s)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} [hs : Set.OrdConnected.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) s] {{t : Set.{u1} (Set.Elem.{u1} α s)}}, (Set.Nonempty.{u1} (Set.Elem.{u1} α s) t) -> (BddAbove.{u1} (Set.Elem.{u1} α s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (Set.Elem.{u1} α s) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t)) s)
-Case conversion may be inaccurate. Consider using '#align Sup_within_of_ord_connected sSup_within_of_ordConnectedₓ'. -/
 /-- The `Sup` function on a nonempty `ord_connected` set `s` in a conditionally complete linear
 order takes values within `s`, for all nonempty bounded-above subsets of `s`. -/
 theorem sSup_within_of_ordConnected {s : Set α} [hs : OrdConnected s] ⦃t : Set s⦄ (ht : t.Nonempty)
@@ -168,12 +156,6 @@ theorem sSup_within_of_ordConnected {s : Set α} [hs : OrdConnected s] ⦃t : Se
   · exact (Subtype.mono_coe s).csSup_image_le ⟨c, hct⟩ hB
 #align Sup_within_of_ord_connected sSup_within_of_ordConnected
 
-/- warning: Inf_within_of_ord_connected -> sInf_within_of_ordConnected is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} [hs : Set.OrdConnected.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) s] {{t : Set.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)}}, (Set.Nonempty.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) t) -> (BddBelow.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)) t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) t)) s)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} [hs : Set.OrdConnected.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) s] {{t : Set.{u1} (Set.Elem.{u1} α s)}}, (Set.Nonempty.{u1} (Set.Elem.{u1} α s) t) -> (BddBelow.{u1} (Set.Elem.{u1} α s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (Set.Elem.{u1} α s) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t)) s)
-Case conversion may be inaccurate. Consider using '#align Inf_within_of_ord_connected sInf_within_of_ordConnectedₓ'. -/
 /-- The `Inf` function on a nonempty `ord_connected` set `s` in a conditionally complete linear
 order takes values within `s`, for all nonempty bounded-below subsets of `s`. -/
 theorem sInf_within_of_ordConnected {s : Set α} [hs : OrdConnected s] ⦃t : Set s⦄ (ht : t.Nonempty)

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

@@ -43,26 +43,26 @@ variable [SupSet α]
 non-canonical (it uses `default s`); it should be used only as here, as an auxiliary instance in the
 construction of the `conditionally_complete_linear_order` structure. -/
 noncomputable def subsetSupSet [Inhabited s] : SupSet s
-    where supₛ t :=
-    if ht : supₛ (coe '' t : Set α) ∈ s then ⟨supₛ (coe '' t : Set α), ht⟩ else default
+    where sSup t :=
+    if ht : sSup (coe '' t : Set α) ∈ s then ⟨sSup (coe '' t : Set α), ht⟩ else default
 #align subset_has_Sup subsetSupSet
 -/
 
 attribute [local instance] subsetSupSet
 
-#print subset_supₛ_def /-
+#print subset_sSup_def /-
 @[simp]
-theorem subset_supₛ_def [Inhabited s] :
-    @supₛ s _ = fun t =>
-      if ht : supₛ (coe '' t : Set α) ∈ s then ⟨supₛ (coe '' t : Set α), ht⟩ else default :=
+theorem subset_sSup_def [Inhabited s] :
+    @sSup s _ = fun t =>
+      if ht : sSup (coe '' t : Set α) ∈ s then ⟨sSup (coe '' t : Set α), ht⟩ else default :=
   rfl
-#align subset_Sup_def subset_supₛ_def
+#align subset_Sup_def subset_sSup_def
 -/
 
-#print subset_supₛ_of_within /-
-theorem subset_supₛ_of_within [Inhabited s] {t : Set s} (h : supₛ (coe '' t : Set α) ∈ s) :
-    supₛ (coe '' t : Set α) = (@supₛ s _ t : α) := by simp [dif_pos h]
-#align subset_Sup_of_within subset_supₛ_of_within
+#print subset_sSup_of_within /-
+theorem subset_sSup_of_within [Inhabited s] {t : Set s} (h : sSup (coe '' t : Set α) ∈ s) :
+    sSup (coe '' t : Set α) = (@sSup s _ t : α) := by simp [dif_pos h]
+#align subset_Sup_of_within subset_sSup_of_within
 -/
 
 end SupSet
@@ -76,26 +76,26 @@ variable [InfSet α]
 non-canonical (it uses `default s`); it should be used only as here, as an auxiliary instance in the
 construction of the `conditionally_complete_linear_order` structure. -/
 noncomputable def subsetInfSet [Inhabited s] : InfSet s
-    where infₛ t :=
-    if ht : infₛ (coe '' t : Set α) ∈ s then ⟨infₛ (coe '' t : Set α), ht⟩ else default
+    where sInf t :=
+    if ht : sInf (coe '' t : Set α) ∈ s then ⟨sInf (coe '' t : Set α), ht⟩ else default
 #align subset_has_Inf subsetInfSet
 -/
 
 attribute [local instance] subsetInfSet
 
-#print subset_infₛ_def /-
+#print subset_sInf_def /-
 @[simp]
-theorem subset_infₛ_def [Inhabited s] :
-    @infₛ s _ = fun t =>
-      if ht : infₛ (coe '' t : Set α) ∈ s then ⟨infₛ (coe '' t : Set α), ht⟩ else default :=
+theorem subset_sInf_def [Inhabited s] :
+    @sInf s _ = fun t =>
+      if ht : sInf (coe '' t : Set α) ∈ s then ⟨sInf (coe '' t : Set α), ht⟩ else default :=
   rfl
-#align subset_Inf_def subset_infₛ_def
+#align subset_Inf_def subset_sInf_def
 -/
 
-#print subset_infₛ_of_within /-
-theorem subset_infₛ_of_within [Inhabited s] {t : Set s} (h : infₛ (coe '' t : Set α) ∈ s) :
-    infₛ (coe '' t : Set α) = (@infₛ s _ t : α) := by simp [dif_pos h]
-#align subset_Inf_of_within subset_infₛ_of_within
+#print subset_sInf_of_within /-
+theorem subset_sInf_of_within [Inhabited s] {t : Set s} (h : sInf (coe '' t : Set α) ∈ s) :
+    sInf (coe '' t : Set α) = (@sInf s _ t : α) := by simp [dif_pos h]
+#align subset_Inf_of_within subset_sInf_of_within
 -/
 
 end InfSet
@@ -108,9 +108,9 @@ attribute [local instance] subsetInfSet
 
 /- warning: subset_conditionally_complete_linear_order -> subsetConditionallyCompleteLinearOrder is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} (s : Set.{u1} α) [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : Inhabited.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)], (forall {t : Set.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)}, (Set.Nonempty.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) t) -> (BddAbove.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)) t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) t)) s)) -> (forall {t : Set.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)}, (Set.Nonempty.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) t) -> (BddBelow.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)) t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (InfSet.infₛ.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) t)) s)) -> (ConditionallyCompleteLinearOrder.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s))
+  forall {α : Type.{u1}} (s : Set.{u1} α) [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : Inhabited.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)], (forall {t : Set.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)}, (Set.Nonempty.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) t) -> (BddAbove.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)) t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) t)) s)) -> (forall {t : Set.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)}, (Set.Nonempty.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) t) -> (BddBelow.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)) t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) t)) s)) -> (ConditionallyCompleteLinearOrder.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s))
 but is expected to have type
-  forall {α : Type.{u1}} (s : Set.{u1} α) [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : Inhabited.{succ u1} (Set.Elem.{u1} α s)], (forall {t : Set.{u1} (Set.Elem.{u1} α s)}, (Set.Nonempty.{u1} (Set.Elem.{u1} α s) t) -> (BddAbove.{u1} (Set.Elem.{u1} α s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (Set.Elem.{u1} α s) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t)) s)) -> (forall {t : Set.{u1} (Set.Elem.{u1} α s)}, (Set.Nonempty.{u1} (Set.Elem.{u1} α s) t) -> (BddBelow.{u1} (Set.Elem.{u1} α s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (InfSet.infₛ.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (Set.Elem.{u1} α s) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t)) s)) -> (ConditionallyCompleteLinearOrder.{u1} (Set.Elem.{u1} α s))
+  forall {α : Type.{u1}} (s : Set.{u1} α) [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : Inhabited.{succ u1} (Set.Elem.{u1} α s)], (forall {t : Set.{u1} (Set.Elem.{u1} α s)}, (Set.Nonempty.{u1} (Set.Elem.{u1} α s) t) -> (BddAbove.{u1} (Set.Elem.{u1} α s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (Set.Elem.{u1} α s) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t)) s)) -> (forall {t : Set.{u1} (Set.Elem.{u1} α s)}, (Set.Nonempty.{u1} (Set.Elem.{u1} α s) t) -> (BddBelow.{u1} (Set.Elem.{u1} α s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (Set.Elem.{u1} α s) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t)) s)) -> (ConditionallyCompleteLinearOrder.{u1} (Set.Elem.{u1} α s))
 Case conversion may be inaccurate. Consider using '#align subset_conditionally_complete_linear_order subsetConditionallyCompleteLinearOrderₓ'. -/
 /-- For a nonempty subset of a conditionally complete linear order to be a conditionally complete
 linear order, it suffices that it contain the `Sup` of all its nonempty bounded-above subsets, and
@@ -118,8 +118,8 @@ the `Inf` of all its nonempty bounded-below subsets.
 See note [reducible non-instances]. -/
 @[reducible]
 noncomputable def subsetConditionallyCompleteLinearOrder [Inhabited s]
-    (h_Sup : ∀ {t : Set s} (ht : t.Nonempty) (h_bdd : BddAbove t), supₛ (coe '' t : Set α) ∈ s)
-    (h_Inf : ∀ {t : Set s} (ht : t.Nonempty) (h_bdd : BddBelow t), infₛ (coe '' t : Set α) ∈ s) :
+    (h_Sup : ∀ {t : Set s} (ht : t.Nonempty) (h_bdd : BddAbove t), sSup (coe '' t : Set α) ∈ s)
+    (h_Inf : ∀ {t : Set s} (ht : t.Nonempty) (h_bdd : BddBelow t), sInf (coe '' t : Set α) ∈ s) :
     ConditionallyCompleteLinearOrder s :=
   {-- The following would be a more natural way to finish, but gives a "deep recursion" error:
       -- simpa [subset_Sup_of_within (h_Sup t)] using
@@ -132,66 +132,66 @@ noncomputable def subsetConditionallyCompleteLinearOrder [Inhabited s]
         s) with
     le_cSup := by
       rintro t c h_bdd hct
-      have := (Subtype.mono_coe s).le_csupₛ_image hct h_bdd
-      rwa [subset_supₛ_of_within s (h_Sup ⟨c, hct⟩ h_bdd)] at this
+      have := (Subtype.mono_coe s).le_csSup_image hct h_bdd
+      rwa [subset_sSup_of_within s (h_Sup ⟨c, hct⟩ h_bdd)] at this
     cSup_le := by
       rintro t B ht hB
-      have := (Subtype.mono_coe s).csupₛ_image_le ht hB
-      rwa [subset_supₛ_of_within s (h_Sup ht ⟨B, hB⟩)] at this
+      have := (Subtype.mono_coe s).csSup_image_le ht hB
+      rwa [subset_sSup_of_within s (h_Sup ht ⟨B, hB⟩)] at this
     le_cInf := by
       intro t B ht hB
-      have := (Subtype.mono_coe s).le_cinfₛ_image ht hB
-      rwa [subset_infₛ_of_within s (h_Inf ht ⟨B, hB⟩)] at this
+      have := (Subtype.mono_coe s).le_csInf_image ht hB
+      rwa [subset_sInf_of_within s (h_Inf ht ⟨B, hB⟩)] at this
     cInf_le := by
       rintro t c h_bdd hct
-      have := (Subtype.mono_coe s).cinfₛ_image_le hct h_bdd
-      rwa [subset_infₛ_of_within s (h_Inf ⟨c, hct⟩ h_bdd)] at this }
+      have := (Subtype.mono_coe s).csInf_image_le hct h_bdd
+      rwa [subset_sInf_of_within s (h_Inf ⟨c, hct⟩ h_bdd)] at this }
 #align subset_conditionally_complete_linear_order subsetConditionallyCompleteLinearOrder
 
 section OrdConnected
 
-/- warning: Sup_within_of_ord_connected -> supₛ_within_of_ordConnected is a dubious translation:
+/- warning: Sup_within_of_ord_connected -> sSup_within_of_ordConnected is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} [hs : Set.OrdConnected.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) s] {{t : Set.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)}}, (Set.Nonempty.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) t) -> (BddAbove.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)) t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) t)) s)
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} [hs : Set.OrdConnected.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) s] {{t : Set.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)}}, (Set.Nonempty.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) t) -> (BddAbove.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)) t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) t)) s)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} [hs : Set.OrdConnected.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) s] {{t : Set.{u1} (Set.Elem.{u1} α s)}}, (Set.Nonempty.{u1} (Set.Elem.{u1} α s) t) -> (BddAbove.{u1} (Set.Elem.{u1} α s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (SupSet.supₛ.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (Set.Elem.{u1} α s) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t)) s)
-Case conversion may be inaccurate. Consider using '#align Sup_within_of_ord_connected supₛ_within_of_ordConnectedₓ'. -/
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} [hs : Set.OrdConnected.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) s] {{t : Set.{u1} (Set.Elem.{u1} α s)}}, (Set.Nonempty.{u1} (Set.Elem.{u1} α s) t) -> (BddAbove.{u1} (Set.Elem.{u1} α s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (SupSet.sSup.{u1} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (Set.Elem.{u1} α s) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t)) s)
+Case conversion may be inaccurate. Consider using '#align Sup_within_of_ord_connected sSup_within_of_ordConnectedₓ'. -/
 /-- The `Sup` function on a nonempty `ord_connected` set `s` in a conditionally complete linear
 order takes values within `s`, for all nonempty bounded-above subsets of `s`. -/
-theorem supₛ_within_of_ordConnected {s : Set α} [hs : OrdConnected s] ⦃t : Set s⦄ (ht : t.Nonempty)
-    (h_bdd : BddAbove t) : supₛ (coe '' t : Set α) ∈ s :=
+theorem sSup_within_of_ordConnected {s : Set α} [hs : OrdConnected s] ⦃t : Set s⦄ (ht : t.Nonempty)
+    (h_bdd : BddAbove t) : sSup (coe '' t : Set α) ∈ s :=
   by
   obtain ⟨c, hct⟩ : ∃ c, c ∈ t := ht
   obtain ⟨B, hB⟩ : ∃ B, B ∈ upperBounds t := h_bdd
   refine' hs.out c.2 B.2 ⟨_, _⟩
-  · exact (Subtype.mono_coe s).le_csupₛ_image hct ⟨B, hB⟩
-  · exact (Subtype.mono_coe s).csupₛ_image_le ⟨c, hct⟩ hB
-#align Sup_within_of_ord_connected supₛ_within_of_ordConnected
+  · exact (Subtype.mono_coe s).le_csSup_image hct ⟨B, hB⟩
+  · exact (Subtype.mono_coe s).csSup_image_le ⟨c, hct⟩ hB
+#align Sup_within_of_ord_connected sSup_within_of_ordConnected
 
-/- warning: Inf_within_of_ord_connected -> infₛ_within_of_ordConnected is a dubious translation:
+/- warning: Inf_within_of_ord_connected -> sInf_within_of_ordConnected is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} [hs : Set.OrdConnected.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) s] {{t : Set.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)}}, (Set.Nonempty.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) t) -> (BddBelow.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)) t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (InfSet.infₛ.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) t)) s)
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} [hs : Set.OrdConnected.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) s] {{t : Set.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)}}, (Set.Nonempty.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) t) -> (BddBelow.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)) t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) t)) s)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} [hs : Set.OrdConnected.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) s] {{t : Set.{u1} (Set.Elem.{u1} α s)}}, (Set.Nonempty.{u1} (Set.Elem.{u1} α s) t) -> (BddBelow.{u1} (Set.Elem.{u1} α s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (InfSet.infₛ.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (Set.Elem.{u1} α s) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t)) s)
-Case conversion may be inaccurate. Consider using '#align Inf_within_of_ord_connected infₛ_within_of_ordConnectedₓ'. -/
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {s : Set.{u1} α} [hs : Set.OrdConnected.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) s] {{t : Set.{u1} (Set.Elem.{u1} α s)}}, (Set.Nonempty.{u1} (Set.Elem.{u1} α s) t) -> (BddBelow.{u1} (Set.Elem.{u1} α s) (Subtype.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (InfSet.sInf.{u1} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.image.{u1, u1} (Set.Elem.{u1} α s) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) t)) s)
+Case conversion may be inaccurate. Consider using '#align Inf_within_of_ord_connected sInf_within_of_ordConnectedₓ'. -/
 /-- The `Inf` function on a nonempty `ord_connected` set `s` in a conditionally complete linear
 order takes values within `s`, for all nonempty bounded-below subsets of `s`. -/
-theorem infₛ_within_of_ordConnected {s : Set α} [hs : OrdConnected s] ⦃t : Set s⦄ (ht : t.Nonempty)
-    (h_bdd : BddBelow t) : infₛ (coe '' t : Set α) ∈ s :=
+theorem sInf_within_of_ordConnected {s : Set α} [hs : OrdConnected s] ⦃t : Set s⦄ (ht : t.Nonempty)
+    (h_bdd : BddBelow t) : sInf (coe '' t : Set α) ∈ s :=
   by
   obtain ⟨c, hct⟩ : ∃ c, c ∈ t := ht
   obtain ⟨B, hB⟩ : ∃ B, B ∈ lowerBounds t := h_bdd
   refine' hs.out B.2 c.2 ⟨_, _⟩
-  · exact (Subtype.mono_coe s).le_cinfₛ_image ⟨c, hct⟩ hB
-  · exact (Subtype.mono_coe s).cinfₛ_image_le hct ⟨B, hB⟩
-#align Inf_within_of_ord_connected infₛ_within_of_ordConnected
+  · exact (Subtype.mono_coe s).le_csInf_image ⟨c, hct⟩ hB
+  · exact (Subtype.mono_coe s).csInf_image_le hct ⟨B, hB⟩
+#align Inf_within_of_ord_connected sInf_within_of_ordConnected
 
 #print ordConnectedSubsetConditionallyCompleteLinearOrder /-
 /-- A nonempty `ord_connected` set in a conditionally complete linear order is naturally a
 conditionally complete linear order. -/
 noncomputable instance ordConnectedSubsetConditionallyCompleteLinearOrder [Inhabited s]
     [OrdConnected s] : ConditionallyCompleteLinearOrder s :=
-  subsetConditionallyCompleteLinearOrder s supₛ_within_of_ordConnected infₛ_within_of_ordConnected
+  subsetConditionallyCompleteLinearOrder s sSup_within_of_ordConnected sInf_within_of_ordConnected
 #align ord_connected_subset_conditionally_complete_linear_order ordConnectedSubsetConditionallyCompleteLinearOrder
 -/
 

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

Move Set.Ixx, Finset.Ixx, Multiset.Ixx together under two different folders:

• Order.Interval for their definition and basic properties
• Algebra.Order.Interval for their algebraic properties

Move the definitions of Multiset.Ixx to what is now Order.Interval.Multiset. I believe we could just delete this file in a later PR as nothing uses it (and I already had doubts when defining Multiset.Ixx three years ago).

Move the algebraic results out of what is now Order.Interval.Finset.Basic to a new file Algebra.Order.Interval.Finset.Basic.

@@ -5,7 +5,7 @@ Authors: Heather Macbeth
 -/
 import Mathlib.Order.ConditionallyCompleteLattice.Basic
 import Mathlib.Order.LatticeIntervals
-import Mathlib.Data.Set.Intervals.OrdConnected
+import Mathlib.Order.Interval.Set.OrdConnected
 
 #align_import order.complete_lattice_intervals from "leanprover-community/mathlib"@"207cfac9fcd06138865b5d04f7091e46d9320432"
 

This is not exhaustive; it largely does not rename instances that relate to algebra, and only focuses on the "core" order files.

@@ -218,7 +218,7 @@ noncomputable def Set.Icc.completeLattice [ConditionallyCompleteLattice α]
 /-- Complete linear order structure on `Set.Icc` -/
 noncomputable def Set.Icc.completeLinearOrder [ConditionallyCompleteLinearOrder α]
     {a b : α} (h : a ≤ b) : CompleteLinearOrder (Set.Icc a b) :=
-  { Set.Icc.completeLattice h, Subtype.linearOrder _ with }
+  { Set.Icc.completeLattice h, Subtype.instLinearOrder _ with }
 
 lemma Set.Icc.coe_sSup [ConditionallyCompleteLattice α] {a b : α} (h : a ≤ b)
     {S : Set (Set.Icc a b)} (hS : S.Nonempty) : letI := Set.Icc.completeLattice h

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

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

@@ -23,7 +23,7 @@ default values for `sSup` and `sInf`.
 -/
 
 
-open Classical
+open scoped Classical
 
 open Set
 

This reworks the location of the lemmas from #10086, by moving them to a new Mathlib.Order.CompactlyGenerated.Intervals file. The existing Mathlib.Order.CompactlyGenerated is moved to Mathlib.Order.CompactlyGenerated.Basic for consistency.

@@ -3,7 +3,6 @@ Copyright (c) 2022 Heather Macbeth. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Heather Macbeth
 -/
-import Mathlib.Order.CompactlyGenerated
 import Mathlib.Order.ConditionallyCompleteLattice.Basic
 import Mathlib.Order.LatticeIntervals
 import Mathlib.Data.Set.Intervals.OrdConnected
@@ -276,50 +275,7 @@ theorem coe_biInf : (↑(⨅ i, ⨅ (_ : p i), f i) : α) = a ⊓ ⨅ i, ⨅ (_
   · simp
   · simp_rw [coe_iInf, ← inf_iInf, ← inf_assoc, inf_idem]
 
-theorem isCompactElement {b : Iic a} (h : CompleteLattice.IsCompactElement (b : α)) :
-    CompleteLattice.IsCompactElement b := by
-  simp only [CompleteLattice.isCompactElement_iff, Finset.sup_eq_iSup] at h ⊢
-  intro ι s hb
-  replace hb : (b : α) ≤ iSup ((↑) ∘ s) := le_trans hb <| (coe_iSup s) ▸ le_refl _
-  obtain ⟨t, ht⟩ := h ι ((↑) ∘ s) hb
-  exact ⟨t, (by simpa using ht : (b : α) ≤ _)⟩
-
-instance instIsCompactlyGenerated [IsCompactlyGenerated α] : IsCompactlyGenerated (Iic a) := by
-  refine ⟨fun ⟨x, (hx : x ≤ a)⟩ ↦ ?_⟩
-  obtain ⟨s, hs, rfl⟩ := IsCompactlyGenerated.exists_sSup_eq x
-  rw [sSup_le_iff] at hx
-  let f : s → Iic a := fun y ↦ ⟨y, hx _ y.property⟩
-  refine ⟨range f, ?_, ?_⟩
-  · rintro - ⟨⟨y, hy⟩, hy', rfl⟩
-    exact isCompactElement (hs _ hy)
-  · rw [Subtype.ext_iff]
-    change sSup (((↑) : Iic a → α) '' (range f)) = sSup s
-    congr
-    ext b
-    simpa using hx b
 
 end Set.Iic
 
-theorem complementedLattice_of_complementedLattice_Iic
-    [CompleteLattice α] [IsModularLattice α] [IsCompactlyGenerated α]
-    {ι : Type*} {s : Set ι} {f : ι → α}
-    (h : ∀ i ∈ s, ComplementedLattice <| Iic (f i))
-    (h' : ⨆ i ∈ s, f i = ⊤) :
-    ComplementedLattice α := by
-  apply complementedLattice_of_sSup_atoms_eq_top
-  have : ∀ i ∈ s, ∃ t : Set α, f i = sSup t ∧ ∀ a ∈ t, IsAtom a := fun i hi ↦ by
-    replace h := complementedLattice_iff_isAtomistic.mp (h i hi)
-    obtain ⟨u, hu, hu'⟩ := eq_sSup_atoms (⊤ : Iic (f i))
-    refine ⟨(↑) '' u, ?_, ?_⟩
-    · replace hu : f i = ↑(sSup u) := Subtype.ext_iff.mp hu
-      simp_rw [hu, Iic.coe_sSup]
-    · rintro b ⟨⟨a, ha'⟩, ha, rfl⟩
-      exact IsAtom.of_isAtom_coe_Iic (hu' _ ha)
-  choose t ht ht' using this
-  let u : Set α := ⋃ i, ⋃ hi : i ∈ s, t i hi
-  have hu₁ : u ⊆ {a | IsAtom a} := by
-    rintro a ⟨-, ⟨i, rfl⟩, ⟨-, ⟨hi, rfl⟩, ha : a ∈ t i hi⟩⟩
-    exact ht' i hi a ha
-  have hu₂ : sSup u = ⨆ i ∈ s, f i := by simp_rw [sSup_iUnion, biSup_congr' ht]
-  rw [eq_top_iff, ← h', ← hu₂]
-  exact sSup_le_sSup hu₁
+assert_not_exists Multiset

Another small step toward Jordan-Chevalley-Dunford.

@@ -3,6 +3,7 @@ Copyright (c) 2022 Heather Macbeth. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Heather Macbeth
 -/
+import Mathlib.Order.CompactlyGenerated
 import Mathlib.Order.ConditionallyCompleteLattice.Basic
 import Mathlib.Order.LatticeIntervals
 import Mathlib.Data.Set.Intervals.OrdConnected
@@ -27,7 +28,7 @@ open Classical
 
 open Set
 
-variable {α : Type*} (s : Set α)
+variable {ι : Sort*} {α : Type*} (s : Set α)
 
 section SupSet
 
@@ -231,13 +232,94 @@ lemma Set.Icc.coe_sInf [ConditionallyCompleteLattice α] {a b : α} (h : a ≤ b
   congrArg Subtype.val (dif_neg hS.ne_empty)
 
 lemma Set.Icc.coe_iSup [ConditionallyCompleteLattice α] {a b : α} (h : a ≤ b)
-    {ι : Sort*} [Nonempty ι] {S : ι → Set.Icc a b} : letI := Set.Icc.completeLattice h
+    [Nonempty ι] {S : ι → Set.Icc a b} : letI := Set.Icc.completeLattice h
     ↑(iSup S) = (⨆ i, S i : α) :=
   (Set.Icc.coe_sSup h (range_nonempty S)).trans (congrArg sSup (range_comp Subtype.val S).symm)
 
 lemma Set.Icc.coe_iInf [ConditionallyCompleteLattice α] {a b : α} (h : a ≤ b)
-    {ι : Sort*} [Nonempty ι] {S : ι → Set.Icc a b} : letI := Set.Icc.completeLattice h
+    [Nonempty ι] {S : ι → Set.Icc a b} : letI := Set.Icc.completeLattice h
     ↑(iInf S) = (⨅ i, S i : α) :=
   (Set.Icc.coe_sInf h (range_nonempty S)).trans (congrArg sInf (range_comp Subtype.val S).symm)
 
 end Icc
+
+namespace Set.Iic
+
+variable [CompleteLattice α] {a : α}
+
+instance instCompleteLattice : CompleteLattice (Iic a) where
+  sSup S := ⟨sSup ((↑) '' S), by simpa using fun b hb _ ↦ hb⟩
+  sInf S := ⟨a ⊓ sInf ((↑) '' S), by simp⟩
+  le_sSup S b hb := le_sSup <| mem_image_of_mem Subtype.val hb
+  sSup_le S b hb := sSup_le <| fun c' ⟨c, hc, hc'⟩ ↦ hc' ▸ hb c hc
+  sInf_le S b hb := inf_le_of_right_le <| sInf_le <| mem_image_of_mem Subtype.val hb
+  le_sInf S b hb := le_inf_iff.mpr ⟨b.property, le_sInf fun d' ⟨d, hd, hd'⟩  ↦ hd' ▸ hb d hd⟩
+  le_top := by simp
+  bot_le := by simp
+
+variable (S : Set <| Iic a) (f : ι → Iic a) (p : ι → Prop)
+
+@[simp] theorem coe_sSup : (↑(sSup S) : α) = sSup ((↑) '' S) := rfl
+
+@[simp] theorem coe_iSup : (↑(⨆ i, f i) : α) = ⨆ i, (f i : α) := by
+  rw [iSup, coe_sSup]; congr; ext; simp
+
+theorem coe_biSup : (↑(⨆ i, ⨆ (_ : p i), f i) : α) = ⨆ i, ⨆ (_ : p i), (f i : α) := by simp
+
+@[simp] theorem coe_sInf : (↑(sInf S) : α) = a ⊓ sInf ((↑) '' S) := rfl
+
+@[simp] theorem coe_iInf : (↑(⨅ i, f i) : α) = a ⊓ ⨅ i, (f i : α) := by
+  rw [iInf, coe_sInf]; congr; ext; simp
+
+theorem coe_biInf : (↑(⨅ i, ⨅ (_ : p i), f i) : α) = a ⊓ ⨅ i, ⨅ (_ : p i), (f i : α) := by
+  cases isEmpty_or_nonempty ι
+  · simp
+  · simp_rw [coe_iInf, ← inf_iInf, ← inf_assoc, inf_idem]
+
+theorem isCompactElement {b : Iic a} (h : CompleteLattice.IsCompactElement (b : α)) :
+    CompleteLattice.IsCompactElement b := by
+  simp only [CompleteLattice.isCompactElement_iff, Finset.sup_eq_iSup] at h ⊢
+  intro ι s hb
+  replace hb : (b : α) ≤ iSup ((↑) ∘ s) := le_trans hb <| (coe_iSup s) ▸ le_refl _
+  obtain ⟨t, ht⟩ := h ι ((↑) ∘ s) hb
+  exact ⟨t, (by simpa using ht : (b : α) ≤ _)⟩
+
+instance instIsCompactlyGenerated [IsCompactlyGenerated α] : IsCompactlyGenerated (Iic a) := by
+  refine ⟨fun ⟨x, (hx : x ≤ a)⟩ ↦ ?_⟩
+  obtain ⟨s, hs, rfl⟩ := IsCompactlyGenerated.exists_sSup_eq x
+  rw [sSup_le_iff] at hx
+  let f : s → Iic a := fun y ↦ ⟨y, hx _ y.property⟩
+  refine ⟨range f, ?_, ?_⟩
+  · rintro - ⟨⟨y, hy⟩, hy', rfl⟩
+    exact isCompactElement (hs _ hy)
+  · rw [Subtype.ext_iff]
+    change sSup (((↑) : Iic a → α) '' (range f)) = sSup s
+    congr
+    ext b
+    simpa using hx b
+
+end Set.Iic
+
+theorem complementedLattice_of_complementedLattice_Iic
+    [CompleteLattice α] [IsModularLattice α] [IsCompactlyGenerated α]
+    {ι : Type*} {s : Set ι} {f : ι → α}
+    (h : ∀ i ∈ s, ComplementedLattice <| Iic (f i))
+    (h' : ⨆ i ∈ s, f i = ⊤) :
+    ComplementedLattice α := by
+  apply complementedLattice_of_sSup_atoms_eq_top
+  have : ∀ i ∈ s, ∃ t : Set α, f i = sSup t ∧ ∀ a ∈ t, IsAtom a := fun i hi ↦ by
+    replace h := complementedLattice_iff_isAtomistic.mp (h i hi)
+    obtain ⟨u, hu, hu'⟩ := eq_sSup_atoms (⊤ : Iic (f i))
+    refine ⟨(↑) '' u, ?_, ?_⟩
+    · replace hu : f i = ↑(sSup u) := Subtype.ext_iff.mp hu
+      simp_rw [hu, Iic.coe_sSup]
+    · rintro b ⟨⟨a, ha'⟩, ha, rfl⟩
+      exact IsAtom.of_isAtom_coe_Iic (hu' _ ha)
+  choose t ht ht' using this
+  let u : Set α := ⋃ i, ⋃ hi : i ∈ s, t i hi
+  have hu₁ : u ⊆ {a | IsAtom a} := by
+    rintro a ⟨-, ⟨i, rfl⟩, ⟨-, ⟨hi, rfl⟩, ha : a ∈ t i hi⟩⟩
+    exact ht' i hi a ha
+  have hu₂ : sSup u = ⨆ i ∈ s, f i := by simp_rw [sSup_iUnion, biSup_congr' ht]
+  rw [eq_top_iff, ← h', ← hu₂]
+  exact sSup_le_sSup hu₁

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

@@ -187,7 +187,7 @@ noncomputable def Set.Icc.completeLattice [ConditionallyCompleteLattice α]
     {a b : α} (h : a ≤ b) : CompleteLattice (Set.Icc a b) where
   __ := Set.Icc.boundedOrder h
   sSup S := if hS : S = ∅ then ⟨a, le_rfl, h⟩ else ⟨sSup ((↑) '' S), by
-    rw [←Set.not_nonempty_iff_eq_empty, not_not] at hS
+    rw [← Set.not_nonempty_iff_eq_empty, not_not] at hS
     refine' ⟨_, csSup_le (hS.image (↑)) (fun _ ⟨c, _, hc⟩ ↦ hc ▸ c.2.2)⟩
     obtain ⟨c, hc⟩ := hS
     exact c.2.1.trans (le_csSup ⟨b, fun _ ⟨d, _, hd⟩ ↦ hd ▸ d.2.2⟩ ⟨c, hc, rfl⟩)⟩
@@ -201,7 +201,7 @@ noncomputable def Set.Icc.completeLattice [ConditionallyCompleteLattice α]
     · exact csSup_le ((Set.nonempty_iff_ne_empty.mpr hS).image (↑))
         (fun _ ⟨d, h, hd⟩ ↦ hd ▸ hc d h)
   sInf S := if hS : S = ∅ then ⟨b, h, le_rfl⟩ else ⟨sInf ((↑) '' S), by
-    rw [←Set.not_nonempty_iff_eq_empty, not_not] at hS
+    rw [← Set.not_nonempty_iff_eq_empty, not_not] at hS
     refine' ⟨le_csInf (hS.image (↑)) (fun _ ⟨c, _, hc⟩ ↦ hc ▸ c.2.1), _⟩
     obtain ⟨c, hc⟩ := hS
     exact le_trans (csInf_le ⟨a, fun _ ⟨d, _, hd⟩ ↦ hd ▸ d.2.1⟩ ⟨c, hc, rfl⟩) c.2.2⟩

This PR adds a complete lattice instance on Set.Icc.

Co-authored-by: Thomas Browning <tb65536@users.noreply.github.com>

@@ -4,6 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Heather Macbeth
 -/
 import Mathlib.Order.ConditionallyCompleteLattice.Basic
+import Mathlib.Order.LatticeIntervals
 import Mathlib.Data.Set.Intervals.OrdConnected
 
 #align_import order.complete_lattice_intervals from "leanprover-community/mathlib"@"207cfac9fcd06138865b5d04f7091e46d9320432"
@@ -108,6 +109,8 @@ theorem subset_sInf_of_not_bddBelow [Inhabited s] {t : Set s} (ht : ¬BddBelow t
 
 end InfSet
 
+section OrdConnected
+
 variable [ConditionallyCompleteLinearOrder α]
 
 attribute [local instance] subsetSupSet
@@ -144,8 +147,6 @@ noncomputable def subsetConditionallyCompleteLinearOrder [Inhabited s]
     csInf_of_not_bddBelow := fun t ht ↦ by simp [ht] }
 #align subset_conditionally_complete_linear_order subsetConditionallyCompleteLinearOrder
 
-section OrdConnected
-
 /-- The `sSup` function on a nonempty `OrdConnected` set `s` in a conditionally complete linear
 order takes values within `s`, for all nonempty bounded-above subsets of `s`. -/
 theorem sSup_within_of_ordConnected {s : Set α} [hs : OrdConnected s] ⦃t : Set s⦄ (ht : t.Nonempty)
@@ -178,3 +179,65 @@ noncomputable instance ordConnectedSubsetConditionallyCompleteLinearOrder [Inhab
 #align ord_connected_subset_conditionally_complete_linear_order ordConnectedSubsetConditionallyCompleteLinearOrder
 
 end OrdConnected
+
+section Icc
+
+/-- Complete lattice structure on `Set.Icc` -/
+noncomputable def Set.Icc.completeLattice [ConditionallyCompleteLattice α]
+    {a b : α} (h : a ≤ b) : CompleteLattice (Set.Icc a b) where
+  __ := Set.Icc.boundedOrder h
+  sSup S := if hS : S = ∅ then ⟨a, le_rfl, h⟩ else ⟨sSup ((↑) '' S), by
+    rw [←Set.not_nonempty_iff_eq_empty, not_not] at hS
+    refine' ⟨_, csSup_le (hS.image (↑)) (fun _ ⟨c, _, hc⟩ ↦ hc ▸ c.2.2)⟩
+    obtain ⟨c, hc⟩ := hS
+    exact c.2.1.trans (le_csSup ⟨b, fun _ ⟨d, _, hd⟩ ↦ hd ▸ d.2.2⟩ ⟨c, hc, rfl⟩)⟩
+  le_sSup S c hc := by
+    by_cases hS : S = ∅ <;> simp only [hS, dite_true, dite_false]
+    · simp [hS] at hc
+    · exact le_csSup ⟨b, fun _ ⟨d, _, hd⟩ ↦ hd ▸ d.2.2⟩ ⟨c, hc, rfl⟩
+  sSup_le S c hc := by
+    by_cases hS : S = ∅ <;> simp only [hS, dite_true, dite_false]
+    · exact c.2.1
+    · exact csSup_le ((Set.nonempty_iff_ne_empty.mpr hS).image (↑))
+        (fun _ ⟨d, h, hd⟩ ↦ hd ▸ hc d h)
+  sInf S := if hS : S = ∅ then ⟨b, h, le_rfl⟩ else ⟨sInf ((↑) '' S), by
+    rw [←Set.not_nonempty_iff_eq_empty, not_not] at hS
+    refine' ⟨le_csInf (hS.image (↑)) (fun _ ⟨c, _, hc⟩ ↦ hc ▸ c.2.1), _⟩
+    obtain ⟨c, hc⟩ := hS
+    exact le_trans (csInf_le ⟨a, fun _ ⟨d, _, hd⟩ ↦ hd ▸ d.2.1⟩ ⟨c, hc, rfl⟩) c.2.2⟩
+  sInf_le S c hc := by
+    by_cases hS : S = ∅ <;> simp only [hS, dite_true, dite_false]
+    · simp [hS] at hc
+    · exact csInf_le ⟨a, fun _ ⟨d, _, hd⟩ ↦ hd ▸ d.2.1⟩ ⟨c, hc, rfl⟩
+  le_sInf S c hc := by
+    by_cases hS : S = ∅ <;> simp only [hS, dite_true, dite_false]
+    · exact c.2.2
+    · exact le_csInf ((Set.nonempty_iff_ne_empty.mpr hS).image (↑))
+        (fun _ ⟨d, h, hd⟩ ↦ hd ▸ hc d h)
+
+/-- Complete linear order structure on `Set.Icc` -/
+noncomputable def Set.Icc.completeLinearOrder [ConditionallyCompleteLinearOrder α]
+    {a b : α} (h : a ≤ b) : CompleteLinearOrder (Set.Icc a b) :=
+  { Set.Icc.completeLattice h, Subtype.linearOrder _ with }
+
+lemma Set.Icc.coe_sSup [ConditionallyCompleteLattice α] {a b : α} (h : a ≤ b)
+    {S : Set (Set.Icc a b)} (hS : S.Nonempty) : letI := Set.Icc.completeLattice h
+    ↑(sSup S) = sSup ((↑) '' S : Set α) :=
+  congrArg Subtype.val (dif_neg hS.ne_empty)
+
+lemma Set.Icc.coe_sInf [ConditionallyCompleteLattice α] {a b : α} (h : a ≤ b)
+    {S : Set (Set.Icc a b)} (hS : S.Nonempty) : letI := Set.Icc.completeLattice h
+    ↑(sInf S) = sInf ((↑) '' S : Set α) :=
+  congrArg Subtype.val (dif_neg hS.ne_empty)
+
+lemma Set.Icc.coe_iSup [ConditionallyCompleteLattice α] {a b : α} (h : a ≤ b)
+    {ι : Sort*} [Nonempty ι] {S : ι → Set.Icc a b} : letI := Set.Icc.completeLattice h
+    ↑(iSup S) = (⨆ i, S i : α) :=
+  (Set.Icc.coe_sSup h (range_nonempty S)).trans (congrArg sSup (range_comp Subtype.val S).symm)
+
+lemma Set.Icc.coe_iInf [ConditionallyCompleteLattice α] {a b : α} (h : a ≤ b)
+    {ι : Sort*} [Nonempty ι] {S : ι → Set.Icc a b} : letI := Set.Icc.completeLattice h
+    ↑(iInf S) = (⨅ i, S i : α) :=
+  (Set.Icc.coe_sInf h (range_nonempty S)).trans (congrArg sInf (range_comp Subtype.val S).symm)
+
+end Icc

We switch from sSup univ to sSup ∅ for the supremum of unbounded sets in a conditionally complete linear order. These quantities already coincide for all concrete instances in mathlib. With the new convention one gets additionally the theorem

theorem cbiSup_eq_of_not_forall {p : ι → Prop} {f : Subtype p → α} (hp : ¬ (∀ i, p i)) :
    ⨆ (i) (h : p i), f ⟨i, h⟩ = iSup f ⊔ sSup ∅

which will be convenient for general measurability statements.

@@ -30,15 +30,15 @@ variable {α : Type*} (s : Set α)
 
 section SupSet
 
-variable [SupSet α]
+variable [Preorder α] [SupSet α]
 
-/-- `SupSet` structure on a nonempty subset `s` of an object with `SupSet`. This definition is
+/-- `SupSet` structure on a nonempty subset `s` of a preorder with `SupSet`. This definition is
 non-canonical (it uses `default s`); it should be used only as here, as an auxiliary instance in the
 construction of the `ConditionallyCompleteLinearOrder` structure. -/
 noncomputable def subsetSupSet [Inhabited s] : SupSet s where
   sSup t :=
-    if ht : sSup ((↑) '' t : Set α) ∈ s
-    then ⟨sSup ((↑) '' t : Set α), ht⟩
+    if ht : t.Nonempty ∧ BddAbove t ∧ sSup ((↑) '' t : Set α) ∈ s
+    then ⟨sSup ((↑) '' t : Set α), ht.2.2⟩
     else default
 #align subset_has_Sup subsetSupSet
 
@@ -47,29 +47,38 @@ attribute [local instance] subsetSupSet
 @[simp]
 theorem subset_sSup_def [Inhabited s] :
     @sSup s _ = fun t =>
-      if ht : sSup ((↑) '' t : Set α) ∈ s
-      then ⟨sSup ((↑) '' t : Set α), ht⟩
+      if ht : t.Nonempty ∧ BddAbove t ∧ sSup ((↑) '' t : Set α) ∈ s
+      then ⟨sSup ((↑) '' t : Set α), ht.2.2⟩
       else default :=
   rfl
 #align subset_Sup_def subset_sSup_def
 
-theorem subset_sSup_of_within [Inhabited s] {t : Set s} (h : sSup ((↑) '' t : Set α) ∈ s) :
-    sSup ((↑) '' t : Set α) = (@sSup s _ t : α) := by simp [dif_pos h]
+theorem subset_sSup_of_within [Inhabited s] {t : Set s}
+    (h' : t.Nonempty) (h'' : BddAbove t)  (h : sSup ((↑) '' t : Set α) ∈ s) :
+    sSup ((↑) '' t : Set α) = (@sSup s _ t : α) := by simp [dif_pos, h, h', h'']
 #align subset_Sup_of_within subset_sSup_of_within
 
+theorem subset_sSup_emptyset [Inhabited s] :
+    sSup (∅ : Set s) = default := by
+  simp [sSup]
+
+theorem subset_sSup_of_not_bddAbove [Inhabited s] {t : Set s} (ht : ¬BddAbove t) :
+    sSup t = default := by
+  simp [sSup, ht]
+
 end SupSet
 
 section InfSet
 
-variable [InfSet α]
+variable [Preorder α] [InfSet α]
 
-/-- `InfSet` structure on a nonempty subset `s` of an object with `InfSet`. This definition is
+/-- `InfSet` structure on a nonempty subset `s` of a preorder with `InfSet`. This definition is
 non-canonical (it uses `default s`); it should be used only as here, as an auxiliary instance in the
 construction of the `ConditionallyCompleteLinearOrder` structure. -/
 noncomputable def subsetInfSet [Inhabited s] : InfSet s where
   sInf t :=
-    if ht : sInf ((↑) '' t : Set α) ∈ s
-    then ⟨sInf ((↑) '' t : Set α), ht⟩
+    if ht : t.Nonempty ∧ BddBelow t ∧ sInf ((↑) '' t : Set α) ∈ s
+    then ⟨sInf ((↑) '' t : Set α), ht.2.2⟩
     else default
 #align subset_has_Inf subsetInfSet
 
@@ -78,16 +87,25 @@ attribute [local instance] subsetInfSet
 @[simp]
 theorem subset_sInf_def [Inhabited s] :
     @sInf s _ = fun t =>
-      if ht : sInf ((↑) '' t : Set α) ∈ s
-      then ⟨sInf ((↑) '' t : Set α), ht⟩ else
+      if ht : t.Nonempty ∧ BddBelow t ∧ sInf ((↑) '' t : Set α) ∈ s
+      then ⟨sInf ((↑) '' t : Set α), ht.2.2⟩ else
       default :=
   rfl
 #align subset_Inf_def subset_sInf_def
 
-theorem subset_sInf_of_within [Inhabited s] {t : Set s} (h : sInf ((↑) '' t : Set α) ∈ s) :
-    sInf ((↑) '' t : Set α) = (@sInf s _ t : α) := by simp [dif_pos h]
+theorem subset_sInf_of_within [Inhabited s] {t : Set s}
+    (h' : t.Nonempty) (h'' : BddBelow t) (h : sInf ((↑) '' t : Set α) ∈ s) :
+    sInf ((↑) '' t : Set α) = (@sInf s _ t : α) := by simp [dif_pos, h, h', h'']
 #align subset_Inf_of_within subset_sInf_of_within
 
+theorem subset_sInf_emptyset [Inhabited s] :
+    sInf (∅ : Set s) = default := by
+  simp [sInf]
+
+theorem subset_sInf_of_not_bddBelow [Inhabited s] {t : Set s} (ht : ¬BddBelow t) :
+    sInf t = default := by
+  simp [sInf, ht]
+
 end InfSet
 
 variable [ConditionallyCompleteLinearOrder α]
@@ -96,40 +114,6 @@ attribute [local instance] subsetSupSet
 
 attribute [local instance] subsetInfSet
 
-lemma sSup_subtype_eq_sSup_univ_of_not_bddAbove {s : Set α} [Inhabited s]
-    (t : Set s) (ht : ¬BddAbove t) : sSup t = sSup univ := by
-  have A : ∀ (u : Set s), ¬BddAbove u → BddAbove (Subtype.val '' u) →
-      sSup ((↑) '' u : Set α) ∉ s := by
-    intro u hu Hu
-    contrapose! hu
-    refine ⟨⟨_, hu⟩, ?_⟩
-    rintro ⟨x, xs⟩ hx
-    simp only [Subtype.mk_le_mk]
-    apply le_csSup Hu
-    exact ⟨⟨x, xs⟩, hx, rfl⟩
-  by_cases Ht : BddAbove ((↑) '' t : Set α)
-  · have I1 : sSup ((↑) '' t : Set α) ∉ s := A t ht Ht
-    have I2 : sSup ((↑) '' (univ : Set s) : Set α) ∉ s := by
-      apply A
-      · contrapose! ht; exact ht.mono (subset_univ _)
-      · refine ⟨sSup ((↑) '' t : Set α), ?_⟩
-        rintro - ⟨⟨x, hx⟩, -, rfl⟩
-        simp [BddAbove, not_nonempty_iff_eq_empty] at ht
-        have : ⟨x, hx⟩ ∉ upperBounds t := by simp [ht]
-        obtain ⟨⟨y, ys⟩, yt, hy⟩ : ∃ y, y ∈ t ∧ { val := x, property := hx } < y :=
-          by simpa only [Subtype.mk_le_mk, not_forall, not_le, exists_prop, exists_and_right,
-            mem_upperBounds]
-        refine le_trans (le_of_lt hy) ?_
-        exact le_csSup Ht ⟨⟨y, ys⟩, yt, rfl⟩
-    simp only [sSup, I1, I2, dite_false]
-  · have I : ¬BddAbove ((↑) '' (univ : Set s) : Set α) := by
-      contrapose! Ht; exact Ht.mono (image_subset Subtype.val (subset_univ _))
-    have X : sSup ((↑) '' t : Set α) = sSup (univ : Set α) :=
-      ConditionallyCompleteLinearOrder.csSup_of_not_bddAbove _ Ht
-    have Y : sSup ((↑) '' (univ : Set s) : Set α) = sSup (univ : Set α) :=
-      ConditionallyCompleteLinearOrder.csSup_of_not_bddAbove _ I
-    simp only [sSup, X, Y]
-
 /-- For a nonempty subset of a conditionally complete linear order to be a conditionally complete
 linear order, it suffices that it contain the `sSup` of all its nonempty bounded-above subsets, and
 the `sInf` of all its nonempty bounded-below subsets.
@@ -139,28 +123,25 @@ noncomputable def subsetConditionallyCompleteLinearOrder [Inhabited s]
     (h_Sup : ∀ {t : Set s} (_ : t.Nonempty) (_h_bdd : BddAbove t), sSup ((↑) '' t : Set α) ∈ s)
     (h_Inf : ∀ {t : Set s} (_ : t.Nonempty) (_h_bdd : BddBelow t), sInf ((↑) '' t : Set α) ∈ s) :
     ConditionallyCompleteLinearOrder s :=
-  { -- The following would be a more natural way to finish, but gives a "deep recursion" error:
-      -- simpa [subset_Sup_of_within (h_Sup t)] using
-      --   (strict_mono_coe s).monotone.le_cSup_image hct h_bdd,
-    subsetSupSet s, subsetInfSet s, DistribLattice.toLattice, (inferInstance : LinearOrder s) with
+  { subsetSupSet s, subsetInfSet s, DistribLattice.toLattice, (inferInstance : LinearOrder s) with
     le_csSup := by
       rintro t c h_bdd hct
-      rw [← Subtype.coe_le_coe, ← subset_sSup_of_within s (h_Sup ⟨c, hct⟩ h_bdd)]
+      rw [← Subtype.coe_le_coe, ← subset_sSup_of_within s ⟨c, hct⟩ h_bdd (h_Sup ⟨c, hct⟩ h_bdd)]
       exact (Subtype.mono_coe _).le_csSup_image hct h_bdd
     csSup_le := by
       rintro t B ht hB
-      rw [← Subtype.coe_le_coe, ← subset_sSup_of_within s (h_Sup ht ⟨B, hB⟩)]
+      rw [← Subtype.coe_le_coe, ← subset_sSup_of_within s ht ⟨B, hB⟩ (h_Sup ht ⟨B, hB⟩)]
       exact (Subtype.mono_coe s).csSup_image_le ht hB
     le_csInf := by
       intro t B ht hB
-      rw [← Subtype.coe_le_coe, ← subset_sInf_of_within s (h_Inf ht ⟨B, hB⟩)]
+      rw [← Subtype.coe_le_coe, ← subset_sInf_of_within s ht ⟨B, hB⟩ (h_Inf ht ⟨B, hB⟩)]
       exact (Subtype.mono_coe s).le_csInf_image ht hB
     csInf_le := by
       rintro t c h_bdd hct
-      rw [← Subtype.coe_le_coe, ← subset_sInf_of_within s (h_Inf ⟨c, hct⟩ h_bdd)]
+      rw [← Subtype.coe_le_coe, ← subset_sInf_of_within s ⟨c, hct⟩ h_bdd (h_Inf ⟨c, hct⟩ h_bdd)]
       exact (Subtype.mono_coe s).csInf_image_le hct h_bdd
-    csSup_of_not_bddAbove := sSup_subtype_eq_sSup_univ_of_not_bddAbove
-    csInf_of_not_bddBelow := @sSup_subtype_eq_sSup_univ_of_not_bddAbove αᵒᵈ _ _ _ }
+    csSup_of_not_bddAbove := fun t ht ↦ by simp [ht]
+    csInf_of_not_bddBelow := fun t ht ↦ by simp [ht] }
 #align subset_conditionally_complete_linear_order subsetConditionallyCompleteLinearOrder
 
 section OrdConnected

Currently, in a conditionally complete linear order, the supremum of an unbounded set hasn't any specific property. However, in all instances in mathlib, all unbounded sets have the same supremum. This PR adds this requirement in mathlib. This will be convenient to remove boundedness assumptions in measurability statements.

@@ -96,6 +96,40 @@ attribute [local instance] subsetSupSet
 
 attribute [local instance] subsetInfSet
 
+lemma sSup_subtype_eq_sSup_univ_of_not_bddAbove {s : Set α} [Inhabited s]
+    (t : Set s) (ht : ¬BddAbove t) : sSup t = sSup univ := by
+  have A : ∀ (u : Set s), ¬BddAbove u → BddAbove (Subtype.val '' u) →
+      sSup ((↑) '' u : Set α) ∉ s := by
+    intro u hu Hu
+    contrapose! hu
+    refine ⟨⟨_, hu⟩, ?_⟩
+    rintro ⟨x, xs⟩ hx
+    simp only [Subtype.mk_le_mk]
+    apply le_csSup Hu
+    exact ⟨⟨x, xs⟩, hx, rfl⟩
+  by_cases Ht : BddAbove ((↑) '' t : Set α)
+  · have I1 : sSup ((↑) '' t : Set α) ∉ s := A t ht Ht
+    have I2 : sSup ((↑) '' (univ : Set s) : Set α) ∉ s := by
+      apply A
+      · contrapose! ht; exact ht.mono (subset_univ _)
+      · refine ⟨sSup ((↑) '' t : Set α), ?_⟩
+        rintro - ⟨⟨x, hx⟩, -, rfl⟩
+        simp [BddAbove, not_nonempty_iff_eq_empty] at ht
+        have : ⟨x, hx⟩ ∉ upperBounds t := by simp [ht]
+        obtain ⟨⟨y, ys⟩, yt, hy⟩ : ∃ y, y ∈ t ∧ { val := x, property := hx } < y :=
+          by simpa only [Subtype.mk_le_mk, not_forall, not_le, exists_prop, exists_and_right,
+            mem_upperBounds]
+        refine le_trans (le_of_lt hy) ?_
+        exact le_csSup Ht ⟨⟨y, ys⟩, yt, rfl⟩
+    simp only [sSup, I1, I2, dite_false]
+  · have I : ¬BddAbove ((↑) '' (univ : Set s) : Set α) := by
+      contrapose! Ht; exact Ht.mono (image_subset Subtype.val (subset_univ _))
+    have X : sSup ((↑) '' t : Set α) = sSup (univ : Set α) :=
+      ConditionallyCompleteLinearOrder.csSup_of_not_bddAbove _ Ht
+    have Y : sSup ((↑) '' (univ : Set s) : Set α) = sSup (univ : Set α) :=
+      ConditionallyCompleteLinearOrder.csSup_of_not_bddAbove _ I
+    simp only [sSup, X, Y]
+
 /-- For a nonempty subset of a conditionally complete linear order to be a conditionally complete
 linear order, it suffices that it contain the `sSup` of all its nonempty bounded-above subsets, and
 the `sInf` of all its nonempty bounded-below subsets.
@@ -124,7 +158,9 @@ noncomputable def subsetConditionallyCompleteLinearOrder [Inhabited s]
     csInf_le := by
       rintro t c h_bdd hct
       rw [← Subtype.coe_le_coe, ← subset_sInf_of_within s (h_Inf ⟨c, hct⟩ h_bdd)]
-      exact (Subtype.mono_coe s).csInf_image_le hct h_bdd }
+      exact (Subtype.mono_coe s).csInf_image_le hct h_bdd
+    csSup_of_not_bddAbove := sSup_subtype_eq_sSup_univ_of_not_bddAbove
+    csInf_of_not_bddBelow := @sSup_subtype_eq_sSup_univ_of_not_bddAbove αᵒᵈ _ _ _ }
 #align subset_conditionally_complete_linear_order subsetConditionallyCompleteLinearOrder
 
 section OrdConnected

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

This has nice performance benefits.

@@ -26,7 +26,7 @@ open Classical
 
 open Set
 
-variable {α : Type _} (s : Set α)
+variable {α : Type*} (s : Set α)
 
 section SupSet
 

• depends on: #5966

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

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Heather Macbeth. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Heather Macbeth
-
-! This file was ported from Lean 3 source module order.complete_lattice_intervals
-! leanprover-community/mathlib commit 207cfac9fcd06138865b5d04f7091e46d9320432
-! 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.Intervals.OrdConnected
 
+#align_import order.complete_lattice_intervals from "leanprover-community/mathlib"@"207cfac9fcd06138865b5d04f7091e46d9320432"
+
 /-! # Subtypes of conditionally complete linear orders
 
 In this file we give conditions on a subset of a conditionally complete linear order, to ensure that

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>

@@ -21,7 +21,7 @@ We check that an `OrdConnected` set satisfies these conditions.
 ## TODO
 
 Add appropriate instances for all `Set.Ixx`. This requires a refactor that will allow different
-default values for `supₛ` and `infₛ`.
+default values for `sSup` and `sInf`.
 -/
 
 
@@ -39,26 +39,26 @@ variable [SupSet α]
 non-canonical (it uses `default s`); it should be used only as here, as an auxiliary instance in the
 construction of the `ConditionallyCompleteLinearOrder` structure. -/
 noncomputable def subsetSupSet [Inhabited s] : SupSet s where
-  supₛ t :=
-    if ht : supₛ ((↑) '' t : Set α) ∈ s
-    then ⟨supₛ ((↑) '' t : Set α), ht⟩
+  sSup t :=
+    if ht : sSup ((↑) '' t : Set α) ∈ s
+    then ⟨sSup ((↑) '' t : Set α), ht⟩
     else default
 #align subset_has_Sup subsetSupSet
 
 attribute [local instance] subsetSupSet
 
 @[simp]
-theorem subset_supₛ_def [Inhabited s] :
-    @supₛ s _ = fun t =>
-      if ht : supₛ ((↑) '' t : Set α) ∈ s
-      then ⟨supₛ ((↑) '' t : Set α), ht⟩
+theorem subset_sSup_def [Inhabited s] :
+    @sSup s _ = fun t =>
+      if ht : sSup ((↑) '' t : Set α) ∈ s
+      then ⟨sSup ((↑) '' t : Set α), ht⟩
       else default :=
   rfl
-#align subset_Sup_def subset_supₛ_def
+#align subset_Sup_def subset_sSup_def
 
-theorem subset_supₛ_of_within [Inhabited s] {t : Set s} (h : supₛ ((↑) '' t : Set α) ∈ s) :
-    supₛ ((↑) '' t : Set α) = (@supₛ s _ t : α) := by simp [dif_pos h]
-#align subset_Sup_of_within subset_supₛ_of_within
+theorem subset_sSup_of_within [Inhabited s] {t : Set s} (h : sSup ((↑) '' t : Set α) ∈ s) :
+    sSup ((↑) '' t : Set α) = (@sSup s _ t : α) := by simp [dif_pos h]
+#align subset_Sup_of_within subset_sSup_of_within
 
 end SupSet
 
@@ -70,26 +70,26 @@ variable [InfSet α]
 non-canonical (it uses `default s`); it should be used only as here, as an auxiliary instance in the
 construction of the `ConditionallyCompleteLinearOrder` structure. -/
 noncomputable def subsetInfSet [Inhabited s] : InfSet s where
-  infₛ t :=
-    if ht : infₛ ((↑) '' t : Set α) ∈ s
-    then ⟨infₛ ((↑) '' t : Set α), ht⟩
+  sInf t :=
+    if ht : sInf ((↑) '' t : Set α) ∈ s
+    then ⟨sInf ((↑) '' t : Set α), ht⟩
     else default
 #align subset_has_Inf subsetInfSet
 
 attribute [local instance] subsetInfSet
 
 @[simp]
-theorem subset_infₛ_def [Inhabited s] :
-    @infₛ s _ = fun t =>
-      if ht : infₛ ((↑) '' t : Set α) ∈ s
-      then ⟨infₛ ((↑) '' t : Set α), ht⟩ else
+theorem subset_sInf_def [Inhabited s] :
+    @sInf s _ = fun t =>
+      if ht : sInf ((↑) '' t : Set α) ∈ s
+      then ⟨sInf ((↑) '' t : Set α), ht⟩ else
       default :=
   rfl
-#align subset_Inf_def subset_infₛ_def
+#align subset_Inf_def subset_sInf_def
 
-theorem subset_infₛ_of_within [Inhabited s] {t : Set s} (h : infₛ ((↑) '' t : Set α) ∈ s) :
-    infₛ ((↑) '' t : Set α) = (@infₛ s _ t : α) := by simp [dif_pos h]
-#align subset_Inf_of_within subset_infₛ_of_within
+theorem subset_sInf_of_within [Inhabited s] {t : Set s} (h : sInf ((↑) '' t : Set α) ∈ s) :
+    sInf ((↑) '' t : Set α) = (@sInf s _ t : α) := by simp [dif_pos h]
+#align subset_Inf_of_within subset_sInf_of_within
 
 end InfSet
 
@@ -100,67 +100,67 @@ attribute [local instance] subsetSupSet
 attribute [local instance] subsetInfSet
 
 /-- For a nonempty subset of a conditionally complete linear order to be a conditionally complete
-linear order, it suffices that it contain the `supₛ` of all its nonempty bounded-above subsets, and
-the `infₛ` of all its nonempty bounded-below subsets.
+linear order, it suffices that it contain the `sSup` of all its nonempty bounded-above subsets, and
+the `sInf` of all its nonempty bounded-below subsets.
 See note [reducible non-instances]. -/
 @[reducible]
 noncomputable def subsetConditionallyCompleteLinearOrder [Inhabited s]
-    (h_Sup : ∀ {t : Set s} (_ : t.Nonempty) (_h_bdd : BddAbove t), supₛ ((↑) '' t : Set α) ∈ s)
-    (h_Inf : ∀ {t : Set s} (_ : t.Nonempty) (_h_bdd : BddBelow t), infₛ ((↑) '' t : Set α) ∈ s) :
+    (h_Sup : ∀ {t : Set s} (_ : t.Nonempty) (_h_bdd : BddAbove t), sSup ((↑) '' t : Set α) ∈ s)
+    (h_Inf : ∀ {t : Set s} (_ : t.Nonempty) (_h_bdd : BddBelow t), sInf ((↑) '' t : Set α) ∈ s) :
     ConditionallyCompleteLinearOrder s :=
   { -- The following would be a more natural way to finish, but gives a "deep recursion" error:
       -- simpa [subset_Sup_of_within (h_Sup t)] using
       --   (strict_mono_coe s).monotone.le_cSup_image hct h_bdd,
     subsetSupSet s, subsetInfSet s, DistribLattice.toLattice, (inferInstance : LinearOrder s) with
-    le_csupₛ := by
+    le_csSup := by
       rintro t c h_bdd hct
-      rw [← Subtype.coe_le_coe, ← subset_supₛ_of_within s (h_Sup ⟨c, hct⟩ h_bdd)]
-      exact (Subtype.mono_coe _).le_csupₛ_image hct h_bdd
-    csupₛ_le := by
+      rw [← Subtype.coe_le_coe, ← subset_sSup_of_within s (h_Sup ⟨c, hct⟩ h_bdd)]
+      exact (Subtype.mono_coe _).le_csSup_image hct h_bdd
+    csSup_le := by
       rintro t B ht hB
-      rw [← Subtype.coe_le_coe, ← subset_supₛ_of_within s (h_Sup ht ⟨B, hB⟩)]
-      exact (Subtype.mono_coe s).csupₛ_image_le ht hB
-    le_cinfₛ := by
+      rw [← Subtype.coe_le_coe, ← subset_sSup_of_within s (h_Sup ht ⟨B, hB⟩)]
+      exact (Subtype.mono_coe s).csSup_image_le ht hB
+    le_csInf := by
       intro t B ht hB
-      rw [← Subtype.coe_le_coe, ← subset_infₛ_of_within s (h_Inf ht ⟨B, hB⟩)]
-      exact (Subtype.mono_coe s).le_cinfₛ_image ht hB
-    cinfₛ_le := by
+      rw [← Subtype.coe_le_coe, ← subset_sInf_of_within s (h_Inf ht ⟨B, hB⟩)]
+      exact (Subtype.mono_coe s).le_csInf_image ht hB
+    csInf_le := by
       rintro t c h_bdd hct
-      rw [← Subtype.coe_le_coe, ← subset_infₛ_of_within s (h_Inf ⟨c, hct⟩ h_bdd)]
-      exact (Subtype.mono_coe s).cinfₛ_image_le hct h_bdd }
+      rw [← Subtype.coe_le_coe, ← subset_sInf_of_within s (h_Inf ⟨c, hct⟩ h_bdd)]
+      exact (Subtype.mono_coe s).csInf_image_le hct h_bdd }
 #align subset_conditionally_complete_linear_order subsetConditionallyCompleteLinearOrder
 
 section OrdConnected
 
-/-- The `supₛ` function on a nonempty `OrdConnected` set `s` in a conditionally complete linear
+/-- The `sSup` function on a nonempty `OrdConnected` set `s` in a conditionally complete linear
 order takes values within `s`, for all nonempty bounded-above subsets of `s`. -/
-theorem supₛ_within_of_ordConnected {s : Set α} [hs : OrdConnected s] ⦃t : Set s⦄ (ht : t.Nonempty)
-    (h_bdd : BddAbove t) : supₛ ((↑) '' t : Set α) ∈ s := by
+theorem sSup_within_of_ordConnected {s : Set α} [hs : OrdConnected s] ⦃t : Set s⦄ (ht : t.Nonempty)
+    (h_bdd : BddAbove t) : sSup ((↑) '' t : Set α) ∈ s := by
   obtain ⟨c, hct⟩ : ∃ c, c ∈ t := ht
   obtain ⟨B, hB⟩ : ∃ B, B ∈ upperBounds t := h_bdd
   refine' hs.out c.2 B.2 ⟨_, _⟩
-  · exact (Subtype.mono_coe s).le_csupₛ_image hct ⟨B, hB⟩
-  · exact (Subtype.mono_coe s).csupₛ_image_le ⟨c, hct⟩ hB
-#align Sup_within_of_ord_connected supₛ_within_of_ordConnected
+  · exact (Subtype.mono_coe s).le_csSup_image hct ⟨B, hB⟩
+  · exact (Subtype.mono_coe s).csSup_image_le ⟨c, hct⟩ hB
+#align Sup_within_of_ord_connected sSup_within_of_ordConnected
 
-/-- The `infₛ` function on a nonempty `OrdConnected` set `s` in a conditionally complete linear
+/-- The `sInf` function on a nonempty `OrdConnected` set `s` in a conditionally complete linear
 order takes values within `s`, for all nonempty bounded-below subsets of `s`. -/
-theorem infₛ_within_of_ordConnected {s : Set α} [hs : OrdConnected s] ⦃t : Set s⦄ (ht : t.Nonempty)
-    (h_bdd : BddBelow t) : infₛ ((↑) '' t : Set α) ∈ s := by
+theorem sInf_within_of_ordConnected {s : Set α} [hs : OrdConnected s] ⦃t : Set s⦄ (ht : t.Nonempty)
+    (h_bdd : BddBelow t) : sInf ((↑) '' t : Set α) ∈ s := by
   obtain ⟨c, hct⟩ : ∃ c, c ∈ t := ht
   obtain ⟨B, hB⟩ : ∃ B, B ∈ lowerBounds t := h_bdd
   refine' hs.out B.2 c.2 ⟨_, _⟩
-  · exact (Subtype.mono_coe s).le_cinfₛ_image ⟨c, hct⟩ hB
-  · exact (Subtype.mono_coe s).cinfₛ_image_le hct ⟨B, hB⟩
-#align Inf_within_of_ord_connected infₛ_within_of_ordConnected
+  · exact (Subtype.mono_coe s).le_csInf_image ⟨c, hct⟩ hB
+  · exact (Subtype.mono_coe s).csInf_image_le hct ⟨B, hB⟩
+#align Inf_within_of_ord_connected sInf_within_of_ordConnected
 
 /-- A nonempty `OrdConnected` set in a conditionally complete linear order is naturally a
 conditionally complete linear order. -/
 noncomputable instance ordConnectedSubsetConditionallyCompleteLinearOrder [Inhabited s]
     [OrdConnected s] : ConditionallyCompleteLinearOrder s :=
   subsetConditionallyCompleteLinearOrder s
-    (fun h => supₛ_within_of_ordConnected h)
-    (fun h => infₛ_within_of_ordConnected h)
+    (fun h => sSup_within_of_ordConnected h)
+    (fun h => sInf_within_of_ordConnected h)
 #align ord_connected_subset_conditionally_complete_linear_order ordConnectedSubsetConditionallyCompleteLinearOrder
 
 end OrdConnected

@@ -161,8 +161,6 @@ noncomputable instance ordConnectedSubsetConditionallyCompleteLinearOrder [Inhab
   subsetConditionallyCompleteLinearOrder s
     (fun h => supₛ_within_of_ordConnected h)
     (fun h => infₛ_within_of_ordConnected h)
-#align
-  ord_connected_subset_conditionally_complete_linear_order
-  ordConnectedSubsetConditionallyCompleteLinearOrder
+#align ord_connected_subset_conditionally_complete_linear_order ordConnectedSubsetConditionallyCompleteLinearOrder
 
 end OrdConnected

Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Chris Hughes <33847686+ChrisHughes24@users.noreply.github.com>