data.int.conditionally_complete_order | Mathlib porting status

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

1e05171a

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

c3291da4

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2021 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
 -/
-import Mathbin.Order.ConditionallyCompleteLattice.Basic
-import Mathbin.Data.Int.LeastGreatest
+import Order.ConditionallyCompleteLattice.Basic
+import Data.Int.LeastGreatest
 
 #align_import data.int.conditionally_complete_order from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"

c3291da4

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2021 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
-
-! This file was ported from Lean 3 source module data.int.conditionally_complete_order
-! 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.Int.LeastGreatest
 
+#align_import data.int.conditionally_complete_order from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"
+
 /-!
 ## `ℤ` forms a conditionally complete linear order

c3291da4

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -61,6 +61,7 @@ instance : ConditionallyCompleteLinearOrder ℤ :=
 
 namespace Int
 
+#print Int.csSup_eq_greatest_of_bdd /-
 theorem csSup_eq_greatest_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : ℤ) (Hb : ∀ z ∈ s, z ≤ b)
     (Hinh : ∃ z : ℤ, z ∈ s) : sSup s = greatestOfBdd b Hb Hinh :=
   by
@@ -68,16 +69,22 @@ theorem csSup_eq_greatest_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : 
   · convert coe_greatest_of_bdd_eq _ (Classical.choose_spec (⟨b, Hb⟩ : BddAbove s)) _
   · exact ⟨Hinh, b, Hb⟩
 #align int.cSup_eq_greatest_of_bdd Int.csSup_eq_greatest_of_bdd
+-/
 
+#print Int.csSup_empty /-
 @[simp]
 theorem csSup_empty : sSup (∅ : Set ℤ) = 0 :=
   dif_neg (by simp)
 #align int.cSup_empty Int.csSup_empty
+-/
 
+#print Int.csSup_of_not_bdd_above /-
 theorem csSup_of_not_bdd_above {s : Set ℤ} (h : ¬BddAbove s) : sSup s = 0 :=
   dif_neg (by simp [h])
 #align int.cSup_of_not_bdd_above Int.csSup_of_not_bdd_above
+-/
 
+#print Int.csInf_eq_least_of_bdd /-
 theorem csInf_eq_least_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : ℤ) (Hb : ∀ z ∈ s, b ≤ z)
     (Hinh : ∃ z : ℤ, z ∈ s) : sInf s = leastOfBdd b Hb Hinh :=
   by
@@ -85,27 +92,36 @@ theorem csInf_eq_least_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : ℤ)
   · convert coe_least_of_bdd_eq _ (Classical.choose_spec (⟨b, Hb⟩ : BddBelow s)) _
   · exact ⟨Hinh, b, Hb⟩
 #align int.cInf_eq_least_of_bdd Int.csInf_eq_least_of_bdd
+-/
 
+#print Int.csInf_empty /-
 @[simp]
 theorem csInf_empty : sInf (∅ : Set ℤ) = 0 :=
   dif_neg (by simp)
 #align int.cInf_empty Int.csInf_empty
+-/
 
+#print Int.csInf_of_not_bdd_below /-
 theorem csInf_of_not_bdd_below {s : Set ℤ} (h : ¬BddBelow s) : sInf s = 0 :=
   dif_neg (by simp [h])
 #align int.cInf_of_not_bdd_below Int.csInf_of_not_bdd_below
+-/
 
+#print Int.csSup_mem /-
 theorem csSup_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddAbove s) : sSup s ∈ s :=
   by
   convert (greatest_of_bdd _ (Classical.choose_spec h2) h1).2.1
   exact dif_pos ⟨h1, h2⟩
 #align int.cSup_mem Int.csSup_mem
+-/
 
+#print Int.csInf_mem /-
 theorem csInf_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddBelow s) : sInf s ∈ s :=
   by
   convert (least_of_bdd _ (Classical.choose_spec h2) h1).2.1
   exact dif_pos ⟨h1, h2⟩
 #align int.cInf_mem Int.csInf_mem
+-/
 
 end Int

c3291da4

bump to nightly-2023-06-04-18

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

3fb4268b

Diff

@@ -97,13 +97,13 @@ theorem csInf_of_not_bdd_below {s : Set ℤ} (h : ¬BddBelow s) : sInf s = 0 :=
 
 theorem csSup_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddAbove s) : sSup s ∈ s :=
   by
-  convert(greatest_of_bdd _ (Classical.choose_spec h2) h1).2.1
+  convert (greatest_of_bdd _ (Classical.choose_spec h2) h1).2.1
   exact dif_pos ⟨h1, h2⟩
 #align int.cSup_mem Int.csSup_mem
 
 theorem csInf_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddBelow s) : sInf s ∈ s :=
   by
-  convert(least_of_bdd _ (Classical.choose_spec h2) h1).2.1
+  convert (least_of_bdd _ (Classical.choose_spec h2) h1).2.1
   exact dif_pos ⟨h1, h2⟩
 #align int.cInf_mem Int.csInf_mem

c3291da4

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -23,7 +23,7 @@ The integers form a conditionally complete linear order.
 
 open Int
 
-open Classical
+open scoped Classical
 
 noncomputable section

c3291da4

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -61,12 +61,6 @@ instance : ConditionallyCompleteLinearOrder ℤ :=
 
 namespace Int
 
-/- warning: int.cSup_eq_greatest_of_bdd -> Int.csSup_eq_greatest_of_bdd is a dubious translation:
-lean 3 declaration is
-  forall {s : Set.{0} Int} [_inst_1 : DecidablePred.{1} Int (fun (_x : Int) => Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) _x s)] (b : Int) (Hb : forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe z b)) (Hinh : Exists.{1} Int (fun (z : Int) => Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s)), Eq.{1} Int (SupSet.sSup.{0} Int (ConditionallyCompleteLattice.toHasSup.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) s) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Subtype.{1} Int (fun (ub : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) ub s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe z ub)))) Int (HasLiftT.mk.{1, 1} (Subtype.{1} Int (fun (ub : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) ub s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe z ub)))) Int (CoeTCₓ.coe.{1, 1} (Subtype.{1} Int (fun (ub : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) ub s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe z ub)))) Int (coeBase.{1, 1} (Subtype.{1} Int (fun (ub : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) ub s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe z ub)))) Int (coeSubtype.{1} Int (fun (ub : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) ub s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe z ub))))))) (Int.greatestOfBdd (fun (z : Int) => Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) (fun (a : Int) => _inst_1 a) b Hb Hinh))
-but is expected to have type
-  forall {s : Set.{0} Int} [_inst_1 : DecidablePred.{1} Int (fun (_x : Int) => Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) _x s)] (b : Int) (Hb : forall (z : Int), (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s) -> (LE.le.{0} Int Int.instLEInt z b)) (Hinh : Exists.{1} Int (fun (z : Int) => Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s)), Eq.{1} Int (SupSet.sSup.{0} Int (ConditionallyCompleteLattice.toSupSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) s) (Subtype.val.{1} Int (fun (ub : Int) => And (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) ub s) (forall (z : Int), (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s) -> (LE.le.{0} Int Int.instLEInt z ub))) (Int.greatestOfBdd (fun (z : Int) => Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s) (fun (a : Int) => _inst_1 a) b Hb Hinh))
-Case conversion may be inaccurate. Consider using '#align int.cSup_eq_greatest_of_bdd Int.csSup_eq_greatest_of_bddₓ'. -/
 theorem csSup_eq_greatest_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : ℤ) (Hb : ∀ z ∈ s, z ≤ b)
     (Hinh : ∃ z : ℤ, z ∈ s) : sSup s = greatestOfBdd b Hb Hinh :=
   by
@@ -75,33 +69,15 @@ theorem csSup_eq_greatest_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : 
   · exact ⟨Hinh, b, Hb⟩
 #align int.cSup_eq_greatest_of_bdd Int.csSup_eq_greatest_of_bdd
 
