data.int.conditionally_complete_orderMathlib.Data.Int.ConditionallyCompleteOrder

This file has been ported!

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

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(last sync)

Changes in mathlib3port

mathlib3
mathlib3port
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"
 
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
 
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
 
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
 
Diff
@@ -23,7 +23,7 @@ The integers form a conditionally complete linear order.
 
 open Int
 
-open Classical
+open scoped Classical
 
 noncomputable section
 
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
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
 
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
 

Changes in mathlib4

mathlib3
mathlib4
chore: Rename Int and Rat instances (#12235)

Fix a few names and deduplicate the AddCommGroup ℤ instance

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
 
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.

Diff
@@ -19,7 +19,7 @@ open Int
 
 
 noncomputable section
-open Classical
+open scoped Classical
 
 instance : ConditionallyCompleteLinearOrder ℤ :=
   { Int.linearOrderedCommRing,
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

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
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.

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
 
chore: script to replace headers with #align_import statements (#5979)

Open in Gitpod

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

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
 
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>

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
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.

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]
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>

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
feat: port Data.Int.ConditionallyCompleteOrder (#1299)

Dependencies 2 + 99

100 files ported (98.0%)
50096 lines ported (99.7%)
Show graph

The unported dependencies are