-/- warning: int.cSup_empty -> Int.csSup_empty is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Int (SupSet.sSup.{0} Int (ConditionallyCompleteLattice.toHasSup.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) (EmptyCollection.emptyCollection.{0} (Set.{0} Int) (Set.hasEmptyc.{0} Int))) (OfNat.ofNat.{0} Int 0 (OfNat.mk.{0} Int 0 (Zero.zero.{0} Int Int.hasZero)))
-but is expected to have type
-  Eq.{1} Int (SupSet.sSup.{0} Int (ConditionallyCompleteLattice.toSupSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) (EmptyCollection.emptyCollection.{0} (Set.{0} Int) (Set.instEmptyCollectionSet.{0} Int))) (OfNat.ofNat.{0} Int 0 (instOfNatInt 0))
-Case conversion may be inaccurate. Consider using '#align int.cSup_empty Int.csSup_emptyₓ'. -/
 @[simp]
 theorem csSup_empty : sSup (∅ : Set ℤ) = 0 :=
   dif_neg (by simp)
 #align int.cSup_empty Int.csSup_empty
 
-/- warning: int.cSup_of_not_bdd_above -> Int.csSup_of_not_bdd_above is a dubious translation:
-lean 3 declaration is
-  forall {s : Set.{0} Int}, (Not (BddAbove.{0} Int (PartialOrder.toPreorder.{0} Int (OrderedAddCommGroup.toPartialOrder.{0} Int (StrictOrderedRing.toOrderedAddCommGroup.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing))))) s)) -> (Eq.{1} Int (SupSet.sSup.{0} Int (ConditionallyCompleteLattice.toHasSup.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) s) (OfNat.ofNat.{0} Int 0 (OfNat.mk.{0} Int 0 (Zero.zero.{0} Int Int.hasZero))))
-but is expected to have type
-  forall {s : Set.{0} Int}, (Not (BddAbove.{0} Int (PartialOrder.toPreorder.{0} Int (StrictOrderedRing.toPartialOrder.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing)))) s)) -> (Eq.{1} Int (SupSet.sSup.{0} Int (ConditionallyCompleteLattice.toSupSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) s) (OfNat.ofNat.{0} Int 0 (instOfNatInt 0)))
-Case conversion may be inaccurate. Consider using '#align int.cSup_of_not_bdd_above Int.csSup_of_not_bdd_aboveₓ'. -/
 theorem csSup_of_not_bdd_above {s : Set ℤ} (h : ¬BddAbove s) : sSup s = 0 :=
   dif_neg (by simp [h])
 #align int.cSup_of_not_bdd_above Int.csSup_of_not_bdd_above
 
-/- warning: int.cInf_eq_least_of_bdd -> Int.csInf_eq_least_of_bdd is a dubious translation:
-lean 3 declaration is
-  forall {s : Set.{0} Int} [_inst_1 : DecidablePred.{1} Int (fun (_x : Int) => Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) _x s)] (b : Int) (Hb : forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe b z)) (Hinh : Exists.{1} Int (fun (z : Int) => Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s)), Eq.{1} Int (InfSet.sInf.{0} Int (ConditionallyCompleteLattice.toHasInf.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) s) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Subtype.{1} Int (fun (lb : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) lb s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe lb z)))) Int (HasLiftT.mk.{1, 1} (Subtype.{1} Int (fun (lb : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) lb s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe lb z)))) Int (CoeTCₓ.coe.{1, 1} (Subtype.{1} Int (fun (lb : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) lb s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe lb z)))) Int (coeBase.{1, 1} (Subtype.{1} Int (fun (lb : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) lb s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe lb z)))) Int (coeSubtype.{1} Int (fun (lb : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) lb s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe lb z))))))) (Int.leastOfBdd (fun (z : Int) => Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) (fun (a : Int) => _inst_1 a) b Hb Hinh))
-but is expected to have type
-  forall {s : Set.{0} Int} [_inst_1 : DecidablePred.{1} Int (fun (_x : Int) => Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) _x s)] (b : Int) (Hb : forall (z : Int), (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s) -> (LE.le.{0} Int Int.instLEInt b z)) (Hinh : Exists.{1} Int (fun (z : Int) => Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s)), Eq.{1} Int (InfSet.sInf.{0} Int (ConditionallyCompleteLattice.toInfSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) s) (Subtype.val.{1} Int (fun (lb : Int) => And (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) lb s) (forall (z : Int), (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s) -> (LE.le.{0} Int Int.instLEInt lb z))) (Int.leastOfBdd (fun (z : Int) => Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s) (fun (a : Int) => _inst_1 a) b Hb Hinh))
-Case conversion may be inaccurate. Consider using '#align int.cInf_eq_least_of_bdd Int.csInf_eq_least_of_bddₓ'. -/
 theorem csInf_eq_least_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : ℤ) (Hb : ∀ z ∈ s, b ≤ z)
     (Hinh : ∃ z : ℤ, z ∈ s) : sInf s = leastOfBdd b Hb Hinh :=
   by
@@ -110,45 +86,21 @@ theorem csInf_eq_least_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : ℤ)
   · exact ⟨Hinh, b, Hb⟩
 #align int.cInf_eq_least_of_bdd Int.csInf_eq_least_of_bdd
 
-/- warning: int.cInf_empty -> Int.csInf_empty is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Int (InfSet.sInf.{0} Int (ConditionallyCompleteLattice.toHasInf.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) (EmptyCollection.emptyCollection.{0} (Set.{0} Int) (Set.hasEmptyc.{0} Int))) (OfNat.ofNat.{0} Int 0 (OfNat.mk.{0} Int 0 (Zero.zero.{0} Int Int.hasZero)))
-but is expected to have type
-  Eq.{1} Int (InfSet.sInf.{0} Int (ConditionallyCompleteLattice.toInfSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) (EmptyCollection.emptyCollection.{0} (Set.{0} Int) (Set.instEmptyCollectionSet.{0} Int))) (OfNat.ofNat.{0} Int 0 (instOfNatInt 0))
-Case conversion may be inaccurate. Consider using '#align int.cInf_empty Int.csInf_emptyₓ'. -/
 @[simp]
 theorem csInf_empty : sInf (∅ : Set ℤ) = 0 :=
   dif_neg (by simp)
 #align int.cInf_empty Int.csInf_empty
 
-/- warning: int.cInf_of_not_bdd_below -> Int.csInf_of_not_bdd_below is a dubious translation:
-lean 3 declaration is
-  forall {s : Set.{0} Int}, (Not (BddBelow.{0} Int (PartialOrder.toPreorder.{0} Int (OrderedAddCommGroup.toPartialOrder.{0} Int (StrictOrderedRing.toOrderedAddCommGroup.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing))))) s)) -> (Eq.{1} Int (InfSet.sInf.{0} Int (ConditionallyCompleteLattice.toHasInf.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) s) (OfNat.ofNat.{0} Int 0 (OfNat.mk.{0} Int 0 (Zero.zero.{0} Int Int.hasZero))))
-but is expected to have type
-  forall {s : Set.{0} Int}, (Not (BddBelow.{0} Int (PartialOrder.toPreorder.{0} Int (StrictOrderedRing.toPartialOrder.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing)))) s)) -> (Eq.{1} Int (InfSet.sInf.{0} Int (ConditionallyCompleteLattice.toInfSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) s) (OfNat.ofNat.{0} Int 0 (instOfNatInt 0)))
-Case conversion may be inaccurate. Consider using '#align int.cInf_of_not_bdd_below Int.csInf_of_not_bdd_belowₓ'. -/
 theorem csInf_of_not_bdd_below {s : Set ℤ} (h : ¬BddBelow s) : sInf s = 0 :=
   dif_neg (by simp [h])
 #align int.cInf_of_not_bdd_below Int.csInf_of_not_bdd_below
 
-/- warning: int.cSup_mem -> Int.csSup_mem is a dubious translation:
-lean 3 declaration is
-  forall {s : Set.{0} Int}, (Set.Nonempty.{0} Int s) -> (BddAbove.{0} Int (PartialOrder.toPreorder.{0} Int (OrderedAddCommGroup.toPartialOrder.{0} Int (StrictOrderedRing.toOrderedAddCommGroup.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing))))) s) -> (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) (SupSet.sSup.{0} Int (ConditionallyCompleteLattice.toHasSup.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) s) s)
-but is expected to have type
-  forall {s : Set.{0} Int}, (Set.Nonempty.{0} Int s) -> (BddAbove.{0} Int (PartialOrder.toPreorder.{0} Int (StrictOrderedRing.toPartialOrder.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing)))) s) -> (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) (SupSet.sSup.{0} Int (ConditionallyCompleteLattice.toSupSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) s) s)
-Case conversion may be inaccurate. Consider using '#align int.cSup_mem Int.csSup_memₓ'. -/
 theorem csSup_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddAbove s) : sSup s ∈ s :=
   by
   convert(greatest_of_bdd _ (Classical.choose_spec h2) h1).2.1
   exact dif_pos ⟨h1, h2⟩
 #align int.cSup_mem Int.csSup_mem
 
-/- warning: int.cInf_mem -> Int.csInf_mem is a dubious translation:
-lean 3 declaration is
-  forall {s : Set.{0} Int}, (Set.Nonempty.{0} Int s) -> (BddBelow.{0} Int (PartialOrder.toPreorder.{0} Int (OrderedAddCommGroup.toPartialOrder.{0} Int (StrictOrderedRing.toOrderedAddCommGroup.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing))))) s) -> (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) (InfSet.sInf.{0} Int (ConditionallyCompleteLattice.toHasInf.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) s) s)
-but is expected to have type
-  forall {s : Set.{0} Int}, (Set.Nonempty.{0} Int s) -> (BddBelow.{0} Int (PartialOrder.toPreorder.{0} Int (StrictOrderedRing.toPartialOrder.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing)))) s) -> (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) (InfSet.sInf.{0} Int (ConditionallyCompleteLattice.toInfSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) s) s)
-Case conversion may be inaccurate. Consider using '#align int.cInf_mem Int.csInf_memₓ'. -/
 theorem csInf_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddBelow s) : sInf s ∈ s :=
   by
   convert(least_of_bdd _ (Classical.choose_spec h2) h1).2.1

c3291da4

bump to nightly-2023-05-14-08

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

d31da313

Diff

@@ -30,11 +30,11 @@ noncomputable section
 instance : ConditionallyCompleteLinearOrder ℤ :=
   { Int.linearOrder,
     LinearOrder.toLattice with
-    supₛ := fun s =>
+    sSup := fun s =>
       if h : s.Nonempty ∧ BddAbove s then
         greatestOfBdd (Classical.choose h.2) (Classical.choose_spec h.2) h.1
       else 0
-    infₛ := fun s =>
+    sInf := fun s =>
       if h : s.Nonempty ∧ BddBelow s then
         leastOfBdd (Classical.choose h.2) (Classical.choose_spec h.2) h.1
       else 0
@@ -61,99 +61,99 @@ instance : ConditionallyCompleteLinearOrder ℤ :=
 
 namespace Int
 
-/- warning: int.cSup_eq_greatest_of_bdd -> Int.csupₛ_eq_greatest_of_bdd is a dubious translation:
+/- warning: int.cSup_eq_greatest_of_bdd -> Int.csSup_eq_greatest_of_bdd is a dubious translation:
 lean 3 declaration is
-  forall {s : Set.{0} Int} [_inst_1 : DecidablePred.{1} Int (fun (_x : Int) => Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) _x s)] (b : Int) (Hb : forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe z b)) (Hinh : Exists.{1} Int (fun (z : Int) => Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s)), Eq.{1} Int (SupSet.supₛ.{0} Int (ConditionallyCompleteLattice.toHasSup.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) s) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Subtype.{1} Int (fun (ub : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) ub s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe z ub)))) Int (HasLiftT.mk.{1, 1} (Subtype.{1} Int (fun (ub : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) ub s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe z ub)))) Int (CoeTCₓ.coe.{1, 1} (Subtype.{1} Int (fun (ub : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) ub s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe z ub)))) Int (coeBase.{1, 1} (Subtype.{1} Int (fun (ub : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) ub s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe z ub)))) Int (coeSubtype.{1} Int (fun (ub : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) ub s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe z ub))))))) (Int.greatestOfBdd (fun (z : Int) => Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) (fun (a : Int) => _inst_1 a) b Hb Hinh))
+  forall {s : Set.{0} Int} [_inst_1 : DecidablePred.{1} Int (fun (_x : Int) => Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) _x s)] (b : Int) (Hb : forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe z b)) (Hinh : Exists.{1} Int (fun (z : Int) => Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s)), Eq.{1} Int (SupSet.sSup.{0} Int (ConditionallyCompleteLattice.toHasSup.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) s) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Subtype.{1} Int (fun (ub : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) ub s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe z ub)))) Int (HasLiftT.mk.{1, 1} (Subtype.{1} Int (fun (ub : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) ub s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe z ub)))) Int (CoeTCₓ.coe.{1, 1} (Subtype.{1} Int (fun (ub : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) ub s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe z ub)))) Int (coeBase.{1, 1} (Subtype.{1} Int (fun (ub : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) ub s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe z ub)))) Int (coeSubtype.{1} Int (fun (ub : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) ub s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe z ub))))))) (Int.greatestOfBdd (fun (z : Int) => Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) (fun (a : Int) => _inst_1 a) b Hb Hinh))
 but is expected to have type
-  forall {s : Set.{0} Int} [_inst_1 : DecidablePred.{1} Int (fun (_x : Int) => Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) _x s)] (b : Int) (Hb : forall (z : Int), (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s) -> (LE.le.{0} Int Int.instLEInt z b)) (Hinh : Exists.{1} Int (fun (z : Int) => Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s)), Eq.{1} Int (SupSet.supₛ.{0} Int (ConditionallyCompleteLattice.toSupSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) s) (Subtype.val.{1} Int (fun (ub : Int) => And (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) ub s) (forall (z : Int), (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s) -> (LE.le.{0} Int Int.instLEInt z ub))) (Int.greatestOfBdd (fun (z : Int) => Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s) (fun (a : Int) => _inst_1 a) b Hb Hinh))
-Case conversion may be inaccurate. Consider using '#align int.cSup_eq_greatest_of_bdd Int.csupₛ_eq_greatest_of_bddₓ'. -/
-theorem csupₛ_eq_greatest_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : ℤ) (Hb : ∀ z ∈ s, z ≤ b)
-    (Hinh : ∃ z : ℤ, z ∈ s) : supₛ s = greatestOfBdd b Hb Hinh :=
+  forall {s : Set.{0} Int} [_inst_1 : DecidablePred.{1} Int (fun (_x : Int) => Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) _x s)] (b : Int) (Hb : forall (z : Int), (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s) -> (LE.le.{0} Int Int.instLEInt z b)) (Hinh : Exists.{1} Int (fun (z : Int) => Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s)), Eq.{1} Int (SupSet.sSup.{0} Int (ConditionallyCompleteLattice.toSupSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) s) (Subtype.val.{1} Int (fun (ub : Int) => And (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) ub s) (forall (z : Int), (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s) -> (LE.le.{0} Int Int.instLEInt z ub))) (Int.greatestOfBdd (fun (z : Int) => Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s) (fun (a : Int) => _inst_1 a) b Hb Hinh))
+Case conversion may be inaccurate. Consider using '#align int.cSup_eq_greatest_of_bdd Int.csSup_eq_greatest_of_bddₓ'. -/
+theorem csSup_eq_greatest_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : ℤ) (Hb : ∀ z ∈ s, z ≤ b)
+    (Hinh : ∃ z : ℤ, z ∈ s) : sSup s = greatestOfBdd b Hb Hinh :=
   by
   convert dif_pos _ using 1
   · convert coe_greatest_of_bdd_eq _ (Classical.choose_spec (⟨b, Hb⟩ : BddAbove s)) _
   · exact ⟨Hinh, b, Hb⟩
-#align int.cSup_eq_greatest_of_bdd Int.csupₛ_eq_greatest_of_bdd
+#align int.cSup_eq_greatest_of_bdd Int.csSup_eq_greatest_of_bdd
 
-/- warning: int.cSup_empty -> Int.csupₛ_empty is a dubious translation:
+/- warning: int.cSup_empty -> Int.csSup_empty is a dubious translation:
 lean 3 declaration is
-  Eq.{1} Int (SupSet.supₛ.{0} Int (ConditionallyCompleteLattice.toHasSup.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) (EmptyCollection.emptyCollection.{0} (Set.{0} Int) (Set.hasEmptyc.{0} Int))) (OfNat.ofNat.{0} Int 0 (OfNat.mk.{0} Int 0 (Zero.zero.{0} Int Int.hasZero)))
+  Eq.{1} Int (SupSet.sSup.{0} Int (ConditionallyCompleteLattice.toHasSup.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) (EmptyCollection.emptyCollection.{0} (Set.{0} Int) (Set.hasEmptyc.{0} Int))) (OfNat.ofNat.{0} Int 0 (OfNat.mk.{0} Int 0 (Zero.zero.{0} Int Int.hasZero)))
 but is expected to have type
-  Eq.{1} Int (SupSet.supₛ.{0} Int (ConditionallyCompleteLattice.toSupSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) (EmptyCollection.emptyCollection.{0} (Set.{0} Int) (Set.instEmptyCollectionSet.{0} Int))) (OfNat.ofNat.{0} Int 0 (instOfNatInt 0))
-Case conversion may be inaccurate. Consider using '#align int.cSup_empty Int.csupₛ_emptyₓ'. -/
+  Eq.{1} Int (SupSet.sSup.{0} Int (ConditionallyCompleteLattice.toSupSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) (EmptyCollection.emptyCollection.{0} (Set.{0} Int) (Set.instEmptyCollectionSet.{0} Int))) (OfNat.ofNat.{0} Int 0 (instOfNatInt 0))
+Case conversion may be inaccurate. Consider using '#align int.cSup_empty Int.csSup_emptyₓ'. -/
 @[simp]
-theorem csupₛ_empty : supₛ (∅ : Set ℤ) = 0 :=
+theorem csSup_empty : sSup (∅ : Set ℤ) = 0 :=
   dif_neg (by simp)
-#align int.cSup_empty Int.csupₛ_empty
+#align int.cSup_empty Int.csSup_empty
 
-/- warning: int.cSup_of_not_bdd_above -> Int.csupₛ_of_not_bdd_above is a dubious translation:
+/- warning: int.cSup_of_not_bdd_above -> Int.csSup_of_not_bdd_above is a dubious translation:
 lean 3 declaration is
-  forall {s : Set.{0} Int}, (Not (BddAbove.{0} Int (PartialOrder.toPreorder.{0} Int (OrderedAddCommGroup.toPartialOrder.{0} Int (StrictOrderedRing.toOrderedAddCommGroup.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing))))) s)) -> (Eq.{1} Int (SupSet.supₛ.{0} Int (ConditionallyCompleteLattice.toHasSup.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) s) (OfNat.ofNat.{0} Int 0 (OfNat.mk.{0} Int 0 (Zero.zero.{0} Int Int.hasZero))))
+  forall {s : Set.{0} Int}, (Not (BddAbove.{0} Int (PartialOrder.toPreorder.{0} Int (OrderedAddCommGroup.toPartialOrder.{0} Int (StrictOrderedRing.toOrderedAddCommGroup.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing))))) s)) -> (Eq.{1} Int (SupSet.sSup.{0} Int (ConditionallyCompleteLattice.toHasSup.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) s) (OfNat.ofNat.{0} Int 0 (OfNat.mk.{0} Int 0 (Zero.zero.{0} Int Int.hasZero))))
 but is expected to have type
-  forall {s : Set.{0} Int}, (Not (BddAbove.{0} Int (PartialOrder.toPreorder.{0} Int (StrictOrderedRing.toPartialOrder.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing)))) s)) -> (Eq.{1} Int (SupSet.supₛ.{0} Int (ConditionallyCompleteLattice.toSupSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) s) (OfNat.ofNat.{0} Int 0 (instOfNatInt 0)))
-Case conversion may be inaccurate. Consider using '#align int.cSup_of_not_bdd_above Int.csupₛ_of_not_bdd_aboveₓ'. -/
-theorem csupₛ_of_not_bdd_above {s : Set ℤ} (h : ¬BddAbove s) : supₛ s = 0 :=
+  forall {s : Set.{0} Int}, (Not (BddAbove.{0} Int (PartialOrder.toPreorder.{0} Int (StrictOrderedRing.toPartialOrder.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing)))) s)) -> (Eq.{1} Int (SupSet.sSup.{0} Int (ConditionallyCompleteLattice.toSupSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) s) (OfNat.ofNat.{0} Int 0 (instOfNatInt 0)))
+Case conversion may be inaccurate. Consider using '#align int.cSup_of_not_bdd_above Int.csSup_of_not_bdd_aboveₓ'. -/
+theorem csSup_of_not_bdd_above {s : Set ℤ} (h : ¬BddAbove s) : sSup s = 0 :=
   dif_neg (by simp [h])
-#align int.cSup_of_not_bdd_above Int.csupₛ_of_not_bdd_above
+#align int.cSup_of_not_bdd_above Int.csSup_of_not_bdd_above
 
-/- warning: int.cInf_eq_least_of_bdd -> Int.cinfₛ_eq_least_of_bdd is a dubious translation:
+/- warning: int.cInf_eq_least_of_bdd -> Int.csInf_eq_least_of_bdd is a dubious translation:
 lean 3 declaration is
-  forall {s : Set.{0} Int} [_inst_1 : DecidablePred.{1} Int (fun (_x : Int) => Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) _x s)] (b : Int) (Hb : forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe b z)) (Hinh : Exists.{1} Int (fun (z : Int) => Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s)), Eq.{1} Int (InfSet.infₛ.{0} Int (ConditionallyCompleteLattice.toHasInf.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) s) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Subtype.{1} Int (fun (lb : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) lb s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe lb z)))) Int (HasLiftT.mk.{1, 1} (Subtype.{1} Int (fun (lb : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) lb s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe lb z)))) Int (CoeTCₓ.coe.{1, 1} (Subtype.{1} Int (fun (lb : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) lb s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe lb z)))) Int (coeBase.{1, 1} (Subtype.{1} Int (fun (lb : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) lb s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe lb z)))) Int (coeSubtype.{1} Int (fun (lb : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) lb s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe lb z))))))) (Int.leastOfBdd (fun (z : Int) => Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) (fun (a : Int) => _inst_1 a) b Hb Hinh))
+  forall {s : Set.{0} Int} [_inst_1 : DecidablePred.{1} Int (fun (_x : Int) => Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) _x s)] (b : Int) (Hb : forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe b z)) (Hinh : Exists.{1} Int (fun (z : Int) => Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s)), Eq.{1} Int (InfSet.sInf.{0} Int (ConditionallyCompleteLattice.toHasInf.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) s) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Subtype.{1} Int (fun (lb : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) lb s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe lb z)))) Int (HasLiftT.mk.{1, 1} (Subtype.{1} Int (fun (lb : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) lb s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe lb z)))) Int (CoeTCₓ.coe.{1, 1} (Subtype.{1} Int (fun (lb : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) lb s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe lb z)))) Int (coeBase.{1, 1} (Subtype.{1} Int (fun (lb : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) lb s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe lb z)))) Int (coeSubtype.{1} Int (fun (lb : Int) => And (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) lb s) (forall (z : Int), (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) -> (LE.le.{0} Int Int.hasLe lb z))))))) (Int.leastOfBdd (fun (z : Int) => Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) z s) (fun (a : Int) => _inst_1 a) b Hb Hinh))
 but is expected to have type
-  forall {s : Set.{0} Int} [_inst_1 : DecidablePred.{1} Int (fun (_x : Int) => Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) _x s)] (b : Int) (Hb : forall (z : Int), (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s) -> (LE.le.{0} Int Int.instLEInt b z)) (Hinh : Exists.{1} Int (fun (z : Int) => Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s)), Eq.{1} Int (InfSet.infₛ.{0} Int (ConditionallyCompleteLattice.toInfSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) s) (Subtype.val.{1} Int (fun (lb : Int) => And (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) lb s) (forall (z : Int), (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s) -> (LE.le.{0} Int Int.instLEInt lb z))) (Int.leastOfBdd (fun (z : Int) => Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s) (fun (a : Int) => _inst_1 a) b Hb Hinh))
-Case conversion may be inaccurate. Consider using '#align int.cInf_eq_least_of_bdd Int.cinfₛ_eq_least_of_bddₓ'. -/
-theorem cinfₛ_eq_least_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : ℤ) (Hb : ∀ z ∈ s, b ≤ z)
-    (Hinh : ∃ z : ℤ, z ∈ s) : infₛ s = leastOfBdd b Hb Hinh :=
+  forall {s : Set.{0} Int} [_inst_1 : DecidablePred.{1} Int (fun (_x : Int) => Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) _x s)] (b : Int) (Hb : forall (z : Int), (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s) -> (LE.le.{0} Int Int.instLEInt b z)) (Hinh : Exists.{1} Int (fun (z : Int) => Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s)), Eq.{1} Int (InfSet.sInf.{0} Int (ConditionallyCompleteLattice.toInfSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) s) (Subtype.val.{1} Int (fun (lb : Int) => And (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) lb s) (forall (z : Int), (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s) -> (LE.le.{0} Int Int.instLEInt lb z))) (Int.leastOfBdd (fun (z : Int) => Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) z s) (fun (a : Int) => _inst_1 a) b Hb Hinh))
+Case conversion may be inaccurate. Consider using '#align int.cInf_eq_least_of_bdd Int.csInf_eq_least_of_bddₓ'. -/
+theorem csInf_eq_least_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : ℤ) (Hb : ∀ z ∈ s, b ≤ z)
+    (Hinh : ∃ z : ℤ, z ∈ s) : sInf s = leastOfBdd b Hb Hinh :=
   by
   convert dif_pos _ using 1
   · convert coe_least_of_bdd_eq _ (Classical.choose_spec (⟨b, Hb⟩ : BddBelow s)) _
   · exact ⟨Hinh, b, Hb⟩
-#align int.cInf_eq_least_of_bdd Int.cinfₛ_eq_least_of_bdd
+#align int.cInf_eq_least_of_bdd Int.csInf_eq_least_of_bdd
 
-/- warning: int.cInf_empty -> Int.cinfₛ_empty is a dubious translation:
+/- warning: int.cInf_empty -> Int.csInf_empty is a dubious translation:
 lean 3 declaration is
-  Eq.{1} Int (InfSet.infₛ.{0} Int (ConditionallyCompleteLattice.toHasInf.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) (EmptyCollection.emptyCollection.{0} (Set.{0} Int) (Set.hasEmptyc.{0} Int))) (OfNat.ofNat.{0} Int 0 (OfNat.mk.{0} Int 0 (Zero.zero.{0} Int Int.hasZero)))
+  Eq.{1} Int (InfSet.sInf.{0} Int (ConditionallyCompleteLattice.toHasInf.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) (EmptyCollection.emptyCollection.{0} (Set.{0} Int) (Set.hasEmptyc.{0} Int))) (OfNat.ofNat.{0} Int 0 (OfNat.mk.{0} Int 0 (Zero.zero.{0} Int Int.hasZero)))
 but is expected to have type
-  Eq.{1} Int (InfSet.infₛ.{0} Int (ConditionallyCompleteLattice.toInfSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) (EmptyCollection.emptyCollection.{0} (Set.{0} Int) (Set.instEmptyCollectionSet.{0} Int))) (OfNat.ofNat.{0} Int 0 (instOfNatInt 0))
-Case conversion may be inaccurate. Consider using '#align int.cInf_empty Int.cinfₛ_emptyₓ'. -/
+  Eq.{1} Int (InfSet.sInf.{0} Int (ConditionallyCompleteLattice.toInfSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) (EmptyCollection.emptyCollection.{0} (Set.{0} Int) (Set.instEmptyCollectionSet.{0} Int))) (OfNat.ofNat.{0} Int 0 (instOfNatInt 0))
+Case conversion may be inaccurate. Consider using '#align int.cInf_empty Int.csInf_emptyₓ'. -/
 @[simp]
-theorem cinfₛ_empty : infₛ (∅ : Set ℤ) = 0 :=
+theorem csInf_empty : sInf (∅ : Set ℤ) = 0 :=
   dif_neg (by simp)
-#align int.cInf_empty Int.cinfₛ_empty
+#align int.cInf_empty Int.csInf_empty
 
-/- warning: int.cInf_of_not_bdd_below -> Int.cinfₛ_of_not_bdd_below is a dubious translation:
+/- warning: int.cInf_of_not_bdd_below -> Int.csInf_of_not_bdd_below is a dubious translation:
 lean 3 declaration is
-  forall {s : Set.{0} Int}, (Not (BddBelow.{0} Int (PartialOrder.toPreorder.{0} Int (OrderedAddCommGroup.toPartialOrder.{0} Int (StrictOrderedRing.toOrderedAddCommGroup.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing))))) s)) -> (Eq.{1} Int (InfSet.infₛ.{0} Int (ConditionallyCompleteLattice.toHasInf.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) s) (OfNat.ofNat.{0} Int 0 (OfNat.mk.{0} Int 0 (Zero.zero.{0} Int Int.hasZero))))
+  forall {s : Set.{0} Int}, (Not (BddBelow.{0} Int (PartialOrder.toPreorder.{0} Int (OrderedAddCommGroup.toPartialOrder.{0} Int (StrictOrderedRing.toOrderedAddCommGroup.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing))))) s)) -> (Eq.{1} Int (InfSet.sInf.{0} Int (ConditionallyCompleteLattice.toHasInf.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) s) (OfNat.ofNat.{0} Int 0 (OfNat.mk.{0} Int 0 (Zero.zero.{0} Int Int.hasZero))))
 but is expected to have type
-  forall {s : Set.{0} Int}, (Not (BddBelow.{0} Int (PartialOrder.toPreorder.{0} Int (StrictOrderedRing.toPartialOrder.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing)))) s)) -> (Eq.{1} Int (InfSet.infₛ.{0} Int (ConditionallyCompleteLattice.toInfSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) s) (OfNat.ofNat.{0} Int 0 (instOfNatInt 0)))
-Case conversion may be inaccurate. Consider using '#align int.cInf_of_not_bdd_below Int.cinfₛ_of_not_bdd_belowₓ'. -/
-theorem cinfₛ_of_not_bdd_below {s : Set ℤ} (h : ¬BddBelow s) : infₛ s = 0 :=
+  forall {s : Set.{0} Int}, (Not (BddBelow.{0} Int (PartialOrder.toPreorder.{0} Int (StrictOrderedRing.toPartialOrder.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing)))) s)) -> (Eq.{1} Int (InfSet.sInf.{0} Int (ConditionallyCompleteLattice.toInfSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) s) (OfNat.ofNat.{0} Int 0 (instOfNatInt 0)))
+Case conversion may be inaccurate. Consider using '#align int.cInf_of_not_bdd_below Int.csInf_of_not_bdd_belowₓ'. -/
+theorem csInf_of_not_bdd_below {s : Set ℤ} (h : ¬BddBelow s) : sInf s = 0 :=
   dif_neg (by simp [h])
-#align int.cInf_of_not_bdd_below Int.cinfₛ_of_not_bdd_below
+#align int.cInf_of_not_bdd_below Int.csInf_of_not_bdd_below
 
-/- warning: int.cSup_mem -> Int.csupₛ_mem is a dubious translation:
+/- warning: int.cSup_mem -> Int.csSup_mem is a dubious translation:
 lean 3 declaration is
-  forall {s : Set.{0} Int}, (Set.Nonempty.{0} Int s) -> (BddAbove.{0} Int (PartialOrder.toPreorder.{0} Int (OrderedAddCommGroup.toPartialOrder.{0} Int (StrictOrderedRing.toOrderedAddCommGroup.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing))))) s) -> (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) (SupSet.supₛ.{0} Int (ConditionallyCompleteLattice.toHasSup.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) s) s)
+  forall {s : Set.{0} Int}, (Set.Nonempty.{0} Int s) -> (BddAbove.{0} Int (PartialOrder.toPreorder.{0} Int (OrderedAddCommGroup.toPartialOrder.{0} Int (StrictOrderedRing.toOrderedAddCommGroup.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing))))) s) -> (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) (SupSet.sSup.{0} Int (ConditionallyCompleteLattice.toHasSup.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) s) s)
 but is expected to have type
-  forall {s : Set.{0} Int}, (Set.Nonempty.{0} Int s) -> (BddAbove.{0} Int (PartialOrder.toPreorder.{0} Int (StrictOrderedRing.toPartialOrder.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing)))) s) -> (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) (SupSet.supₛ.{0} Int (ConditionallyCompleteLattice.toSupSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) s) s)
-Case conversion may be inaccurate. Consider using '#align int.cSup_mem Int.csupₛ_memₓ'. -/
-theorem csupₛ_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddAbove s) : supₛ s ∈ s :=
+  forall {s : Set.{0} Int}, (Set.Nonempty.{0} Int s) -> (BddAbove.{0} Int (PartialOrder.toPreorder.{0} Int (StrictOrderedRing.toPartialOrder.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing)))) s) -> (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) (SupSet.sSup.{0} Int (ConditionallyCompleteLattice.toSupSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) s) s)
+Case conversion may be inaccurate. Consider using '#align int.cSup_mem Int.csSup_memₓ'. -/
+theorem csSup_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddAbove s) : sSup s ∈ s :=
   by
   convert(greatest_of_bdd _ (Classical.choose_spec h2) h1).2.1
   exact dif_pos ⟨h1, h2⟩
-#align int.cSup_mem Int.csupₛ_mem
+#align int.cSup_mem Int.csSup_mem
 
-/- warning: int.cInf_mem -> Int.cinfₛ_mem is a dubious translation:
+/- warning: int.cInf_mem -> Int.csInf_mem is a dubious translation:
 lean 3 declaration is
-  forall {s : Set.{0} Int}, (Set.Nonempty.{0} Int s) -> (BddBelow.{0} Int (PartialOrder.toPreorder.{0} Int (OrderedAddCommGroup.toPartialOrder.{0} Int (StrictOrderedRing.toOrderedAddCommGroup.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing))))) s) -> (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) (InfSet.infₛ.{0} Int (ConditionallyCompleteLattice.toHasInf.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) s) s)
+  forall {s : Set.{0} Int}, (Set.Nonempty.{0} Int s) -> (BddBelow.{0} Int (PartialOrder.toPreorder.{0} Int (OrderedAddCommGroup.toPartialOrder.{0} Int (StrictOrderedRing.toOrderedAddCommGroup.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing))))) s) -> (Membership.Mem.{0, 0} Int (Set.{0} Int) (Set.hasMem.{0} Int) (InfSet.sInf.{0} Int (ConditionallyCompleteLattice.toHasInf.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int Int.conditionallyCompleteLinearOrder)) s) s)
 but is expected to have type
-  forall {s : Set.{0} Int}, (Set.Nonempty.{0} Int s) -> (BddBelow.{0} Int (PartialOrder.toPreorder.{0} Int (StrictOrderedRing.toPartialOrder.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing)))) s) -> (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) (InfSet.infₛ.{0} Int (ConditionallyCompleteLattice.toInfSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) s) s)
-Case conversion may be inaccurate. Consider using '#align int.cInf_mem Int.cinfₛ_memₓ'. -/
-theorem cinfₛ_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddBelow s) : infₛ s ∈ s :=
+  forall {s : Set.{0} Int}, (Set.Nonempty.{0} Int s) -> (BddBelow.{0} Int (PartialOrder.toPreorder.{0} Int (StrictOrderedRing.toPartialOrder.{0} Int (LinearOrderedRing.toStrictOrderedRing.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing)))) s) -> (Membership.mem.{0, 0} Int (Set.{0} Int) (Set.instMembershipSet.{0} Int) (InfSet.sInf.{0} Int (ConditionallyCompleteLattice.toInfSet.{0} Int (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Int instConditionallyCompleteLinearOrderInt)) s) s)
+Case conversion may be inaccurate. Consider using '#align int.cInf_mem Int.csInf_memₓ'. -/
+theorem csInf_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddBelow s) : sInf s ∈ s :=
   by
   convert(least_of_bdd _ (Classical.choose_spec h2) h1).2.1
   exact dif_pos ⟨h1, h2⟩
-#align int.cInf_mem Int.cinfₛ_mem
+#align int.cInf_mem Int.csInf_mem
 
 end Int

c3291da4

bump to nightly-2023-03-17-00

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

c85864d4

Diff

@@ -139,7 +139,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align int.cSup_mem Int.csupₛ_memₓ'. -/
 theorem csupₛ_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddAbove s) : supₛ s ∈ s :=
   by
-  convert (greatest_of_bdd _ (Classical.choose_spec h2) h1).2.1
+  convert(greatest_of_bdd _ (Classical.choose_spec h2) h1).2.1
   exact dif_pos ⟨h1, h2⟩
 #align int.cSup_mem Int.csupₛ_mem
 
@@ -151,7 +151,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align int.cInf_mem Int.cinfₛ_memₓ'. -/
 theorem cinfₛ_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddBelow s) : infₛ s ∈ s :=
   by
-  convert (least_of_bdd _ (Classical.choose_spec h2) h1).2.1
+  convert(least_of_bdd _ (Classical.choose_spec h2) h1).2.1
   exact dif_pos ⟨h1, h2⟩
 #align int.cInf_mem Int.cinfₛ_mem

c3291da4

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

1e05171a

chore: Rename Int and Rat instances (#12235)

Fix a few names and deduplicate the AddCommGroup ℤ instance

de6ffbc2

Diff

@@ -21,43 +21,39 @@ open Int
 noncomputable section
 open scoped Classical
 
-instance : ConditionallyCompleteLinearOrder ℤ :=
-  { Int.linearOrderedCommRing,
-    LinearOrder.toLattice with
-    sSup := fun s =>
-      if h : s.Nonempty ∧ BddAbove s then
-        greatestOfBdd (Classical.choose h.2) (Classical.choose_spec h.2) h.1
-      else 0
-    sInf := fun s =>
-      if h : s.Nonempty ∧ BddBelow s then
-        leastOfBdd (Classical.choose h.2) (Classical.choose_spec h.2) h.1
-      else 0
-    le_csSup := by
-      intro s n hs hns
-      have : s.Nonempty ∧ BddAbove s := ⟨⟨n, hns⟩, hs⟩
-      -- Porting note: this was `rw [dif_pos this]`
-      simp only [this, and_self, dite_true, ge_iff_le]
-      exact (greatestOfBdd _ _ _).2.2 n hns
-    csSup_le := by
-      intro s n hs hns
-      have : s.Nonempty ∧ BddAbove s := ⟨hs, ⟨n, hns⟩⟩
-      -- Porting note: this was `rw [dif_pos this]`
-      simp only [this, and_self, dite_true, ge_iff_le]
-      exact hns (greatestOfBdd _ (Classical.choose_spec this.2) _).2.1
-    csInf_le := by
-      intro s n hs hns
-      have : s.Nonempty ∧ BddBelow s := ⟨⟨n, hns⟩, hs⟩
-      -- Porting note: this was `rw [dif_pos this]`
-      simp only [this, and_self, dite_true, ge_iff_le]
-      exact (leastOfBdd _ _ _).2.2 n hns
-    le_csInf := by
-      intro s n hs hns
-      have : s.Nonempty ∧ BddBelow s := ⟨hs, ⟨n, hns⟩⟩
-      -- Porting note: this was `rw [dif_pos this]`
-      simp only [this, and_self, dite_true, ge_iff_le]
-      exact hns (leastOfBdd _ (Classical.choose_spec this.2) _).2.1
-    csSup_of_not_bddAbove := fun s hs ↦ by simp [hs]
-    csInf_of_not_bddBelow := fun s hs ↦ by simp [hs] }
+instance instConditionallyCompleteLinearOrder : ConditionallyCompleteLinearOrder ℤ where
+  __ := instLinearOrder
+  __ := LinearOrder.toLattice
+  sSup s :=
+    if h : s.Nonempty ∧ BddAbove s then
+      greatestOfBdd (Classical.choose h.2) (Classical.choose_spec h.2) h.1
+    else 0
+  sInf s :=
+    if h : s.Nonempty ∧ BddBelow s then
+      leastOfBdd (Classical.choose h.2) (Classical.choose_spec h.2) h.1
+    else 0
+  le_csSup s n hs hns := by
+    have : s.Nonempty ∧ BddAbove s := ⟨⟨n, hns⟩, hs⟩
+    -- Porting note: this was `rw [dif_pos this]`
+    simp only [this, and_self, dite_true, ge_iff_le]
+    exact (greatestOfBdd _ _ _).2.2 n hns
+  csSup_le s n hs hns := by
+    have : s.Nonempty ∧ BddAbove s := ⟨hs, ⟨n, hns⟩⟩
+    -- Porting note: this was `rw [dif_pos this]`
+    simp only [this, and_self, dite_true, ge_iff_le]
+    exact hns (greatestOfBdd _ (Classical.choose_spec this.2) _).2.1
+  csInf_le s n hs hns := by
+    have : s.Nonempty ∧ BddBelow s := ⟨⟨n, hns⟩, hs⟩
+    -- Porting note: this was `rw [dif_pos this]`
+    simp only [this, and_self, dite_true, ge_iff_le]
+    exact (leastOfBdd _ _ _).2.2 n hns
+  le_csInf s n hs hns := by
+    have : s.Nonempty ∧ BddBelow s := ⟨hs, ⟨n, hns⟩⟩
+    -- Porting note: this was `rw [dif_pos this]`
+    simp only [this, and_self, dite_true, ge_iff_le]
+    exact hns (leastOfBdd _ (Classical.choose_spec this.2) _).2.1
+  csSup_of_not_bddAbove := fun s hs ↦ by simp [hs]
+  csInf_of_not_bddBelow := fun s hs ↦ by simp [hs]
 
 namespace Int

1e05171a

chore: scope open Classical (#11199)

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.

c747be0a

Diff

@@ -19,7 +19,7 @@ open Int
 
 
 noncomputable section
-open Classical
+open scoped Classical
 
 instance : ConditionallyCompleteLinearOrder ℤ :=
   { Int.linearOrderedCommRing,

1e05171a

Add Lattice ℤ instance for computability (#9946)

The file Data.Int.ConditionallyCompleteOrder defines a noncomputable instance of ConditionallyCompleteLinearOrder on ℤ.

This noncomputable instance is picked up by the typeclass search when looking for a Lattice instance on ℤ, making, for instance, abs noncomputable on ℤ.

This PR restores the computability of Lattice ℤ.

Zulip discussion

e61934e2

Diff

@@ -17,9 +17,9 @@ The integers form a conditionally complete linear order.
 
 open Int
 
-open Classical
 
 noncomputable section
+open Classical
 
 instance : ConditionallyCompleteLinearOrder ℤ :=
   { Int.linearOrderedCommRing,
@@ -106,3 +106,9 @@ theorem csInf_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddBelow s) : sInf s ∈
 #align int.cInf_mem Int.csInf_mem
 
 end Int
+
+end
+
+--  this example tests that the `Lattice ℤ` instance is computable;
+-- i.e., that is is not found via the noncomputable instance in this file.
+example : Lattice ℤ := inferInstance

1e05171a

feat: use junk value in the definition of conditionally complete linear order (#6571)

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.

d1cd996f

Diff

@@ -55,7 +55,9 @@ instance : ConditionallyCompleteLinearOrder ℤ :=
       have : s.Nonempty ∧ BddBelow s := ⟨hs, ⟨n, hns⟩⟩
       -- Porting note: this was `rw [dif_pos this]`
       simp only [this, and_self, dite_true, ge_iff_le]
-      exact hns (leastOfBdd _ (Classical.choose_spec this.2) _).2.1 }
+      exact hns (leastOfBdd _ (Classical.choose_spec this.2) _).2.1
+    csSup_of_not_bddAbove := fun s hs ↦ by simp [hs]
+    csInf_of_not_bddBelow := fun s hs ↦ by simp [hs] }
 
 namespace Int

1e05171a

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

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

89aa3a3b

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2021 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
-
-! This file was ported from Lean 3 source module data.int.conditionally_complete_order
-! leanprover-community/mathlib commit 1e05171a5e8cf18d98d9cf7b207540acb044acae
-! 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.Int.LeastGreatest
 
+#align_import data.int.conditionally_complete_order from "leanprover-community/mathlib"@"1e05171a5e8cf18d98d9cf7b207540acb044acae"
+
 /-!
 ## `ℤ` forms a conditionally complete linear order

1e05171a

chore: Rename to sSup/iSup (#3938)

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>

d1eb6264

Diff

@@ -27,33 +27,33 @@ noncomputable section
 instance : ConditionallyCompleteLinearOrder ℤ :=
   { Int.linearOrderedCommRing,
     LinearOrder.toLattice with
-    supₛ := fun s =>
+    sSup := fun s =>
       if h : s.Nonempty ∧ BddAbove s then
         greatestOfBdd (Classical.choose h.2) (Classical.choose_spec h.2) h.1
       else 0
-    infₛ := fun s =>
+    sInf := fun s =>
       if h : s.Nonempty ∧ BddBelow s then
         leastOfBdd (Classical.choose h.2) (Classical.choose_spec h.2) h.1
       else 0
-    le_csupₛ := by
+    le_csSup := by
       intro s n hs hns
       have : s.Nonempty ∧ BddAbove s := ⟨⟨n, hns⟩, hs⟩
       -- Porting note: this was `rw [dif_pos this]`
       simp only [this, and_self, dite_true, ge_iff_le]
       exact (greatestOfBdd _ _ _).2.2 n hns
-    csupₛ_le := by
+    csSup_le := by
       intro s n hs hns
       have : s.Nonempty ∧ BddAbove s := ⟨hs, ⟨n, hns⟩⟩
       -- Porting note: this was `rw [dif_pos this]`
       simp only [this, and_self, dite_true, ge_iff_le]
       exact hns (greatestOfBdd _ (Classical.choose_spec this.2) _).2.1
-    cinfₛ_le := by
+    csInf_le := by
       intro s n hs hns
       have : s.Nonempty ∧ BddBelow s := ⟨⟨n, hns⟩, hs⟩
       -- Porting note: this was `rw [dif_pos this]`
       simp only [this, and_self, dite_true, ge_iff_le]
       exact (leastOfBdd _ _ _).2.2 n hns
-    le_cinfₛ := by
+    le_csInf := by
       intro s n hs hns
       have : s.Nonempty ∧ BddBelow s := ⟨hs, ⟨n, hns⟩⟩
       -- Porting note: this was `rw [dif_pos this]`
@@ -63,47 +63,47 @@ instance : ConditionallyCompleteLinearOrder ℤ :=
 namespace Int
 
 -- Porting note: mathlib3 proof uses `convert dif_pos _ using 1`
-theorem csupₛ_eq_greatest_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : ℤ) (Hb : ∀ z ∈ s, z ≤ b)
-    (Hinh : ∃ z : ℤ, z ∈ s) : supₛ s = greatestOfBdd b Hb Hinh := by
+theorem csSup_eq_greatest_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : ℤ) (Hb : ∀ z ∈ s, z ≤ b)
+    (Hinh : ∃ z : ℤ, z ∈ s) : sSup s = greatestOfBdd b Hb Hinh := by
   have : s.Nonempty ∧ BddAbove s := ⟨Hinh, b, Hb⟩
-  simp only [supₛ, this, and_self, dite_true]
+  simp only [sSup, this, and_self, dite_true]
   convert (coe_greatestOfBdd_eq Hb (Classical.choose_spec (⟨b, Hb⟩ : BddAbove s)) Hinh).symm
-#align int.cSup_eq_greatest_of_bdd Int.csupₛ_eq_greatest_of_bdd
+#align int.cSup_eq_greatest_of_bdd Int.csSup_eq_greatest_of_bdd
 
 @[simp]
-theorem csupₛ_empty : supₛ (∅ : Set ℤ) = 0 :=
+theorem csSup_empty : sSup (∅ : Set ℤ) = 0 :=
   dif_neg (by simp)
-#align int.cSup_empty Int.csupₛ_empty
+#align int.cSup_empty Int.csSup_empty
 
-theorem csupₛ_of_not_bdd_above {s : Set ℤ} (h : ¬BddAbove s) : supₛ s = 0 :=
+theorem csSup_of_not_bdd_above {s : Set ℤ} (h : ¬BddAbove s) : sSup s = 0 :=
   dif_neg (by simp [h])
-#align int.cSup_of_not_bdd_above Int.csupₛ_of_not_bdd_above
+#align int.cSup_of_not_bdd_above Int.csSup_of_not_bdd_above
 
 -- Porting note: mathlib3 proof uses `convert dif_pos _ using 1`
-theorem cinfₛ_eq_least_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : ℤ) (Hb : ∀ z ∈ s, b ≤ z)
-    (Hinh : ∃ z : ℤ, z ∈ s) : infₛ s = leastOfBdd b Hb Hinh := by
+theorem csInf_eq_least_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : ℤ) (Hb : ∀ z ∈ s, b ≤ z)
+    (Hinh : ∃ z : ℤ, z ∈ s) : sInf s = leastOfBdd b Hb Hinh := by
   have : s.Nonempty ∧ BddBelow s := ⟨Hinh, b, Hb⟩
-  simp only [infₛ, this, and_self, dite_true]
+  simp only [sInf, this, and_self, dite_true]
   convert (coe_leastOfBdd_eq Hb (Classical.choose_spec (⟨b, Hb⟩ : BddBelow s)) Hinh).symm
-#align int.cInf_eq_least_of_bdd Int.cinfₛ_eq_least_of_bdd
+#align int.cInf_eq_least_of_bdd Int.csInf_eq_least_of_bdd
 
 @[simp]
-theorem cinfₛ_empty : infₛ (∅ : Set ℤ) = 0 :=
+theorem csInf_empty : sInf (∅ : Set ℤ) = 0 :=
   dif_neg (by simp)
-#align int.cInf_empty Int.cinfₛ_empty
+#align int.cInf_empty Int.csInf_empty
 
-theorem cinfₛ_of_not_bdd_below {s : Set ℤ} (h : ¬BddBelow s) : infₛ s = 0 :=
+theorem csInf_of_not_bdd_below {s : Set ℤ} (h : ¬BddBelow s) : sInf s = 0 :=
   dif_neg (by simp [h])
-#align int.cInf_of_not_bdd_below Int.cinfₛ_of_not_bdd_below
+#align int.cInf_of_not_bdd_below Int.csInf_of_not_bdd_below
 
-theorem csupₛ_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddAbove s) : supₛ s ∈ s := by
+theorem csSup_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddAbove s) : sSup s ∈ s := by
   convert (greatestOfBdd _ (Classical.choose_spec h2) h1).2.1
   exact dif_pos ⟨h1, h2⟩
-#align int.cSup_mem Int.csupₛ_mem
+#align int.cSup_mem Int.csSup_mem
 
-theorem cinfₛ_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddBelow s) : infₛ s ∈ s := by
+theorem csInf_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddBelow s) : sInf s ∈ s := by
   convert (leastOfBdd _ (Classical.choose_spec h2) h1).2.1
   exact dif_pos ⟨h1, h2⟩
-#align int.cInf_mem Int.cinfₛ_mem
+#align int.cInf_mem Int.csInf_mem
 
 end Int

1e05171a

feat: tactic congr! and improvement to convert (#2566)

This introduces a tactic congr! that is an analogue to mathlib 3's congr'. It is a more insistent version of congr that makes use of more congruence lemmas (including user congruence lemmas), propext, funext, and Subsingleton instances. It also has a feature to lift reflexive relations to equalities. Along with funext, the tactic does intros, allowing congr! to get access to function bodies; the introduced variables can be named using rename_i if needed.

This also modifies convert to use congr! rather than congr, which makes it work more like the mathlib3 version of the tactic.

b46c2e36

Diff

@@ -68,7 +68,6 @@ theorem csupₛ_eq_greatest_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b :
   have : s.Nonempty ∧ BddAbove s := ⟨Hinh, b, Hb⟩
   simp only [supₛ, this, and_self, dite_true]
   convert (coe_greatestOfBdd_eq Hb (Classical.choose_spec (⟨b, Hb⟩ : BddAbove s)) Hinh).symm
-  simp
 #align int.cSup_eq_greatest_of_bdd Int.csupₛ_eq_greatest_of_bdd
 
 @[simp]
@@ -86,7 +85,6 @@ theorem cinfₛ_eq_least_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : 
   have : s.Nonempty ∧ BddBelow s := ⟨Hinh, b, Hb⟩
   simp only [infₛ, this, and_self, dite_true]
   convert (coe_leastOfBdd_eq Hb (Classical.choose_spec (⟨b, Hb⟩ : BddBelow s)) Hinh).symm
-  simp
 #align int.cInf_eq_least_of_bdd Int.cinfₛ_eq_least_of_bdd
 
 @[simp]

1e05171a

chore: format by line breaks (#1523)

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

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

I noticed there are some more files that slipped through.

This pull request is the result of running this command:

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

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

d6d859a7

Diff

@@ -98,14 +98,12 @@ theorem cinfₛ_of_not_bdd_below {s : Set ℤ} (h : ¬BddBelow s) : infₛ s = 0
   dif_neg (by simp [h])
 #align int.cInf_of_not_bdd_below Int.cinfₛ_of_not_bdd_below
 
-theorem csupₛ_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddAbove s) : supₛ s ∈ s :=
-  by
+theorem csupₛ_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddAbove s) : supₛ s ∈ s := by
   convert (greatestOfBdd _ (Classical.choose_spec h2) h1).2.1
   exact dif_pos ⟨h1, h2⟩
 #align int.cSup_mem Int.csupₛ_mem
 
-theorem cinfₛ_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddBelow s) : infₛ s ∈ s :=
-  by
+theorem cinfₛ_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddBelow s) : infₛ s ∈ s := by
   convert (leastOfBdd _ (Classical.choose_spec h2) h1).2.1
   exact dif_pos ⟨h1, h2⟩
 #align int.cInf_mem Int.cinfₛ_mem

1e05171a

feat: port Data.Int.ConditionallyCompleteOrder (#1299)

625deea9

`data.int.conditionally_complete_order` ⟷ `Mathlib.Data.Int.ConditionallyCompleteOrder`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Renames

Dependencies 2 + 99

data.int.conditionally_complete_order ⟷ Mathlib.Data.Int.ConditionallyCompleteOrder

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Renames

Dependencies 2 + 99

`data.int.conditionally_complete_order` ⟷ `Mathlib.Data.Int.ConditionallyCompleteOrder`