order.ideal ⟷ Mathlib.Order.Ideal

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

@@ -449,8 +449,8 @@ instance : Sup (Ideal P) :=
           le_sup_left, le_sup_right⟩
       lower' := fun x y h ⟨yi, _, yj, _, _⟩ => ⟨yi, ‹_›, yj, ‹_›, h.trans ‹_›⟩ }⟩
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (i «expr ∈ » I) -/
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (j «expr ∈ » J) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (i «expr ∈ » I) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (j «expr ∈ » J) -/
 instance : Lattice (Ideal P) :=
   { Ideal.partialOrder with
     sup := (· ⊔ ·)

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

@@ -195,8 +195,8 @@ class IsProper (I : Ideal P) : Prop where
 #print Order.Ideal.isProper_of_not_mem /-
 theorem isProper_of_not_mem {I : Ideal P} {p : P} (nmem : p ∉ I) : IsProper I :=
   ⟨fun hp => by
-    change p ∉ ↑I at nmem 
-    rw [hp] at nmem 
+    change p ∉ ↑I at nmem
+    rw [hp] at nmem
     exact nmem (mem_univ p)⟩
 #align order.ideal.is_proper_of_not_mem Order.Ideal.isProper_of_not_mem
 -/
@@ -580,7 +580,7 @@ theorem IsProper.not_mem_of_compl_mem (hI : IsProper I) (hxc : xᶜ ∈ I) : x 
   intro hx
   apply hI.top_not_mem
   have ht : x ⊔ xᶜ ∈ I := sup_mem ‹_› ‹_›
-  rwa [sup_compl_eq_top] at ht 
+  rwa [sup_compl_eq_top] at ht
 #align order.ideal.is_proper.not_mem_of_compl_mem Order.Ideal.IsProper.not_mem_of_compl_mem
 -/
 

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

@@ -3,9 +3,9 @@ Copyright (c) 2020 David Wärn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: David Wärn
 -/
-import Mathbin.Logic.Encodable.Basic
-import Mathbin.Order.Atoms
-import Mathbin.Order.UpperLower.Basic
+import Logic.Encodable.Basic
+import Order.Atoms
+import Order.UpperLower.Basic
 
 #align_import order.ideal from "leanprover-community/mathlib"@"0ebfdb71919ac6ca5d7fbc61a082fa2519556818"
 
@@ -449,8 +449,8 @@ instance : Sup (Ideal P) :=
           le_sup_left, le_sup_right⟩
       lower' := fun x y h ⟨yi, _, yj, _, _⟩ => ⟨yi, ‹_›, yj, ‹_›, h.trans ‹_›⟩ }⟩
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (i «expr ∈ » I) -/
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (j «expr ∈ » J) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (i «expr ∈ » I) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (j «expr ∈ » J) -/
 instance : Lattice (Ideal P) :=
   { Ideal.partialOrder with
     sup := (· ⊔ ·)

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

@@ -2,16 +2,13 @@
 Copyright (c) 2020 David Wärn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: David Wärn
-
-! This file was ported from Lean 3 source module order.ideal
-! leanprover-community/mathlib commit 0ebfdb71919ac6ca5d7fbc61a082fa2519556818
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Logic.Encodable.Basic
 import Mathbin.Order.Atoms
 import Mathbin.Order.UpperLower.Basic
 
+#align_import order.ideal from "leanprover-community/mathlib"@"0ebfdb71919ac6ca5d7fbc61a082fa2519556818"
+
 /-!
 # Order ideals, cofinal sets, and the Rasiowa–Sikorski lemma
 
@@ -452,8 +449,8 @@ instance : Sup (Ideal P) :=
           le_sup_left, le_sup_right⟩
       lower' := fun x y h ⟨yi, _, yj, _, _⟩ => ⟨yi, ‹_›, yj, ‹_›, h.trans ‹_›⟩ }⟩
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (i «expr ∈ » I) -/
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (j «expr ∈ » J) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (i «expr ∈ » I) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (j «expr ∈ » J) -/
 instance : Lattice (Ideal P) :=
   { Ideal.partialOrder with
     sup := (· ⊔ ·)

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

@@ -155,28 +155,36 @@ protected theorem isIdeal (s : Ideal P) : IsIdeal (s : Set P) :=
 #align order.ideal.is_ideal Order.Ideal.isIdeal
 -/
 
+#print Order.Ideal.mem_compl_of_ge /-
 theorem mem_compl_of_ge {x y : P} : x ≤ y → x ∈ (I : Set P)ᶜ → y ∈ (I : Set P)ᶜ := fun h =>
   mt <| I.lower h
 #align order.ideal.mem_compl_of_ge Order.Ideal.mem_compl_of_ge
+-/
 
 /-- The partial ordering by subset inclusion, inherited from `set P`. -/
 instance : PartialOrder (Ideal P) :=
   PartialOrder.lift coe SetLike.coe_injective
 
+#print Order.Ideal.coe_subset_coe /-
 @[simp]
 theorem coe_subset_coe : (s : Set P) ⊆ t ↔ s ≤ t :=
   Iff.rfl
 #align order.ideal.coe_subset_coe Order.Ideal.coe_subset_coe
+-/
 
+#print Order.Ideal.coe_ssubset_coe /-
 @[simp]
 theorem coe_ssubset_coe : (s : Set P) ⊂ t ↔ s < t :=
   Iff.rfl
 #align order.ideal.coe_ssubset_coe Order.Ideal.coe_ssubset_coe
+-/
 
+#print Order.Ideal.mem_of_mem_of_le /-
 @[trans]
 theorem mem_of_mem_of_le {x : P} {I J : Ideal P} : x ∈ I → I ≤ J → x ∈ J :=
   @Set.mem_of_mem_of_subset P x I J
 #align order.ideal.mem_of_mem_of_le Order.Ideal.mem_of_mem_of_le
+-/
 
 #print Order.Ideal.IsProper /-
 /-- A proper ideal is one that is not the whole set.
@@ -207,6 +215,7 @@ class IsMaximal (I : Ideal P) extends IsProper I : Prop where
 #align order.ideal.is_maximal Order.Ideal.IsMaximal
 -/
 
+#print Order.Ideal.inter_nonempty /-
 theorem inter_nonempty [IsDirected P (· ≥ ·)] (I J : Ideal P) : (I ∩ J : Set P).Nonempty :=
   by
   obtain ⟨a, ha⟩ := I.nonempty
@@ -214,6 +223,7 @@ theorem inter_nonempty [IsDirected P (· ≥ ·)] (I J : Ideal P) : (I ∩ J : S
   obtain ⟨c, hac, hbc⟩ := exists_le_le a b
   exact ⟨c, I.lower hac ha, J.lower hbc hb⟩
 #align order.ideal.inter_nonempty Order.Ideal.inter_nonempty
+-/
 
 end
 
@@ -227,46 +237,66 @@ instance : OrderTop (Ideal P)
   top := ⟨⊤, univ_nonempty, directedOn_univ⟩
   le_top I := le_top
 
+#print Order.Ideal.top_toLowerSet /-
 @[simp]
 theorem top_toLowerSet : (⊤ : Ideal P).toLowerSet = ⊤ :=
   rfl
 #align order.ideal.top_to_lower_set Order.Ideal.top_toLowerSet
+-/
 
+#print Order.Ideal.coe_top /-
 @[simp]
 theorem coe_top : ((⊤ : Ideal P) : Set P) = univ :=
   rfl
 #align order.ideal.coe_top Order.Ideal.coe_top
+-/
 
+#print Order.Ideal.isProper_of_ne_top /-
 theorem isProper_of_ne_top (ne_top : I ≠ ⊤) : IsProper I :=
   ⟨fun h => ne_top <| ext h⟩
 #align order.ideal.is_proper_of_ne_top Order.Ideal.isProper_of_ne_top
+-/
 
+#print Order.Ideal.IsProper.ne_top /-
 theorem IsProper.ne_top (hI : IsProper I) : I ≠ ⊤ := fun h => IsProper.ne_univ <| congr_arg coe h
 #align order.ideal.is_proper.ne_top Order.Ideal.IsProper.ne_top
+-/
 
+#print IsCoatom.isProper /-
 theorem IsCoatom.isProper (hI : IsCoatom I) : IsProper I :=
   isProper_of_ne_top hI.1
 #align is_coatom.is_proper IsCoatom.isProper
+-/
 
+#print Order.Ideal.isProper_iff_ne_top /-
 theorem isProper_iff_ne_top : IsProper I ↔ I ≠ ⊤ :=
   ⟨fun h => h.ne_top, fun h => isProper_of_ne_top h⟩
 #align order.ideal.is_proper_iff_ne_top Order.Ideal.isProper_iff_ne_top
+-/
 
+#print Order.Ideal.IsMaximal.isCoatom /-
 theorem IsMaximal.isCoatom (h : IsMaximal I) : IsCoatom I :=
   ⟨IsMaximal.to_isProper.ne_top, fun J h => ext <| IsMaximal.maximal_proper h⟩
 #align order.ideal.is_maximal.is_coatom Order.Ideal.IsMaximal.isCoatom
+-/
 
+#print Order.Ideal.IsMaximal.isCoatom' /-
 theorem IsMaximal.isCoatom' [IsMaximal I] : IsCoatom I :=
   IsMaximal.isCoatom ‹_›
 #align order.ideal.is_maximal.is_coatom' Order.Ideal.IsMaximal.isCoatom'
+-/
 
+#print IsCoatom.isMaximal /-
 theorem IsCoatom.isMaximal (hI : IsCoatom I) : IsMaximal I :=
   { IsCoatom.isProper ‹_› with maximal_proper := fun _ _ => by simp [hI.2 _ ‹_›] }
 #align is_coatom.is_maximal IsCoatom.isMaximal
+-/
 
+#print Order.Ideal.isMaximal_iff_isCoatom /-
 theorem isMaximal_iff_isCoatom : IsMaximal I ↔ IsCoatom I :=
   ⟨fun h => h.IsCoatom, fun h => h.IsMaximal⟩
 #align order.ideal.is_maximal_iff_is_coatom Order.Ideal.isMaximal_iff_isCoatom
+-/
 
 end Directed
 
@@ -274,10 +304,12 @@ section OrderBot
 
 variable [OrderBot P]
 
+#print Order.Ideal.bot_mem /-
 @[simp]
 theorem bot_mem (s : Ideal P) : ⊥ ∈ s :=
   s.lower bot_le s.Nonempty.some_mem
 #align order.ideal.bot_mem Order.Ideal.bot_mem
+-/
 
 end OrderBot
 
@@ -285,11 +317,15 @@ section OrderTop
 
 variable [OrderTop P] {I : Ideal P}
 
+#print Order.Ideal.top_of_top_mem /-
 theorem top_of_top_mem (h : ⊤ ∈ I) : I = ⊤ := by ext; exact iff_of_true (I.lower le_top h) trivial
 #align order.ideal.top_of_top_mem Order.Ideal.top_of_top_mem
+-/
 
+#print Order.Ideal.IsProper.top_not_mem /-
 theorem IsProper.top_not_mem (hI : IsProper I) : ⊤ ∉ I := fun h => hI.ne_top <| top_of_top_mem h
 #align order.ideal.is_proper.top_not_mem Order.Ideal.IsProper.top_not_mem
+-/
 
 end OrderTop
 
@@ -316,10 +352,12 @@ def principal (p : P) : Ideal P where
 instance [Inhabited P] : Inhabited (Ideal P) :=
   ⟨Ideal.principal default⟩
 
+#print Order.Ideal.principal_le_iff /-
 @[simp]
 theorem principal_le_iff : principal x ≤ I ↔ x ∈ I :=
   ⟨fun h => h le_rfl, fun hx y hy => I.lower hy hx⟩
 #align order.ideal.principal_le_iff Order.Ideal.principal_le_iff
+-/
 
 #print Order.Ideal.mem_principal /-
 @[simp]
@@ -339,10 +377,12 @@ instance : OrderBot (Ideal P) where
   bot := principal ⊥
   bot_le := by simp
 
+#print Order.Ideal.principal_bot /-
 @[simp]
 theorem principal_bot : principal (⊥ : P) = ⊥ :=
   rfl
 #align order.ideal.principal_bot Order.Ideal.principal_bot
+-/
 
 end OrderBot
 
@@ -350,10 +390,12 @@ section OrderTop
 
 variable [OrderTop P]
 
+#print Order.Ideal.principal_top /-
 @[simp]
 theorem principal_top : principal (⊤ : P) = ⊤ :=
   toLowerSet_injective <| LowerSet.Iic_top
 #align order.ideal.principal_top Order.Ideal.principal_top
+-/
 
 end OrderTop
 
@@ -363,16 +405,20 @@ section SemilatticeSup
 
 variable [SemilatticeSup P] {x y : P} {I s : Ideal P}
 
+#print Order.Ideal.sup_mem /-
 /-- A specific witness of `I.directed` when `P` has joins. -/
 theorem sup_mem (hx : x ∈ s) (hy : y ∈ s) : x ⊔ y ∈ s :=
   let ⟨z, hz, hx, hy⟩ := s.Directed x hx y hy
   s.lower (sup_le hx hy) hz
 #align order.ideal.sup_mem Order.Ideal.sup_mem
+-/
 
+#print Order.Ideal.sup_mem_iff /-
 @[simp]
 theorem sup_mem_iff : x ⊔ y ∈ I ↔ x ∈ I ∧ y ∈ I :=
   ⟨fun h => ⟨I.lower le_sup_left h, I.lower le_sup_right h⟩, fun h => sup_mem h.1 h.2⟩
 #align order.ideal.sup_mem_iff Order.Ideal.sup_mem_iff
+-/
 
 end SemilatticeSup
 
@@ -421,29 +467,39 @@ instance : Lattice (Ideal P) :=
     inf_le_right := fun I J => inter_subset_right I J
     le_inf := fun I J K => subset_inter }
 
+#print Order.Ideal.coe_sup /-
 @[simp]
 theorem coe_sup : ↑(s ⊔ t) = {x | ∃ a ∈ s, ∃ b ∈ t, x ≤ a ⊔ b} :=
   rfl
 #align order.ideal.coe_sup Order.Ideal.coe_sup
+-/
 
+#print Order.Ideal.coe_inf /-
 @[simp]
 theorem coe_inf : (↑(s ⊓ t) : Set P) = s ∩ t :=
   rfl
 #align order.ideal.coe_inf Order.Ideal.coe_inf
+-/
 
+#print Order.Ideal.mem_inf /-
 @[simp]
 theorem mem_inf : x ∈ I ⊓ J ↔ x ∈ I ∧ x ∈ J :=
   Iff.rfl
 #align order.ideal.mem_inf Order.Ideal.mem_inf
+-/
 
+#print Order.Ideal.mem_sup /-
 @[simp]
 theorem mem_sup : x ∈ I ⊔ J ↔ ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j :=
   Iff.rfl
 #align order.ideal.mem_sup Order.Ideal.mem_sup
+-/
 
+#print Order.Ideal.lt_sup_principal_of_not_mem /-
 theorem lt_sup_principal_of_not_mem (hx : x ∉ I) : I < I ⊔ principal x :=
   le_sup_left.lt_of_ne fun h => hx <| by simpa only [left_eq_sup, principal_le_iff] using h
 #align order.ideal.lt_sup_principal_of_not_mem Order.Ideal.lt_sup_principal_of_not_mem
+-/
 
 end SemilatticeSupDirected
 
@@ -466,15 +522,19 @@ instance : InfSet (Ideal P) :=
 
 variable {S : Set (Ideal P)}
 
+#print Order.Ideal.coe_sInf /-
 @[simp]
 theorem coe_sInf : (↑(sInf S) : Set P) = ⋂ s ∈ S, ↑s :=
   LowerSet.coe_iInf₂ _
 #align order.ideal.coe_Inf Order.Ideal.coe_sInf
+-/
 
+#print Order.Ideal.mem_sInf /-
 @[simp]
 theorem mem_sInf : x ∈ sInf S ↔ ∀ s ∈ S, x ∈ s := by
   simp_rw [← SetLike.mem_coe, coe_Inf, mem_Inter₂]
 #align order.ideal.mem_Inf Order.Ideal.mem_sInf
+-/
 
 instance : CompleteLattice (Ideal P) :=
   { Ideal.lattice,
@@ -492,6 +552,7 @@ variable [DistribLattice P]
 
 variable {I J : Ideal P}
 
+#print Order.Ideal.eq_sup_of_le_sup /-
 theorem eq_sup_of_le_sup {x i j : P} (hi : i ∈ I) (hj : j ∈ J) (hx : x ≤ i ⊔ j) :
     ∃ i' ∈ I, ∃ j' ∈ J, x = i' ⊔ j' :=
   by
@@ -500,12 +561,15 @@ theorem eq_sup_of_le_sup {x i j : P} (hi : i ∈ I) (hj : j ∈ J) (hx : x ≤ i
     x = x ⊓ (i ⊔ j) := left_eq_inf.mpr hx
     _ = x ⊓ i ⊔ x ⊓ j := inf_sup_left
 #align order.ideal.eq_sup_of_le_sup Order.Ideal.eq_sup_of_le_sup
+-/
 
+#print Order.Ideal.coe_sup_eq /-
 theorem coe_sup_eq : ↑(I ⊔ J) = {x | ∃ i ∈ I, ∃ j ∈ J, x = i ⊔ j} :=
   Set.ext fun _ =>
     ⟨fun ⟨_, _, _, _, _⟩ => eq_sup_of_le_sup ‹_› ‹_› ‹_›, fun ⟨i, _, j, _, _⟩ =>
       ⟨i, ‹_›, j, ‹_›, le_of_eq ‹_›⟩⟩
 #align order.ideal.coe_sup_eq Order.Ideal.coe_sup_eq
+-/
 
 end DistribLattice
 
@@ -595,16 +659,20 @@ noncomputable def sequenceOfCofinals : ℕ → P
 #align order.sequence_of_cofinals Order.sequenceOfCofinals
 -/
 
+#print Order.sequenceOfCofinals.monotone /-
 theorem sequenceOfCofinals.monotone : Monotone (sequenceOfCofinals p 𝒟) :=
   by
   apply monotone_nat_of_le_succ; intro n; dsimp only [sequence_of_cofinals]
   cases Encodable.decode ι n; · rfl; · apply cofinal.le_above
 #align order.sequence_of_cofinals.monotone Order.sequenceOfCofinals.monotone
+-/
 
+#print Order.sequenceOfCofinals.encode_mem /-
 theorem sequenceOfCofinals.encode_mem (i : ι) :
     sequenceOfCofinals p 𝒟 (Encodable.encode i + 1) ∈ 𝒟 i := by dsimp only [sequence_of_cofinals];
   rw [Encodable.encodek]; apply cofinal.above_mem
 #align order.sequence_of_cofinals.encode_mem Order.sequenceOfCofinals.encode_mem
+-/
 
 #print Order.idealOfCofinals /-
 /-- Given an element `p : P` and a family `𝒟` of cofinal subsets of a preorder `P`,
@@ -624,14 +692,18 @@ def idealOfCofinals : Ideal P
 #align order.ideal_of_cofinals Order.idealOfCofinals
 -/
 
+#print Order.mem_idealOfCofinals /-
 theorem mem_idealOfCofinals : p ∈ idealOfCofinals p 𝒟 :=
   ⟨0, le_rfl⟩
 #align order.mem_ideal_of_cofinals Order.mem_idealOfCofinals
+-/
 
+#print Order.cofinal_meets_idealOfCofinals /-
 /-- `ideal_of_cofinals p 𝒟` is `𝒟`-generic. -/
 theorem cofinal_meets_idealOfCofinals (i : ι) : ∃ x : P, x ∈ 𝒟 i ∧ x ∈ idealOfCofinals p 𝒟 :=
   ⟨_, sequenceOfCofinals.encode_mem p 𝒟 i, _, le_rfl⟩
 #align order.cofinal_meets_ideal_of_cofinals Order.cofinal_meets_idealOfCofinals
+-/
 
 end IdealOfCofinals
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/7e5137f579de09a059a5ce98f364a04e221aabf0

@@ -399,12 +399,10 @@ instance : Sup (Ideal P) :=
             sup_le
               (calc
                 x ≤ xi ⊔ xj := ‹_›
-                _ ≤ xi ⊔ yi ⊔ (xj ⊔ yj) := sup_le_sup le_sup_left le_sup_left
-                )
+                _ ≤ xi ⊔ yi ⊔ (xj ⊔ yj) := sup_le_sup le_sup_left le_sup_left)
               (calc
                 y ≤ yi ⊔ yj := ‹_›
-                _ ≤ xi ⊔ yi ⊔ (xj ⊔ yj) := sup_le_sup le_sup_right le_sup_right
-                )⟩,
+                _ ≤ xi ⊔ yi ⊔ (xj ⊔ yj) := sup_le_sup le_sup_right le_sup_right)⟩,
           le_sup_left, le_sup_right⟩
       lower' := fun x y h ⟨yi, _, yj, _, _⟩ => ⟨yi, ‹_›, yj, ‹_›, h.trans ‹_›⟩ }⟩
 
@@ -501,7 +499,6 @@ theorem eq_sup_of_le_sup {x i j : P} (hi : i ∈ I) (hj : j ∈ J) (hx : x ≤ i
   calc
     x = x ⊓ (i ⊔ j) := left_eq_inf.mpr hx
     _ = x ⊓ i ⊔ x ⊓ j := inf_sup_left
-    
 #align order.ideal.eq_sup_of_le_sup Order.Ideal.eq_sup_of_le_sup
 
 theorem coe_sup_eq : ↑(I ⊔ J) = {x | ∃ i ∈ I, ∃ j ∈ J, x = i ⊔ j} :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/31c24aa72e7b3e5ed97a8412470e904f82b81004

@@ -408,8 +408,8 @@ instance : Sup (Ideal P) :=
           le_sup_left, le_sup_right⟩
       lower' := fun x y h ⟨yi, _, yj, _, _⟩ => ⟨yi, ‹_›, yj, ‹_›, h.trans ‹_›⟩ }⟩
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (i «expr ∈ » I) -/
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (j «expr ∈ » J) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (i «expr ∈ » I) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (j «expr ∈ » J) -/
 instance : Lattice (Ideal P) :=
   { Ideal.partialOrder with
     sup := (· ⊔ ·)

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

@@ -391,7 +391,7 @@ instance : Inf (Ideal P) :=
 supremum of `I` and `J`. -/
 instance : Sup (Ideal P) :=
   ⟨fun I J =>
-    { carrier := { x | ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j }
+    { carrier := {x | ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j}
       nonempty' := by cases inter_nonempty I J; exact ⟨w, w, h.1, w, h.2, le_sup_left⟩
       directed' := fun x ⟨xi, _, xj, _, _⟩ y ⟨yi, _, yj, _, _⟩ =>
         ⟨x ⊔ y,
@@ -424,7 +424,7 @@ instance : Lattice (Ideal P) :=
     le_inf := fun I J K => subset_inter }
 
 @[simp]
-theorem coe_sup : ↑(s ⊔ t) = { x | ∃ a ∈ s, ∃ b ∈ t, x ≤ a ⊔ b } :=
+theorem coe_sup : ↑(s ⊔ t) = {x | ∃ a ∈ s, ∃ b ∈ t, x ≤ a ⊔ b} :=
   rfl
 #align order.ideal.coe_sup Order.Ideal.coe_sup
 
@@ -504,7 +504,7 @@ theorem eq_sup_of_le_sup {x i j : P} (hi : i ∈ I) (hj : j ∈ J) (hx : x ≤ i
     
 #align order.ideal.eq_sup_of_le_sup Order.Ideal.eq_sup_of_le_sup
 
-theorem coe_sup_eq : ↑(I ⊔ J) = { x | ∃ i ∈ I, ∃ j ∈ J, x = i ⊔ j } :=
+theorem coe_sup_eq : ↑(I ⊔ J) = {x | ∃ i ∈ I, ∃ j ∈ J, x = i ⊔ j} :=
   Set.ext fun _ =>
     ⟨fun ⟨_, _, _, _, _⟩ => eq_sup_of_le_sup ‹_› ‹_› ‹_›, fun ⟨i, _, j, _, _⟩ =>
       ⟨i, ‹_›, j, ‹_›, le_of_eq ‹_›⟩⟩
@@ -618,7 +618,7 @@ theorem sequenceOfCofinals.encode_mem (i : ι) :
   This proves the Rasiowa–Sikorski lemma. -/
 def idealOfCofinals : Ideal P
     where
-  carrier := { x : P | ∃ n, x ≤ sequenceOfCofinals p 𝒟 n }
+  carrier := {x : P | ∃ n, x ≤ sequenceOfCofinals p 𝒟 n}
   lower' := fun x y hxy ⟨n, hn⟩ => ⟨n, le_trans hxy hn⟩
   nonempty' := ⟨p, 0, le_rfl⟩
   directed' := fun x ⟨n, hn⟩ y ⟨m, hm⟩ =>

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

@@ -190,8 +190,8 @@ class IsProper (I : Ideal P) : Prop where
 #print Order.Ideal.isProper_of_not_mem /-
 theorem isProper_of_not_mem {I : Ideal P} {p : P} (nmem : p ∉ I) : IsProper I :=
   ⟨fun hp => by
-    change p ∉ ↑I at nmem
-    rw [hp] at nmem
+    change p ∉ ↑I at nmem 
+    rw [hp] at nmem 
     exact nmem (mem_univ p)⟩
 #align order.ideal.is_proper_of_not_mem Order.Ideal.isProper_of_not_mem
 -/
@@ -463,7 +463,7 @@ instance : InfSet (Ideal P) :=
       directed' := fun a ha b hb =>
         ⟨a ⊔ b,
           ⟨by
-            rw [LowerSet.carrier_eq_coe, LowerSet.coe_iInf₂, Set.mem_iInter₂] at ha hb⊢
+            rw [LowerSet.carrier_eq_coe, LowerSet.coe_iInf₂, Set.mem_iInter₂] at ha hb ⊢
             exact fun s hs => sup_mem (ha _ hs) (hb _ hs), le_sup_left, le_sup_right⟩⟩ }⟩
 
 variable {S : Set (Ideal P)}
@@ -522,7 +522,7 @@ theorem IsProper.not_mem_of_compl_mem (hI : IsProper I) (hxc : xᶜ ∈ I) : x 
   intro hx
   apply hI.top_not_mem
   have ht : x ⊔ xᶜ ∈ I := sup_mem ‹_› ‹_›
-  rwa [sup_compl_eq_top] at ht
+  rwa [sup_compl_eq_top] at ht 
 #align order.ideal.is_proper.not_mem_of_compl_mem Order.Ideal.IsProper.not_mem_of_compl_mem
 -/
 

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

@@ -303,6 +303,7 @@ section
 
 variable {I J : Ideal P} {x y : P}
 
+#print Order.Ideal.principal /-
 /-- The smallest ideal containing a given element. -/
 @[simps]
 def principal (p : P) : Ideal P where
@@ -310,6 +311,7 @@ def principal (p : P) : Ideal P where
   nonempty' := nonempty_Iic
   directed' x hx y hy := ⟨p, le_rfl, hx, hy⟩
 #align order.ideal.principal Order.Ideal.principal
+-/
 
 instance [Inhabited P] : Inhabited (Ideal P) :=
   ⟨Ideal.principal default⟩
@@ -319,10 +321,12 @@ theorem principal_le_iff : principal x ≤ I ↔ x ∈ I :=
   ⟨fun h => h le_rfl, fun hx y hy => I.lower hy hx⟩
 #align order.ideal.principal_le_iff Order.Ideal.principal_le_iff
 
+#print Order.Ideal.mem_principal /-
 @[simp]
 theorem mem_principal : x ∈ principal y ↔ x ≤ y :=
   Iff.rfl
 #align order.ideal.mem_principal Order.Ideal.mem_principal
+-/
 
 end
 
@@ -512,6 +516,7 @@ section BooleanAlgebra
 
 variable [BooleanAlgebra P] {x : P} {I : Ideal P}
 
+#print Order.Ideal.IsProper.not_mem_of_compl_mem /-
 theorem IsProper.not_mem_of_compl_mem (hI : IsProper I) (hxc : xᶜ ∈ I) : x ∉ I :=
   by
   intro hx
@@ -519,12 +524,15 @@ theorem IsProper.not_mem_of_compl_mem (hI : IsProper I) (hxc : xᶜ ∈ I) : x 
   have ht : x ⊔ xᶜ ∈ I := sup_mem ‹_› ‹_›
   rwa [sup_compl_eq_top] at ht
 #align order.ideal.is_proper.not_mem_of_compl_mem Order.Ideal.IsProper.not_mem_of_compl_mem
+-/
 
+#print Order.Ideal.IsProper.not_mem_or_compl_not_mem /-
 theorem IsProper.not_mem_or_compl_not_mem (hI : IsProper I) : x ∉ I ∨ xᶜ ∉ I :=
   by
   have h : xᶜ ∈ I → x ∉ I := hI.not_mem_of_compl_mem
   tauto
 #align order.ideal.is_proper.not_mem_or_compl_not_mem Order.Ideal.IsProper.not_mem_or_compl_not_mem
+-/
 
 end BooleanAlgebra
 
@@ -566,9 +574,11 @@ theorem above_mem : D.above x ∈ D :=
 #align order.cofinal.above_mem Order.Cofinal.above_mem
 -/
 
+#print Order.Cofinal.le_above /-
 theorem le_above : x ≤ D.above x :=
   Exists.elim (Classical.choose_spec <| D.mem_gt x) fun _ b => b
 #align order.cofinal.le_above Order.Cofinal.le_above
+-/
 
 end Cofinal
 
@@ -599,6 +609,7 @@ theorem sequenceOfCofinals.encode_mem (i : ι) :
   rw [Encodable.encodek]; apply cofinal.above_mem
 #align order.sequence_of_cofinals.encode_mem Order.sequenceOfCofinals.encode_mem
 
+#print Order.idealOfCofinals /-
 /-- Given an element `p : P` and a family `𝒟` of cofinal subsets of a preorder `P`,
   indexed by a countable type, `ideal_of_cofinals p 𝒟` is an ideal in `P` which
   - contains `p`, according to `mem_ideal_of_cofinals p 𝒟`, and
@@ -614,6 +625,7 @@ def idealOfCofinals : Ideal P
     ⟨_, ⟨max n m, le_rfl⟩, le_trans hn <| sequenceOfCofinals.monotone p 𝒟 (le_max_left _ _),
       le_trans hm <| sequenceOfCofinals.monotone p 𝒟 (le_max_right _ _)⟩
 #align order.ideal_of_cofinals Order.idealOfCofinals
+-/
 
 theorem mem_idealOfCofinals : p ∈ idealOfCofinals p 𝒟 :=
   ⟨0, le_rfl⟩

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

@@ -155,12 +155,6 @@ protected theorem isIdeal (s : Ideal P) : IsIdeal (s : Set P) :=
 #align order.ideal.is_ideal Order.Ideal.isIdeal
 -/
 
-/- warning: order.ideal.mem_compl_of_ge -> Order.Ideal.mem_compl_of_ge is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] {I : Order.Ideal.{u1} P _inst_1} {x : P} {y : P}, (LE.le.{u1} P _inst_1 x y) -> (Membership.Mem.{u1, u1} P (Set.{u1} P) (Set.hasMem.{u1} P) x (HasCompl.compl.{u1} (Set.{u1} P) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} P) (Set.booleanAlgebra.{u1} P)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) I))) -> (Membership.Mem.{u1, u1} P (Set.{u1} P) (Set.hasMem.{u1} P) y (HasCompl.compl.{u1} (Set.{u1} P) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} P) (Set.booleanAlgebra.{u1} P)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) I)))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] {I : Order.Ideal.{u1} P _inst_1} {x : P} {y : P}, (LE.le.{u1} P _inst_1 x y) -> (Membership.mem.{u1, u1} P (Set.{u1} P) (Set.instMembershipSet.{u1} P) x (HasCompl.compl.{u1} (Set.{u1} P) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} P) (Set.instBooleanAlgebraSet.{u1} P)) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) I))) -> (Membership.mem.{u1, u1} P (Set.{u1} P) (Set.instMembershipSet.{u1} P) y (HasCompl.compl.{u1} (Set.{u1} P) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} P) (Set.instBooleanAlgebraSet.{u1} P)) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) I)))
-Case conversion may be inaccurate. Consider using '#align order.ideal.mem_compl_of_ge Order.Ideal.mem_compl_of_geₓ'. -/
 theorem mem_compl_of_ge {x y : P} : x ≤ y → x ∈ (I : Set P)ᶜ → y ∈ (I : Set P)ᶜ := fun h =>
   mt <| I.lower h
 #align order.ideal.mem_compl_of_ge Order.Ideal.mem_compl_of_ge
@@ -169,34 +163,16 @@ theorem mem_compl_of_ge {x y : P} : x ≤ y → x ∈ (I : Set P)ᶜ → y ∈ (
 instance : PartialOrder (Ideal P) :=
   PartialOrder.lift coe SetLike.coe_injective
 
-/- warning: order.ideal.coe_subset_coe -> Order.Ideal.coe_subset_coe is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] {s : Order.Ideal.{u1} P _inst_1} {t : Order.Ideal.{u1} P _inst_1}, Iff (HasSubset.Subset.{u1} (Set.{u1} P) (Set.hasSubset.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) s) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) t)) (LE.le.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) s t)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] {s : Order.Ideal.{u1} P _inst_1} {t : Order.Ideal.{u1} P _inst_1}, Iff (HasSubset.Subset.{u1} (Set.{u1} P) (Set.instHasSubsetSet.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) s) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) t)) (LE.le.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) s t)
-Case conversion may be inaccurate. Consider using '#align order.ideal.coe_subset_coe Order.Ideal.coe_subset_coeₓ'. -/
 @[simp]
 theorem coe_subset_coe : (s : Set P) ⊆ t ↔ s ≤ t :=
   Iff.rfl
 #align order.ideal.coe_subset_coe Order.Ideal.coe_subset_coe
 
-/- warning: order.ideal.coe_ssubset_coe -> Order.Ideal.coe_ssubset_coe is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] {s : Order.Ideal.{u1} P _inst_1} {t : Order.Ideal.{u1} P _inst_1}, Iff (HasSSubset.SSubset.{u1} (Set.{u1} P) (Set.hasSsubset.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) s) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) t)) (LT.lt.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toHasLt.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) s t)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] {s : Order.Ideal.{u1} P _inst_1} {t : Order.Ideal.{u1} P _inst_1}, Iff (HasSSubset.SSubset.{u1} (Set.{u1} P) (Set.instHasSSubsetSet.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) s) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) t)) (LT.lt.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLT.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) s t)
-Case conversion may be inaccurate. Consider using '#align order.ideal.coe_ssubset_coe Order.Ideal.coe_ssubset_coeₓ'. -/
 @[simp]
 theorem coe_ssubset_coe : (s : Set P) ⊂ t ↔ s < t :=
   Iff.rfl
 #align order.ideal.coe_ssubset_coe Order.Ideal.coe_ssubset_coe
 
-/- warning: order.ideal.mem_of_mem_of_le -> Order.Ideal.mem_of_mem_of_le is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] {x : P} {I : Order.Ideal.{u1} P _inst_1} {J : Order.Ideal.{u1} P _inst_1}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)) x I) -> (LE.le.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) I J) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)) x J)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] {x : P} {I : Order.Ideal.{u1} P _inst_1} {J : Order.Ideal.{u1} P _inst_1}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1)) x I) -> (LE.le.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) I J) -> (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1)) x J)
-Case conversion may be inaccurate. Consider using '#align order.ideal.mem_of_mem_of_le Order.Ideal.mem_of_mem_of_leₓ'. -/
 @[trans]
 theorem mem_of_mem_of_le {x : P} {I J : Ideal P} : x ∈ I → I ≤ J → x ∈ J :=
   @Set.mem_of_mem_of_subset P x I J
@@ -231,12 +207,6 @@ class IsMaximal (I : Ideal P) extends IsProper I : Prop where
 #align order.ideal.is_maximal Order.Ideal.IsMaximal
 -/
 
-/- warning: order.ideal.inter_nonempty -> Order.Ideal.inter_nonempty is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P _inst_1)] (I : Order.Ideal.{u1} P _inst_1) (J : Order.Ideal.{u1} P _inst_1), Set.Nonempty.{u1} P (Inter.inter.{u1} (Set.{u1} P) (Set.hasInter.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) I) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) J))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.883 : P) (x._@.Mathlib.Order.Ideal._hyg.885 : P) => GE.ge.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.883 x._@.Mathlib.Order.Ideal._hyg.885)] (I : Order.Ideal.{u1} P _inst_1) (J : Order.Ideal.{u1} P _inst_1), Set.Nonempty.{u1} P (Inter.inter.{u1} (Set.{u1} P) (Set.instInterSet.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) I) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) J))
-Case conversion may be inaccurate. Consider using '#align order.ideal.inter_nonempty Order.Ideal.inter_nonemptyₓ'. -/
 theorem inter_nonempty [IsDirected P (· ≥ ·)] (I J : Ideal P) : (I ∩ J : Set P).Nonempty :=
   by
   obtain ⟨a, ha⟩ := I.nonempty
@@ -257,103 +227,43 @@ instance : OrderTop (Ideal P)
   top := ⟨⊤, univ_nonempty, directedOn_univ⟩
   le_top I := le_top
 
-/- warning: order.ideal.top_to_lower_set -> Order.Ideal.top_toLowerSet is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P], Eq.{succ u1} (LowerSet.{u1} P _inst_1) (Order.Ideal.toLowerSet.{u1} P _inst_1 (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3)))) (Top.top.{u1} (LowerSet.{u1} P _inst_1) (LowerSet.hasTop.{u1} P _inst_1))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1034 : P) (x._@.Mathlib.Order.Ideal._hyg.1036 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1034 x._@.Mathlib.Order.Ideal._hyg.1036)] [_inst_3 : Nonempty.{succ u1} P], Eq.{succ u1} (LowerSet.{u1} P _inst_1) (Order.Ideal.toLowerSet.{u1} P _inst_1 (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3)))) (Top.top.{u1} (LowerSet.{u1} P _inst_1) (LowerSet.instTopLowerSet.{u1} P _inst_1))
-Case conversion may be inaccurate. Consider using '#align order.ideal.top_to_lower_set Order.Ideal.top_toLowerSetₓ'. -/
 @[simp]
 theorem top_toLowerSet : (⊤ : Ideal P).toLowerSet = ⊤ :=
   rfl
 #align order.ideal.top_to_lower_set Order.Ideal.top_toLowerSet
 
-/- warning: order.ideal.coe_top -> Order.Ideal.coe_top is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P], Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3)))) (Set.univ.{u1} P)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1077 : P) (x._@.Mathlib.Order.Ideal._hyg.1079 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1077 x._@.Mathlib.Order.Ideal._hyg.1079)] [_inst_3 : Nonempty.{succ u1} P], Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3)))) (Set.univ.{u1} P)
-Case conversion may be inaccurate. Consider using '#align order.ideal.coe_top Order.Ideal.coe_topₓ'. -/
 @[simp]
 theorem coe_top : ((⊤ : Ideal P) : Set P) = univ :=
   rfl
 #align order.ideal.coe_top Order.Ideal.coe_top
 
-/- warning: order.ideal.is_proper_of_ne_top -> Order.Ideal.isProper_of_ne_top is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3)))) -> (Order.Ideal.IsProper.{u1} P _inst_1 I)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1123 : P) (x._@.Mathlib.Order.Ideal._hyg.1125 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1123 x._@.Mathlib.Order.Ideal._hyg.1125)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3)))) -> (Order.Ideal.IsProper.{u1} P _inst_1 I)
-Case conversion may be inaccurate. Consider using '#align order.ideal.is_proper_of_ne_top Order.Ideal.isProper_of_ne_topₓ'. -/
 theorem isProper_of_ne_top (ne_top : I ≠ ⊤) : IsProper I :=
   ⟨fun h => ne_top <| ext h⟩
 #align order.ideal.is_proper_of_ne_top Order.Ideal.isProper_of_ne_top
 
-/- warning: order.ideal.is_proper.ne_top -> Order.Ideal.IsProper.ne_top is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Order.Ideal.IsProper.{u1} P _inst_1 I) -> (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3))))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1174 : P) (x._@.Mathlib.Order.Ideal._hyg.1176 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1174 x._@.Mathlib.Order.Ideal._hyg.1176)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Order.Ideal.IsProper.{u1} P _inst_1 I) -> (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3))))
-Case conversion may be inaccurate. Consider using '#align order.ideal.is_proper.ne_top Order.Ideal.IsProper.ne_topₓ'. -/
 theorem IsProper.ne_top (hI : IsProper I) : I ≠ ⊤ := fun h => IsProper.ne_univ <| congr_arg coe h
 #align order.ideal.is_proper.ne_top Order.Ideal.IsProper.ne_top
 
-/- warning: is_coatom.is_proper -> IsCoatom.isProper is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1)) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3) I) -> (Order.Ideal.IsProper.{u1} P _inst_1 I)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1223 : P) (x._@.Mathlib.Order.Ideal._hyg.1225 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1223 x._@.Mathlib.Order.Ideal._hyg.1225)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I) -> (Order.Ideal.IsProper.{u1} P _inst_1 I)
-Case conversion may be inaccurate. Consider using '#align is_coatom.is_proper IsCoatom.isProperₓ'. -/
 theorem IsCoatom.isProper (hI : IsCoatom I) : IsProper I :=
   isProper_of_ne_top hI.1
 #align is_coatom.is_proper IsCoatom.isProper
 
-/- warning: order.ideal.is_proper_iff_ne_top -> Order.Ideal.isProper_iff_ne_top is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, Iff (Order.Ideal.IsProper.{u1} P _inst_1 I) (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3))))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1258 : P) (x._@.Mathlib.Order.Ideal._hyg.1260 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1258 x._@.Mathlib.Order.Ideal._hyg.1260)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, Iff (Order.Ideal.IsProper.{u1} P _inst_1 I) (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3))))
-Case conversion may be inaccurate. Consider using '#align order.ideal.is_proper_iff_ne_top Order.Ideal.isProper_iff_ne_topₓ'. -/
 theorem isProper_iff_ne_top : IsProper I ↔ I ≠ ⊤ :=
   ⟨fun h => h.ne_top, fun h => isProper_of_ne_top h⟩
 #align order.ideal.is_proper_iff_ne_top Order.Ideal.isProper_iff_ne_top
 
-/- warning: order.ideal.is_maximal.is_coatom -> Order.Ideal.IsMaximal.isCoatom is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Order.Ideal.IsMaximal.{u1} P _inst_1 I) -> (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1)) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3) I)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1313 : P) (x._@.Mathlib.Order.Ideal._hyg.1315 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1313 x._@.Mathlib.Order.Ideal._hyg.1315)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Order.Ideal.IsMaximal.{u1} P _inst_1 I) -> (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I)
-Case conversion may be inaccurate. Consider using '#align order.ideal.is_maximal.is_coatom Order.Ideal.IsMaximal.isCoatomₓ'. -/
 theorem IsMaximal.isCoatom (h : IsMaximal I) : IsCoatom I :=
   ⟨IsMaximal.to_isProper.ne_top, fun J h => ext <| IsMaximal.maximal_proper h⟩
 #align order.ideal.is_maximal.is_coatom Order.Ideal.IsMaximal.isCoatom
 
-/- warning: order.ideal.is_maximal.is_coatom' -> Order.Ideal.IsMaximal.isCoatom' is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1} [_inst_4 : Order.Ideal.IsMaximal.{u1} P _inst_1 I], IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1)) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3) I
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1364 : P) (x._@.Mathlib.Order.Ideal._hyg.1366 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1364 x._@.Mathlib.Order.Ideal._hyg.1366)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1} [_inst_4 : Order.Ideal.IsMaximal.{u1} P _inst_1 I], IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I
-Case conversion may be inaccurate. Consider using '#align order.ideal.is_maximal.is_coatom' Order.Ideal.IsMaximal.isCoatom'ₓ'. -/
 theorem IsMaximal.isCoatom' [IsMaximal I] : IsCoatom I :=
   IsMaximal.isCoatom ‹_›
 #align order.ideal.is_maximal.is_coatom' Order.Ideal.IsMaximal.isCoatom'
 
-/- warning: is_coatom.is_maximal -> IsCoatom.isMaximal is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1)) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3) I) -> (Order.Ideal.IsMaximal.{u1} P _inst_1 I)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1409 : P) (x._@.Mathlib.Order.Ideal._hyg.1411 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1409 x._@.Mathlib.Order.Ideal._hyg.1411)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I) -> (Order.Ideal.IsMaximal.{u1} P _inst_1 I)
-Case conversion may be inaccurate. Consider using '#align is_coatom.is_maximal IsCoatom.isMaximalₓ'. -/
 theorem IsCoatom.isMaximal (hI : IsCoatom I) : IsMaximal I :=
   { IsCoatom.isProper ‹_› with maximal_proper := fun _ _ => by simp [hI.2 _ ‹_›] }
 #align is_coatom.is_maximal IsCoatom.isMaximal
 
-/- warning: order.ideal.is_maximal_iff_is_coatom -> Order.Ideal.isMaximal_iff_isCoatom is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, Iff (Order.Ideal.IsMaximal.{u1} P _inst_1 I) (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1)) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3) I)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1468 : P) (x._@.Mathlib.Order.Ideal._hyg.1470 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1468 x._@.Mathlib.Order.Ideal._hyg.1470)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, Iff (Order.Ideal.IsMaximal.{u1} P _inst_1 I) (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I)
-Case conversion may be inaccurate. Consider using '#align order.ideal.is_maximal_iff_is_coatom Order.Ideal.isMaximal_iff_isCoatomₓ'. -/
 theorem isMaximal_iff_isCoatom : IsMaximal I ↔ IsCoatom I :=
   ⟨fun h => h.IsCoatom, fun h => h.IsMaximal⟩
 #align order.ideal.is_maximal_iff_is_coatom Order.Ideal.isMaximal_iff_isCoatom
@@ -364,12 +274,6 @@ section OrderBot
 
 variable [OrderBot P]
 
-/- warning: order.ideal.bot_mem -> Order.Ideal.bot_mem is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : OrderBot.{u1} P _inst_1] (s : Order.Ideal.{u1} P _inst_1), Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)) (Bot.bot.{u1} P (OrderBot.toHasBot.{u1} P _inst_1 _inst_2)) s
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : OrderBot.{u1} P _inst_1] (s : Order.Ideal.{u1} P _inst_1), Membership.mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1)) (Bot.bot.{u1} P (OrderBot.toBot.{u1} P _inst_1 _inst_2)) s
-Case conversion may be inaccurate. Consider using '#align order.ideal.bot_mem Order.Ideal.bot_memₓ'. -/
 @[simp]
 theorem bot_mem (s : Ideal P) : ⊥ ∈ s :=
   s.lower bot_le s.Nonempty.some_mem
@@ -381,21 +285,9 @@ section OrderTop
 
 variable [OrderTop P] {I : Ideal P}
 
-/- warning: order.ideal.top_of_top_mem -> Order.Ideal.top_of_top_mem is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : OrderTop.{u1} P _inst_1] {I : Order.Ideal.{u1} P _inst_1}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)) (Top.top.{u1} P (OrderTop.toHasTop.{u1} P _inst_1 _inst_2)) I) -> (Eq.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 (OrderTop.to_isDirected_le.{u1} P _inst_1 _inst_2) (top_nonempty.{u1} P (OrderTop.toHasTop.{u1} P _inst_1 _inst_2))))))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : OrderTop.{u1} P _inst_1] {I : Order.Ideal.{u1} P _inst_1}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1)) (Top.top.{u1} P (OrderTop.toTop.{u1} P _inst_1 _inst_2)) I) -> (Eq.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 (OrderTop.to_isDirected_le.{u1} P _inst_1 _inst_2) (top_nonempty.{u1} P (OrderTop.toTop.{u1} P _inst_1 _inst_2))))))
-Case conversion may be inaccurate. Consider using '#align order.ideal.top_of_top_mem Order.Ideal.top_of_top_memₓ'. -/
 theorem top_of_top_mem (h : ⊤ ∈ I) : I = ⊤ := by ext; exact iff_of_true (I.lower le_top h) trivial
 #align order.ideal.top_of_top_mem Order.Ideal.top_of_top_mem
 
-/- warning: order.ideal.is_proper.top_not_mem -> Order.Ideal.IsProper.top_not_mem is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : OrderTop.{u1} P _inst_1] {I : Order.Ideal.{u1} P _inst_1}, (Order.Ideal.IsProper.{u1} P _inst_1 I) -> (Not (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)) (Top.top.{u1} P (OrderTop.toHasTop.{u1} P _inst_1 _inst_2)) I))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : OrderTop.{u1} P _inst_1] {I : Order.Ideal.{u1} P _inst_1}, (Order.Ideal.IsProper.{u1} P _inst_1 I) -> (Not (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1)) (Top.top.{u1} P (OrderTop.toTop.{u1} P _inst_1 _inst_2)) I))
-Case conversion may be inaccurate. Consider using '#align order.ideal.is_proper.top_not_mem Order.Ideal.IsProper.top_not_memₓ'. -/
 theorem IsProper.top_not_mem (hI : IsProper I) : ⊤ ∉ I := fun h => hI.ne_top <| top_of_top_mem h
 #align order.ideal.is_proper.top_not_mem Order.Ideal.IsProper.top_not_mem
 
@@ -411,12 +303,6 @@ section
 
 variable {I J : Ideal P} {x y : P}
 
-/- warning: order.ideal.principal -> Order.Ideal.principal is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P], P -> (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P], P -> (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1))
-Case conversion may be inaccurate. Consider using '#align order.ideal.principal Order.Ideal.principalₓ'. -/
 /-- The smallest ideal containing a given element. -/
 @[simps]
 def principal (p : P) : Ideal P where
@@ -428,23 +314,11 @@ def principal (p : P) : Ideal P where
 instance [Inhabited P] : Inhabited (Ideal P) :=
   ⟨Ideal.principal default⟩
 
-/- warning: order.ideal.principal_le_iff -> Order.Ideal.principal_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)} {x : P}, Iff (LE.le.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Order.Ideal.partialOrder.{u1} P (Preorder.toHasLe.{u1} P _inst_1)))) (Order.Ideal.principal.{u1} P _inst_1 x) I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P _inst_1))) x I)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)} {x : P}, Iff (LE.le.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Preorder.toLE.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.instPartialOrderIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1)))) (Order.Ideal.principal.{u1} P _inst_1 x) I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1))) x I)
-Case conversion may be inaccurate. Consider using '#align order.ideal.principal_le_iff Order.Ideal.principal_le_iffₓ'. -/
 @[simp]
 theorem principal_le_iff : principal x ≤ I ↔ x ∈ I :=
   ⟨fun h => h le_rfl, fun hx y hy => I.lower hy hx⟩
 #align order.ideal.principal_le_iff Order.Ideal.principal_le_iff
 
-/- warning: order.ideal.mem_principal -> Order.Ideal.mem_principal is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {y : P}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P _inst_1))) x (Order.Ideal.principal.{u1} P _inst_1 y)) (LE.le.{u1} P (Preorder.toHasLe.{u1} P _inst_1) x y)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {y : P}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1))) x (Order.Ideal.principal.{u1} P _inst_1 y)) (LE.le.{u1} P (Preorder.toLE.{u1} P _inst_1) x y)
-Case conversion may be inaccurate. Consider using '#align order.ideal.mem_principal Order.Ideal.mem_principalₓ'. -/
 @[simp]
 theorem mem_principal : x ∈ principal y ↔ x ≤ y :=
   Iff.rfl
@@ -461,12 +335,6 @@ instance : OrderBot (Ideal P) where
   bot := principal ⊥
   bot_le := by simp
 
-/- warning: order.ideal.principal_bot -> Order.Ideal.principal_bot is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toHasLe.{u1} P _inst_1)], Eq.{succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Order.Ideal.principal.{u1} P _inst_1 (Bot.bot.{u1} P (OrderBot.toHasBot.{u1} P (Preorder.toHasLe.{u1} P _inst_1) _inst_2))) (Bot.bot.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (OrderBot.toHasBot.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Order.Ideal.partialOrder.{u1} P (Preorder.toHasLe.{u1} P _inst_1)))) (Order.Ideal.orderBot.{u1} P _inst_1 _inst_2)))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toLE.{u1} P _inst_1)], Eq.{succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.principal.{u1} P _inst_1 (Bot.bot.{u1} P (OrderBot.toBot.{u1} P (Preorder.toLE.{u1} P _inst_1) _inst_2))) (Bot.bot.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (OrderBot.toBot.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Preorder.toLE.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.instPartialOrderIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1)))) (Order.Ideal.instOrderBotIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2)))
-Case conversion may be inaccurate. Consider using '#align order.ideal.principal_bot Order.Ideal.principal_botₓ'. -/
 @[simp]
 theorem principal_bot : principal (⊥ : P) = ⊥ :=
   rfl
@@ -478,12 +346,6 @@ section OrderTop
 
 variable [OrderTop P]
 
-/- warning: order.ideal.principal_top -> Order.Ideal.principal_top is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] [_inst_2 : OrderTop.{u1} P (Preorder.toHasLe.{u1} P _inst_1)], Eq.{succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Order.Ideal.principal.{u1} P _inst_1 (Top.top.{u1} P (OrderTop.toHasTop.{u1} P (Preorder.toHasLe.{u1} P _inst_1) _inst_2))) (Top.top.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Order.Ideal.partialOrder.{u1} P (Preorder.toHasLe.{u1} P _inst_1)))) (Order.Ideal.orderTop.{u1} P (Preorder.toHasLe.{u1} P _inst_1) (OrderTop.to_isDirected_le.{u1} P (Preorder.toHasLe.{u1} P _inst_1) _inst_2) (top_nonempty.{u1} P (OrderTop.toHasTop.{u1} P (Preorder.toHasLe.{u1} P _inst_1) _inst_2)))))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] [_inst_2 : OrderTop.{u1} P (Preorder.toLE.{u1} P _inst_1)], Eq.{succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.principal.{u1} P _inst_1 (Top.top.{u1} P (OrderTop.toTop.{u1} P (Preorder.toLE.{u1} P _inst_1) _inst_2))) (Top.top.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Preorder.toLE.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.instPartialOrderIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1)))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1) (OrderTop.to_isDirected_le.{u1} P (Preorder.toLE.{u1} P _inst_1) _inst_2) (top_nonempty.{u1} P (OrderTop.toTop.{u1} P (Preorder.toLE.{u1} P _inst_1) _inst_2)))))
-Case conversion may be inaccurate. Consider using '#align order.ideal.principal_top Order.Ideal.principal_topₓ'. -/
 @[simp]
 theorem principal_top : principal (⊤ : P) = ⊤ :=
   toLowerSet_injective <| LowerSet.Iic_top
@@ -497,24 +359,12 @@ section SemilatticeSup
 
 variable [SemilatticeSup P] {x y : P} {I s : Ideal P}
 
-/- warning: order.ideal.sup_mem -> Order.Ideal.sup_mem is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] {x : P} {y : P} {s : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x s) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) y s) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) x y) s)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] {x : P} {y : P} {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x s) -> (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) y s) -> (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) x y) s)
-Case conversion may be inaccurate. Consider using '#align order.ideal.sup_mem Order.Ideal.sup_memₓ'. -/
 /-- A specific witness of `I.directed` when `P` has joins. -/
 theorem sup_mem (hx : x ∈ s) (hy : y ∈ s) : x ⊔ y ∈ s :=
   let ⟨z, hz, hx, hy⟩ := s.Directed x hx y hy
   s.lower (sup_le hx hy) hz
 #align order.ideal.sup_mem Order.Ideal.sup_mem
 
-/- warning: order.ideal.sup_mem_iff -> Order.Ideal.sup_mem_iff is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] {x : P} {y : P} {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) x y) I) (And (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) y I))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] {x : P} {y : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) x y) I) (And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) y I))
-Case conversion may be inaccurate. Consider using '#align order.ideal.sup_mem_iff Order.Ideal.sup_mem_iffₓ'. -/
 @[simp]
 theorem sup_mem_iff : x ⊔ y ∈ I ↔ x ∈ I ∧ y ∈ I :=
   ⟨fun h => ⟨I.lower le_sup_left h, I.lower le_sup_right h⟩, fun h => sup_mem h.1 h.2⟩
@@ -569,56 +419,26 @@ instance : Lattice (Ideal P) :=
     inf_le_right := fun I J => inter_subset_right I J
     le_inf := fun I J K => subset_inter }
 
-/- warning: order.ideal.coe_sup -> Order.Ideal.coe_sup is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {s : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) s t)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (a : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) => Exists.{succ u1} P (fun (b : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) => LE.le.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) a b)))))))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2870 : P) (x._@.Mathlib.Order.Ideal._hyg.2872 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2870 x._@.Mathlib.Order.Ideal._hyg.2872)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (a : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) (Exists.{succ u1} P (fun (b : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) a b)))))))
-Case conversion may be inaccurate. Consider using '#align order.ideal.coe_sup Order.Ideal.coe_supₓ'. -/
 @[simp]
 theorem coe_sup : ↑(s ⊔ t) = { x | ∃ a ∈ s, ∃ b ∈ t, x ≤ a ⊔ b } :=
   rfl
 #align order.ideal.coe_sup Order.Ideal.coe_sup
 
-/- warning: order.ideal.coe_inf -> Order.Ideal.coe_inf is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {s : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) s t)) (Inter.inter.{u1} (Set.{u1} P) (Set.hasInter.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) s) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) t))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2969 : P) (x._@.Mathlib.Order.Ideal._hyg.2971 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2969 x._@.Mathlib.Order.Ideal._hyg.2971)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (Inter.inter.{u1} (Set.{u1} P) (Set.instInterSet.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) s) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) t))
-Case conversion may be inaccurate. Consider using '#align order.ideal.coe_inf Order.Ideal.coe_infₓ'. -/
 @[simp]
 theorem coe_inf : (↑(s ⊓ t) : Set P) = s ∩ t :=
   rfl
 #align order.ideal.coe_inf Order.Ideal.coe_inf
 
-/- warning: order.ideal.mem_inf -> Order.Ideal.mem_inf is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) I J)) (And (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x J))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3031 : P) (x._@.Mathlib.Order.Ideal._hyg.3033 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3031 x._@.Mathlib.Order.Ideal._hyg.3033)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x J))
-Case conversion may be inaccurate. Consider using '#align order.ideal.mem_inf Order.Ideal.mem_infₓ'. -/
 @[simp]
 theorem mem_inf : x ∈ I ⊓ J ↔ x ∈ I ∧ x ∈ J :=
   Iff.rfl
 #align order.ideal.mem_inf Order.Ideal.mem_inf
 
-/- warning: order.ideal.mem_sup -> Order.Ideal.mem_sup is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) I J)) (Exists.{succ u1} P (fun (i : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) => Exists.{succ u1} P (fun (j : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) => LE.le.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) i j))))))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3092 : P) (x._@.Mathlib.Order.Ideal._hyg.3094 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3092 x._@.Mathlib.Order.Ideal._hyg.3094)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (Exists.{succ u1} P (fun (i : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) (Exists.{succ u1} P (fun (j : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) i j))))))
-Case conversion may be inaccurate. Consider using '#align order.ideal.mem_sup Order.Ideal.mem_supₓ'. -/
 @[simp]
 theorem mem_sup : x ∈ I ⊔ J ↔ ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j :=
   Iff.rfl
 #align order.ideal.mem_sup Order.Ideal.mem_sup
 
-/- warning: order.ideal.lt_sup_principal_of_not_mem -> Order.Ideal.lt_sup_principal_of_not_mem is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Not (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I)) -> (LT.lt.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Preorder.toHasLt.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.partialOrder.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))))) I (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) I (Order.Ideal.principal.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)) x)))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3184 : P) (x._@.Mathlib.Order.Ideal._hyg.3186 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3184 x._@.Mathlib.Order.Ideal._hyg.3186)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Not (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I)) -> (LT.lt.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Preorder.toLT.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instPartialOrderIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))))) I (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I (Order.Ideal.principal.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)) x)))
-Case conversion may be inaccurate. Consider using '#align order.ideal.lt_sup_principal_of_not_mem Order.Ideal.lt_sup_principal_of_not_memₓ'. -/
 theorem lt_sup_principal_of_not_mem (hx : x ∉ I) : I < I ⊔ principal x :=
   le_sup_left.lt_of_ne fun h => hx <| by simpa only [left_eq_sup, principal_le_iff] using h
 #align order.ideal.lt_sup_principal_of_not_mem Order.Ideal.lt_sup_principal_of_not_mem
@@ -644,23 +464,11 @@ instance : InfSet (Ideal P) :=
 
 variable {S : Set (Ideal P)}
 
-/- warning: order.ideal.coe_Inf -> Order.Ideal.coe_sInf is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))] {S : Set.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (InfSet.sInf.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) S)) (Set.iInter.{u1, succ u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (fun (s : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) => Set.iInter.{u1, 0} P (Membership.Mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.hasMem.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) (fun (H : Membership.Mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.hasMem.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) s)))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))] {S : Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (InfSet.sInf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfSetIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) S)) (Set.iInter.{u1, succ u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (fun (s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) => Set.iInter.{u1, 0} P (Membership.mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.instMembershipSet.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) (fun (H : Membership.mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.instMembershipSet.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) => SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) s)))
-Case conversion may be inaccurate. Consider using '#align order.ideal.coe_Inf Order.Ideal.coe_sInfₓ'. -/
 @[simp]
 theorem coe_sInf : (↑(sInf S) : Set P) = ⋂ s ∈ S, ↑s :=
   LowerSet.coe_iInf₂ _
 #align order.ideal.coe_Inf Order.Ideal.coe_sInf
 
-/- warning: order.ideal.mem_Inf -> Order.Ideal.mem_sInf is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))] {x : P} {S : Set.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (InfSet.sInf.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) S)) (forall (s : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))), (Membership.Mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.hasMem.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x s))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))] {x : P} {S : Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (InfSet.sInf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfSetIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) S)) (forall (s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))), (Membership.mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.instMembershipSet.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) -> (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x s))
-Case conversion may be inaccurate. Consider using '#align order.ideal.mem_Inf Order.Ideal.mem_sInfₓ'. -/
 @[simp]
 theorem mem_sInf : x ∈ sInf S ↔ ∀ s ∈ S, x ∈ s := by
   simp_rw [← SetLike.mem_coe, coe_Inf, mem_Inter₂]
@@ -682,9 +490,6 @@ variable [DistribLattice P]
 
 variable {I J : Ideal P}
 
-/- warning: order.ideal.eq_sup_of_le_sup -> Order.Ideal.eq_sup_of_le_sup is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align order.ideal.eq_sup_of_le_sup Order.Ideal.eq_sup_of_le_supₓ'. -/
 theorem eq_sup_of_le_sup {x i j : P} (hi : i ∈ I) (hj : j ∈ J) (hx : x ≤ i ⊔ j) :
     ∃ i' ∈ I, ∃ j' ∈ J, x = i' ⊔ j' :=
   by
@@ -695,12 +500,6 @@ theorem eq_sup_of_le_sup {x i j : P} (hi : i ∈ I) (hj : j ∈ J) (hx : x ≤ i
     
 #align order.ideal.eq_sup_of_le_sup Order.Ideal.eq_sup_of_le_sup
 
-/- warning: order.ideal.coe_sup_eq -> Order.Ideal.coe_sup_eq is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : DistribLattice.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {J : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Order.Ideal.hasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)) (SemilatticeInf.to_isDirected_ge.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))) I J)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (i : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) => Exists.{succ u1} P (fun (j : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) => Eq.{succ u1} P x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i j)))))))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : DistribLattice.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)) (SemilatticeInf.to_isDirected_ge.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))) I J)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (i : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) (Exists.{succ u1} P (fun (j : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) (Eq.{succ u1} P x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i j)))))))
-Case conversion may be inaccurate. Consider using '#align order.ideal.coe_sup_eq Order.Ideal.coe_sup_eqₓ'. -/
 theorem coe_sup_eq : ↑(I ⊔ J) = { x | ∃ i ∈ I, ∃ j ∈ J, x = i ⊔ j } :=
   Set.ext fun _ =>
     ⟨fun ⟨_, _, _, _, _⟩ => eq_sup_of_le_sup ‹_› ‹_› ‹_›, fun ⟨i, _, j, _, _⟩ =>
@@ -713,12 +512,6 @@ section BooleanAlgebra
 
 variable [BooleanAlgebra P] {x : P} {I : Ideal P}
 
-/- warning: order.ideal.is_proper.not_mem_of_compl_mem -> Order.Ideal.IsProper.not_mem_of_compl_mem is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} P] {x : P} {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))}, (Order.Ideal.IsProper.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1))))))) I) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1))))))))) (HasCompl.compl.{u1} P (BooleanAlgebra.toHasCompl.{u1} P _inst_1) x) I) -> (Not (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1))))))))) x I))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} P] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))}, (Order.Ideal.IsProper.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1)))))))) I) -> (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1)))))))))) (HasCompl.compl.{u1} P (BooleanAlgebra.toHasCompl.{u1} P _inst_1) x) I) -> (Not (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1)))))))))) x I))
-Case conversion may be inaccurate. Consider using '#align order.ideal.is_proper.not_mem_of_compl_mem Order.Ideal.IsProper.not_mem_of_compl_memₓ'. -/
 theorem IsProper.not_mem_of_compl_mem (hI : IsProper I) (hxc : xᶜ ∈ I) : x ∉ I :=
   by
   intro hx
@@ -727,12 +520,6 @@ theorem IsProper.not_mem_of_compl_mem (hI : IsProper I) (hxc : xᶜ ∈ I) : x 
   rwa [sup_compl_eq_top] at ht
 #align order.ideal.is_proper.not_mem_of_compl_mem Order.Ideal.IsProper.not_mem_of_compl_mem
 
-/- warning: order.ideal.is_proper.not_mem_or_compl_not_mem -> Order.Ideal.IsProper.not_mem_or_compl_not_mem is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} P] {x : P} {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))}, (Order.Ideal.IsProper.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1))))))) I) -> (Or (Not (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1))))))))) x I)) (Not (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1))))))))) (HasCompl.compl.{u1} P (BooleanAlgebra.toHasCompl.{u1} P _inst_1) x) I)))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} P] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))}, (Order.Ideal.IsProper.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1)))))))) I) -> (Or (Not (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1)))))))))) x I)) (Not (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1)))))))))) (HasCompl.compl.{u1} P (BooleanAlgebra.toHasCompl.{u1} P _inst_1) x) I)))
-Case conversion may be inaccurate. Consider using '#align order.ideal.is_proper.not_mem_or_compl_not_mem Order.Ideal.IsProper.not_mem_or_compl_not_memₓ'. -/
 theorem IsProper.not_mem_or_compl_not_mem (hI : IsProper I) : x ∉ I ∨ xᶜ ∉ I :=
   by
   have h : xᶜ ∈ I → x ∉ I := hI.not_mem_of_compl_mem
@@ -779,12 +566,6 @@ theorem above_mem : D.above x ∈ D :=
 #align order.cofinal.above_mem Order.Cofinal.above_mem
 -/
 
-/- warning: order.cofinal.le_above -> Order.Cofinal.le_above is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (D : Order.Cofinal.{u1} P _inst_1) (x : P), LE.le.{u1} P (Preorder.toHasLe.{u1} P _inst_1) x (Order.Cofinal.above.{u1} P _inst_1 D x)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (D : Order.Cofinal.{u1} P _inst_1) (x : P), LE.le.{u1} P (Preorder.toLE.{u1} P _inst_1) x (Order.Cofinal.above.{u1} P _inst_1 D x)
-Case conversion may be inaccurate. Consider using '#align order.cofinal.le_above Order.Cofinal.le_aboveₓ'. -/
 theorem le_above : x ≤ D.above x :=
   Exists.elim (Classical.choose_spec <| D.mem_gt x) fun _ b => b
 #align order.cofinal.le_above Order.Cofinal.le_above
@@ -807,35 +588,17 @@ noncomputable def sequenceOfCofinals : ℕ → P
 #align order.sequence_of_cofinals Order.sequenceOfCofinals
 -/
 
-/- warning: order.sequence_of_cofinals.monotone -> Order.sequenceOfCofinals.monotone is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (p : P) {ι : Type.{u2}} [_inst_2 : Encodable.{u2} ι] (𝒟 : ι -> (Order.Cofinal.{u1} P _inst_1)), Monotone.{0, u1} Nat P (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) _inst_1 (Order.sequenceOfCofinals.{u1, u2} P _inst_1 p ι _inst_2 𝒟)
-but is expected to have type
-  forall {P : Type.{u2}} [_inst_1 : Preorder.{u2} P] (p : P) {ι : Type.{u1}} [_inst_2 : Encodable.{u1} ι] (𝒟 : ι -> (Order.Cofinal.{u2} P _inst_1)), Monotone.{0, u2} Nat P (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) _inst_1 (Order.sequenceOfCofinals.{u2, u1} P _inst_1 p ι _inst_2 𝒟)
-Case conversion may be inaccurate. Consider using '#align order.sequence_of_cofinals.monotone Order.sequenceOfCofinals.monotoneₓ'. -/
 theorem sequenceOfCofinals.monotone : Monotone (sequenceOfCofinals p 𝒟) :=
   by
   apply monotone_nat_of_le_succ; intro n; dsimp only [sequence_of_cofinals]
   cases Encodable.decode ι n; · rfl; · apply cofinal.le_above
 #align order.sequence_of_cofinals.monotone Order.sequenceOfCofinals.monotone
 
-/- warning: order.sequence_of_cofinals.encode_mem -> Order.sequenceOfCofinals.encode_mem is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (p : P) {ι : Type.{u2}} [_inst_2 : Encodable.{u2} ι] (𝒟 : ι -> (Order.Cofinal.{u1} P _inst_1)) (i : ι), Membership.Mem.{u1, u1} P (Order.Cofinal.{u1} P _inst_1) (Order.Cofinal.hasMem.{u1} P _inst_1) (Order.sequenceOfCofinals.{u1, u2} P _inst_1 p ι _inst_2 𝒟 (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) (Encodable.encode.{u2} ι _inst_2 i) (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (𝒟 i)
-but is expected to have type
-  forall {P : Type.{u2}} [_inst_1 : Preorder.{u2} P] (p : P) {ι : Type.{u1}} [_inst_2 : Encodable.{u1} ι] (𝒟 : ι -> (Order.Cofinal.{u2} P _inst_1)) (i : ι), Membership.mem.{u2, u2} P (Order.Cofinal.{u2} P _inst_1) (Order.Cofinal.instMembershipCofinal.{u2} P _inst_1) (Order.sequenceOfCofinals.{u2, u1} P _inst_1 p ι _inst_2 𝒟 (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) (Encodable.encode.{u1} ι _inst_2 i) (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (𝒟 i)
-Case conversion may be inaccurate. Consider using '#align order.sequence_of_cofinals.encode_mem Order.sequenceOfCofinals.encode_memₓ'. -/
 theorem sequenceOfCofinals.encode_mem (i : ι) :
     sequenceOfCofinals p 𝒟 (Encodable.encode i + 1) ∈ 𝒟 i := by dsimp only [sequence_of_cofinals];
   rw [Encodable.encodek]; apply cofinal.above_mem
 #align order.sequence_of_cofinals.encode_mem Order.sequenceOfCofinals.encode_mem
 
-/- warning: order.ideal_of_cofinals -> Order.idealOfCofinals is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P], P -> (forall {ι : Type.{u2}} [_inst_2 : Encodable.{u2} ι], (ι -> (Order.Cofinal.{u1} P _inst_1)) -> (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P], P -> (forall {ι : Type.{u2}} [_inst_2 : Encodable.{u2} ι], (ι -> (Order.Cofinal.{u1} P _inst_1)) -> (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)))
-Case conversion may be inaccurate. Consider using '#align order.ideal_of_cofinals Order.idealOfCofinalsₓ'. -/
 /-- Given an element `p : P` and a family `𝒟` of cofinal subsets of a preorder `P`,
   indexed by a countable type, `ideal_of_cofinals p 𝒟` is an ideal in `P` which
   - contains `p`, according to `mem_ideal_of_cofinals p 𝒟`, and
@@ -852,22 +615,10 @@ def idealOfCofinals : Ideal P
       le_trans hm <| sequenceOfCofinals.monotone p 𝒟 (le_max_right _ _)⟩
 #align order.ideal_of_cofinals Order.idealOfCofinals
 
-/- warning: order.mem_ideal_of_cofinals -> Order.mem_idealOfCofinals is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (p : P) {ι : Type.{u2}} [_inst_2 : Encodable.{u2} ι] (𝒟 : ι -> (Order.Cofinal.{u1} P _inst_1)), Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P _inst_1))) p (Order.idealOfCofinals.{u1, u2} P _inst_1 p ι _inst_2 𝒟)
-but is expected to have type
-  forall {P : Type.{u2}} [_inst_1 : Preorder.{u2} P] (p : P) {ι : Type.{u1}} [_inst_2 : Encodable.{u1} ι] (𝒟 : ι -> (Order.Cofinal.{u2} P _inst_1)), Membership.mem.{u2, u2} P (Order.Ideal.{u2} P (Preorder.toLE.{u2} P _inst_1)) (SetLike.instMembership.{u2, u2} (Order.Ideal.{u2} P (Preorder.toLE.{u2} P _inst_1)) P (Order.Ideal.instSetLikeIdeal.{u2} P (Preorder.toLE.{u2} P _inst_1))) p (Order.idealOfCofinals.{u2, u1} P _inst_1 p ι _inst_2 𝒟)
-Case conversion may be inaccurate. Consider using '#align order.mem_ideal_of_cofinals Order.mem_idealOfCofinalsₓ'. -/
 theorem mem_idealOfCofinals : p ∈ idealOfCofinals p 𝒟 :=
   ⟨0, le_rfl⟩
 #align order.mem_ideal_of_cofinals Order.mem_idealOfCofinals
 
-/- warning: order.cofinal_meets_ideal_of_cofinals -> Order.cofinal_meets_idealOfCofinals is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (p : P) {ι : Type.{u2}} [_inst_2 : Encodable.{u2} ι] (𝒟 : ι -> (Order.Cofinal.{u1} P _inst_1)) (i : ι), Exists.{succ u1} P (fun (x : P) => And (Membership.Mem.{u1, u1} P (Order.Cofinal.{u1} P _inst_1) (Order.Cofinal.hasMem.{u1} P _inst_1) x (𝒟 i)) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P _inst_1))) x (Order.idealOfCofinals.{u1, u2} P _inst_1 p ι _inst_2 𝒟)))
-but is expected to have type
-  forall {P : Type.{u2}} [_inst_1 : Preorder.{u2} P] (p : P) {ι : Type.{u1}} [_inst_2 : Encodable.{u1} ι] (𝒟 : ι -> (Order.Cofinal.{u2} P _inst_1)) (i : ι), Exists.{succ u2} P (fun (x : P) => And (Membership.mem.{u2, u2} P (Order.Cofinal.{u2} P _inst_1) (Order.Cofinal.instMembershipCofinal.{u2} P _inst_1) x (𝒟 i)) (Membership.mem.{u2, u2} P (Order.Ideal.{u2} P (Preorder.toLE.{u2} P _inst_1)) (SetLike.instMembership.{u2, u2} (Order.Ideal.{u2} P (Preorder.toLE.{u2} P _inst_1)) P (Order.Ideal.instSetLikeIdeal.{u2} P (Preorder.toLE.{u2} P _inst_1))) x (Order.idealOfCofinals.{u2, u1} P _inst_1 p ι _inst_2 𝒟)))
-Case conversion may be inaccurate. Consider using '#align order.cofinal_meets_ideal_of_cofinals Order.cofinal_meets_idealOfCofinalsₓ'. -/
 /-- `ideal_of_cofinals p 𝒟` is `𝒟`-generic. -/
 theorem cofinal_meets_idealOfCofinals (i : ι) : ∃ x : P, x ∈ 𝒟 i ∧ x ∈ idealOfCofinals p 𝒟 :=
   ⟨_, sequenceOfCofinals.encode_mem p 𝒟 i, _, le_rfl⟩

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

@@ -101,11 +101,8 @@ section
 variable {I J s t : Ideal P} {x y : P}
 
 #print Order.Ideal.toLowerSet_injective /-
-theorem toLowerSet_injective : Injective (toLowerSet : Ideal P → LowerSet P) := fun s t h =>
-  by
-  cases s
-  cases t
-  congr
+theorem toLowerSet_injective : Injective (toLowerSet : Ideal P → LowerSet P) := fun s t h => by
+  cases s; cases t; congr
 #align order.ideal.to_lower_set_injective Order.Ideal.toLowerSet_injective
 -/
 
@@ -390,9 +387,7 @@ lean 3 declaration is
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : OrderTop.{u1} P _inst_1] {I : Order.Ideal.{u1} P _inst_1}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1)) (Top.top.{u1} P (OrderTop.toTop.{u1} P _inst_1 _inst_2)) I) -> (Eq.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 (OrderTop.to_isDirected_le.{u1} P _inst_1 _inst_2) (top_nonempty.{u1} P (OrderTop.toTop.{u1} P _inst_1 _inst_2))))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.top_of_top_mem Order.Ideal.top_of_top_memₓ'. -/
-theorem top_of_top_mem (h : ⊤ ∈ I) : I = ⊤ := by
-  ext
-  exact iff_of_true (I.lower le_top h) trivial
+theorem top_of_top_mem (h : ⊤ ∈ I) : I = ⊤ := by ext; exact iff_of_true (I.lower le_top h) trivial
 #align order.ideal.top_of_top_mem Order.Ideal.top_of_top_mem
 
 /- warning: order.ideal.is_proper.top_not_mem -> Order.Ideal.IsProper.top_not_mem is a dubious translation:
@@ -543,9 +538,7 @@ supremum of `I` and `J`. -/
 instance : Sup (Ideal P) :=
   ⟨fun I J =>
     { carrier := { x | ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j }
-      nonempty' := by
-        cases inter_nonempty I J
-        exact ⟨w, w, h.1, w, h.2, le_sup_left⟩
+      nonempty' := by cases inter_nonempty I J; exact ⟨w, w, h.1, w, h.2, le_sup_left⟩
       directed' := fun x ⟨xi, _, xj, _, _⟩ y ⟨yi, _, yj, _, _⟩ =>
         ⟨x ⊔ y,
           ⟨xi ⊔ yi, sup_mem ‹_› ‹_›, xj ⊔ yj, sup_mem ‹_› ‹_›,
@@ -566,13 +559,8 @@ instance : Sup (Ideal P) :=
 instance : Lattice (Ideal P) :=
   { Ideal.partialOrder with
     sup := (· ⊔ ·)
-    le_sup_left := fun I J i (_ : i ∈ I) =>
-      by
-      cases J.nonempty
-      exact ⟨i, ‹_›, w, ‹_›, le_sup_left⟩
-    le_sup_right := fun I J j (_ : j ∈ J) =>
-      by
-      cases I.nonempty
+    le_sup_left := fun I J i (_ : i ∈ I) => by cases J.nonempty; exact ⟨i, ‹_›, w, ‹_›, le_sup_left⟩
+    le_sup_right := fun I J j (_ : j ∈ J) => by cases I.nonempty;
       exact ⟨w, ‹_›, j, ‹_›, le_sup_right⟩
     sup_le := fun I J K hIK hJK a ⟨i, hi, j, hj, ha⟩ =>
       K.lower ha <| sup_mem (mem_of_mem_of_le hi hIK) (mem_of_mem_of_le hj hJK)
@@ -827,12 +815,8 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align order.sequence_of_cofinals.monotone Order.sequenceOfCofinals.monotoneₓ'. -/
 theorem sequenceOfCofinals.monotone : Monotone (sequenceOfCofinals p 𝒟) :=
   by
-  apply monotone_nat_of_le_succ
-  intro n
-  dsimp only [sequence_of_cofinals]
-  cases Encodable.decode ι n
-  · rfl
-  · apply cofinal.le_above
+  apply monotone_nat_of_le_succ; intro n; dsimp only [sequence_of_cofinals]
+  cases Encodable.decode ι n; · rfl; · apply cofinal.le_above
 #align order.sequence_of_cofinals.monotone Order.sequenceOfCofinals.monotone
 
 /- warning: order.sequence_of_cofinals.encode_mem -> Order.sequenceOfCofinals.encode_mem is a dubious translation:
@@ -842,11 +826,8 @@ but is expected to have type
   forall {P : Type.{u2}} [_inst_1 : Preorder.{u2} P] (p : P) {ι : Type.{u1}} [_inst_2 : Encodable.{u1} ι] (𝒟 : ι -> (Order.Cofinal.{u2} P _inst_1)) (i : ι), Membership.mem.{u2, u2} P (Order.Cofinal.{u2} P _inst_1) (Order.Cofinal.instMembershipCofinal.{u2} P _inst_1) (Order.sequenceOfCofinals.{u2, u1} P _inst_1 p ι _inst_2 𝒟 (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) (Encodable.encode.{u1} ι _inst_2 i) (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (𝒟 i)
 Case conversion may be inaccurate. Consider using '#align order.sequence_of_cofinals.encode_mem Order.sequenceOfCofinals.encode_memₓ'. -/
 theorem sequenceOfCofinals.encode_mem (i : ι) :
-    sequenceOfCofinals p 𝒟 (Encodable.encode i + 1) ∈ 𝒟 i :=
-  by
-  dsimp only [sequence_of_cofinals]
-  rw [Encodable.encodek]
-  apply cofinal.above_mem
+    sequenceOfCofinals p 𝒟 (Encodable.encode i + 1) ∈ 𝒟 i := by dsimp only [sequence_of_cofinals];
+  rw [Encodable.encodek]; apply cofinal.above_mem
 #align order.sequence_of_cofinals.encode_mem Order.sequenceOfCofinals.encode_mem
 
 /- warning: order.ideal_of_cofinals -> Order.idealOfCofinals is a dubious translation:

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

@@ -695,10 +695,7 @@ variable [DistribLattice P]
 variable {I J : Ideal P}
 
 /- warning: order.ideal.eq_sup_of_le_sup -> Order.Ideal.eq_sup_of_le_sup is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : DistribLattice.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {J : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {x : P} {i : P} {j : P}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) -> (LE.le.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))) x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i j)) -> (Exists.{succ u1} P (fun (i' : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i' I) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i' I) => Exists.{succ u1} P (fun (j' : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j' J) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j' J) => Eq.{succ u1} P x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i' j'))))))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : DistribLattice.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {x : P} {i : P} {j : P}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) -> (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) -> (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i j)) -> (Exists.{succ u1} P (fun (i' : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i' I) (Exists.{succ u1} P (fun (j' : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j' J) (Eq.{succ u1} P x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i' j'))))))
+<too large>
 Case conversion may be inaccurate. Consider using '#align order.ideal.eq_sup_of_le_sup Order.Ideal.eq_sup_of_le_supₓ'. -/
 theorem eq_sup_of_le_sup {x i j : P} (hi : i ∈ I) (hj : j ∈ J) (hx : x ≤ i ⊔ j) :
     ∃ i' ∈ I, ∃ j' ∈ J, x = i' ⊔ j' :=

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

@@ -174,7 +174,7 @@ instance : PartialOrder (Ideal P) :=
 
 /- warning: order.ideal.coe_subset_coe -> Order.Ideal.coe_subset_coe is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] {s : Order.Ideal.{u1} P _inst_1} {t : Order.Ideal.{u1} P _inst_1}, Iff (HasSubset.Subset.{u1} (Set.{u1} P) (Set.hasSubset.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) s) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) t)) (LE.le.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) s t)
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] {s : Order.Ideal.{u1} P _inst_1} {t : Order.Ideal.{u1} P _inst_1}, Iff (HasSubset.Subset.{u1} (Set.{u1} P) (Set.hasSubset.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) s) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) t)) (LE.le.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) s t)
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] {s : Order.Ideal.{u1} P _inst_1} {t : Order.Ideal.{u1} P _inst_1}, Iff (HasSubset.Subset.{u1} (Set.{u1} P) (Set.instHasSubsetSet.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) s) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) t)) (LE.le.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) s t)
 Case conversion may be inaccurate. Consider using '#align order.ideal.coe_subset_coe Order.Ideal.coe_subset_coeₓ'. -/
@@ -185,7 +185,7 @@ theorem coe_subset_coe : (s : Set P) ⊆ t ↔ s ≤ t :=
 
 /- warning: order.ideal.coe_ssubset_coe -> Order.Ideal.coe_ssubset_coe is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] {s : Order.Ideal.{u1} P _inst_1} {t : Order.Ideal.{u1} P _inst_1}, Iff (HasSSubset.SSubset.{u1} (Set.{u1} P) (Set.hasSsubset.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) s) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) t)) (LT.lt.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLT.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) s t)
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] {s : Order.Ideal.{u1} P _inst_1} {t : Order.Ideal.{u1} P _inst_1}, Iff (HasSSubset.SSubset.{u1} (Set.{u1} P) (Set.hasSsubset.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) s) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) t)) (LT.lt.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toHasLt.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) s t)
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] {s : Order.Ideal.{u1} P _inst_1} {t : Order.Ideal.{u1} P _inst_1}, Iff (HasSSubset.SSubset.{u1} (Set.{u1} P) (Set.instHasSSubsetSet.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) s) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) t)) (LT.lt.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLT.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) s t)
 Case conversion may be inaccurate. Consider using '#align order.ideal.coe_ssubset_coe Order.Ideal.coe_ssubset_coeₓ'. -/
@@ -196,7 +196,7 @@ theorem coe_ssubset_coe : (s : Set P) ⊂ t ↔ s < t :=
 
 /- warning: order.ideal.mem_of_mem_of_le -> Order.Ideal.mem_of_mem_of_le is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] {x : P} {I : Order.Ideal.{u1} P _inst_1} {J : Order.Ideal.{u1} P _inst_1}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)) x I) -> (LE.le.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) I J) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)) x J)
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] {x : P} {I : Order.Ideal.{u1} P _inst_1} {J : Order.Ideal.{u1} P _inst_1}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)) x I) -> (LE.le.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) I J) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)) x J)
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] {x : P} {I : Order.Ideal.{u1} P _inst_1} {J : Order.Ideal.{u1} P _inst_1}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1)) x I) -> (LE.le.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) I J) -> (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1)) x J)
 Case conversion may be inaccurate. Consider using '#align order.ideal.mem_of_mem_of_le Order.Ideal.mem_of_mem_of_leₓ'. -/
@@ -262,7 +262,7 @@ instance : OrderTop (Ideal P)
 
 /- warning: order.ideal.top_to_lower_set -> Order.Ideal.top_toLowerSet is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P], Eq.{succ u1} (LowerSet.{u1} P _inst_1) (Order.Ideal.toLowerSet.{u1} P _inst_1 (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3)))) (Top.top.{u1} (LowerSet.{u1} P _inst_1) (LowerSet.hasTop.{u1} P _inst_1))
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P], Eq.{succ u1} (LowerSet.{u1} P _inst_1) (Order.Ideal.toLowerSet.{u1} P _inst_1 (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3)))) (Top.top.{u1} (LowerSet.{u1} P _inst_1) (LowerSet.hasTop.{u1} P _inst_1))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1034 : P) (x._@.Mathlib.Order.Ideal._hyg.1036 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1034 x._@.Mathlib.Order.Ideal._hyg.1036)] [_inst_3 : Nonempty.{succ u1} P], Eq.{succ u1} (LowerSet.{u1} P _inst_1) (Order.Ideal.toLowerSet.{u1} P _inst_1 (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3)))) (Top.top.{u1} (LowerSet.{u1} P _inst_1) (LowerSet.instTopLowerSet.{u1} P _inst_1))
 Case conversion may be inaccurate. Consider using '#align order.ideal.top_to_lower_set Order.Ideal.top_toLowerSetₓ'. -/
@@ -273,7 +273,7 @@ theorem top_toLowerSet : (⊤ : Ideal P).toLowerSet = ⊤ :=
 
 /- warning: order.ideal.coe_top -> Order.Ideal.coe_top is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P], Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3)))) (Set.univ.{u1} P)
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P], Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3)))) (Set.univ.{u1} P)
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1077 : P) (x._@.Mathlib.Order.Ideal._hyg.1079 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1077 x._@.Mathlib.Order.Ideal._hyg.1079)] [_inst_3 : Nonempty.{succ u1} P], Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3)))) (Set.univ.{u1} P)
 Case conversion may be inaccurate. Consider using '#align order.ideal.coe_top Order.Ideal.coe_topₓ'. -/
@@ -284,7 +284,7 @@ theorem coe_top : ((⊤ : Ideal P) : Set P) = univ :=
 
 /- warning: order.ideal.is_proper_of_ne_top -> Order.Ideal.isProper_of_ne_top is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3)))) -> (Order.Ideal.IsProper.{u1} P _inst_1 I)
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3)))) -> (Order.Ideal.IsProper.{u1} P _inst_1 I)
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1123 : P) (x._@.Mathlib.Order.Ideal._hyg.1125 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1123 x._@.Mathlib.Order.Ideal._hyg.1125)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3)))) -> (Order.Ideal.IsProper.{u1} P _inst_1 I)
 Case conversion may be inaccurate. Consider using '#align order.ideal.is_proper_of_ne_top Order.Ideal.isProper_of_ne_topₓ'. -/
@@ -294,7 +294,7 @@ theorem isProper_of_ne_top (ne_top : I ≠ ⊤) : IsProper I :=
 
 /- warning: order.ideal.is_proper.ne_top -> Order.Ideal.IsProper.ne_top is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Order.Ideal.IsProper.{u1} P _inst_1 I) -> (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3))))
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Order.Ideal.IsProper.{u1} P _inst_1 I) -> (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3))))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1174 : P) (x._@.Mathlib.Order.Ideal._hyg.1176 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1174 x._@.Mathlib.Order.Ideal._hyg.1176)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Order.Ideal.IsProper.{u1} P _inst_1 I) -> (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.is_proper.ne_top Order.Ideal.IsProper.ne_topₓ'. -/
@@ -313,7 +313,7 @@ theorem IsCoatom.isProper (hI : IsCoatom I) : IsProper I :=
 
 /- warning: order.ideal.is_proper_iff_ne_top -> Order.Ideal.isProper_iff_ne_top is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, Iff (Order.Ideal.IsProper.{u1} P _inst_1 I) (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3))))
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, Iff (Order.Ideal.IsProper.{u1} P _inst_1 I) (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3))))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1258 : P) (x._@.Mathlib.Order.Ideal._hyg.1260 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1258 x._@.Mathlib.Order.Ideal._hyg.1260)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, Iff (Order.Ideal.IsProper.{u1} P _inst_1 I) (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.is_proper_iff_ne_top Order.Ideal.isProper_iff_ne_topₓ'. -/
@@ -386,7 +386,7 @@ variable [OrderTop P] {I : Ideal P}
 
 /- warning: order.ideal.top_of_top_mem -> Order.Ideal.top_of_top_mem is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : OrderTop.{u1} P _inst_1] {I : Order.Ideal.{u1} P _inst_1}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)) (Top.top.{u1} P (OrderTop.toHasTop.{u1} P _inst_1 _inst_2)) I) -> (Eq.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 (OrderTop.to_isDirected_le.{u1} P _inst_1 _inst_2) (top_nonempty.{u1} P (OrderTop.toHasTop.{u1} P _inst_1 _inst_2))))))
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : OrderTop.{u1} P _inst_1] {I : Order.Ideal.{u1} P _inst_1}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)) (Top.top.{u1} P (OrderTop.toHasTop.{u1} P _inst_1 _inst_2)) I) -> (Eq.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 (OrderTop.to_isDirected_le.{u1} P _inst_1 _inst_2) (top_nonempty.{u1} P (OrderTop.toHasTop.{u1} P _inst_1 _inst_2))))))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : OrderTop.{u1} P _inst_1] {I : Order.Ideal.{u1} P _inst_1}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1)) (Top.top.{u1} P (OrderTop.toTop.{u1} P _inst_1 _inst_2)) I) -> (Eq.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 (OrderTop.to_isDirected_le.{u1} P _inst_1 _inst_2) (top_nonempty.{u1} P (OrderTop.toTop.{u1} P _inst_1 _inst_2))))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.top_of_top_mem Order.Ideal.top_of_top_memₓ'. -/
@@ -416,7 +416,12 @@ section
 
 variable {I J : Ideal P} {x y : P}
 
-#print Order.Ideal.principal /-
+/- warning: order.ideal.principal -> Order.Ideal.principal is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P], P -> (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1))
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P], P -> (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1))
+Case conversion may be inaccurate. Consider using '#align order.ideal.principal Order.Ideal.principalₓ'. -/
 /-- The smallest ideal containing a given element. -/
 @[simps]
 def principal (p : P) : Ideal P where
@@ -424,14 +429,13 @@ def principal (p : P) : Ideal P where
   nonempty' := nonempty_Iic
   directed' x hx y hy := ⟨p, le_rfl, hx, hy⟩
 #align order.ideal.principal Order.Ideal.principal
--/
 
 instance [Inhabited P] : Inhabited (Ideal P) :=
   ⟨Ideal.principal default⟩
 
 /- warning: order.ideal.principal_le_iff -> Order.Ideal.principal_le_iff is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)} {x : P}, Iff (LE.le.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Preorder.toLE.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.partialOrder.{u1} P (Preorder.toLE.{u1} P _inst_1)))) (Order.Ideal.principal.{u1} P _inst_1 x) I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P _inst_1))) x I)
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)} {x : P}, Iff (LE.le.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Order.Ideal.partialOrder.{u1} P (Preorder.toHasLe.{u1} P _inst_1)))) (Order.Ideal.principal.{u1} P _inst_1 x) I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P _inst_1))) x I)
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)} {x : P}, Iff (LE.le.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Preorder.toLE.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.instPartialOrderIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1)))) (Order.Ideal.principal.{u1} P _inst_1 x) I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1))) x I)
 Case conversion may be inaccurate. Consider using '#align order.ideal.principal_le_iff Order.Ideal.principal_le_iffₓ'. -/
@@ -440,12 +444,16 @@ theorem principal_le_iff : principal x ≤ I ↔ x ∈ I :=
   ⟨fun h => h le_rfl, fun hx y hy => I.lower hy hx⟩
 #align order.ideal.principal_le_iff Order.Ideal.principal_le_iff
 
-#print Order.Ideal.mem_principal /-
+/- warning: order.ideal.mem_principal -> Order.Ideal.mem_principal is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {y : P}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P _inst_1))) x (Order.Ideal.principal.{u1} P _inst_1 y)) (LE.le.{u1} P (Preorder.toHasLe.{u1} P _inst_1) x y)
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {y : P}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1))) x (Order.Ideal.principal.{u1} P _inst_1 y)) (LE.le.{u1} P (Preorder.toLE.{u1} P _inst_1) x y)
+Case conversion may be inaccurate. Consider using '#align order.ideal.mem_principal Order.Ideal.mem_principalₓ'. -/
 @[simp]
 theorem mem_principal : x ∈ principal y ↔ x ≤ y :=
   Iff.rfl
 #align order.ideal.mem_principal Order.Ideal.mem_principal
--/
 
 end
 
@@ -460,7 +468,7 @@ instance : OrderBot (Ideal P) where
 
 /- warning: order.ideal.principal_bot -> Order.Ideal.principal_bot is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toLE.{u1} P _inst_1)], Eq.{succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.principal.{u1} P _inst_1 (Bot.bot.{u1} P (OrderBot.toHasBot.{u1} P (Preorder.toLE.{u1} P _inst_1) _inst_2))) (Bot.bot.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (OrderBot.toHasBot.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Preorder.toLE.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.partialOrder.{u1} P (Preorder.toLE.{u1} P _inst_1)))) (Order.Ideal.orderBot.{u1} P _inst_1 _inst_2)))
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toHasLe.{u1} P _inst_1)], Eq.{succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Order.Ideal.principal.{u1} P _inst_1 (Bot.bot.{u1} P (OrderBot.toHasBot.{u1} P (Preorder.toHasLe.{u1} P _inst_1) _inst_2))) (Bot.bot.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (OrderBot.toHasBot.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Order.Ideal.partialOrder.{u1} P (Preorder.toHasLe.{u1} P _inst_1)))) (Order.Ideal.orderBot.{u1} P _inst_1 _inst_2)))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toLE.{u1} P _inst_1)], Eq.{succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.principal.{u1} P _inst_1 (Bot.bot.{u1} P (OrderBot.toBot.{u1} P (Preorder.toLE.{u1} P _inst_1) _inst_2))) (Bot.bot.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (OrderBot.toBot.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Preorder.toLE.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.instPartialOrderIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1)))) (Order.Ideal.instOrderBotIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2)))
 Case conversion may be inaccurate. Consider using '#align order.ideal.principal_bot Order.Ideal.principal_botₓ'. -/
@@ -477,7 +485,7 @@ variable [OrderTop P]
 
 /- warning: order.ideal.principal_top -> Order.Ideal.principal_top is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] [_inst_2 : OrderTop.{u1} P (Preorder.toLE.{u1} P _inst_1)], Eq.{succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.principal.{u1} P _inst_1 (Top.top.{u1} P (OrderTop.toHasTop.{u1} P (Preorder.toLE.{u1} P _inst_1) _inst_2))) (Top.top.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Preorder.toLE.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.partialOrder.{u1} P (Preorder.toLE.{u1} P _inst_1)))) (Order.Ideal.orderTop.{u1} P (Preorder.toLE.{u1} P _inst_1) (OrderTop.to_isDirected_le.{u1} P (Preorder.toLE.{u1} P _inst_1) _inst_2) (top_nonempty.{u1} P (OrderTop.toHasTop.{u1} P (Preorder.toLE.{u1} P _inst_1) _inst_2)))))
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] [_inst_2 : OrderTop.{u1} P (Preorder.toHasLe.{u1} P _inst_1)], Eq.{succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Order.Ideal.principal.{u1} P _inst_1 (Top.top.{u1} P (OrderTop.toHasTop.{u1} P (Preorder.toHasLe.{u1} P _inst_1) _inst_2))) (Top.top.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Preorder.toHasLe.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Order.Ideal.partialOrder.{u1} P (Preorder.toHasLe.{u1} P _inst_1)))) (Order.Ideal.orderTop.{u1} P (Preorder.toHasLe.{u1} P _inst_1) (OrderTop.to_isDirected_le.{u1} P (Preorder.toHasLe.{u1} P _inst_1) _inst_2) (top_nonempty.{u1} P (OrderTop.toHasTop.{u1} P (Preorder.toHasLe.{u1} P _inst_1) _inst_2)))))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] [_inst_2 : OrderTop.{u1} P (Preorder.toLE.{u1} P _inst_1)], Eq.{succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.principal.{u1} P _inst_1 (Top.top.{u1} P (OrderTop.toTop.{u1} P (Preorder.toLE.{u1} P _inst_1) _inst_2))) (Top.top.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Preorder.toLE.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.instPartialOrderIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1)))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1) (OrderTop.to_isDirected_le.{u1} P (Preorder.toLE.{u1} P _inst_1) _inst_2) (top_nonempty.{u1} P (OrderTop.toTop.{u1} P (Preorder.toLE.{u1} P _inst_1) _inst_2)))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.principal_top Order.Ideal.principal_topₓ'. -/
@@ -496,7 +504,7 @@ variable [SemilatticeSup P] {x y : P} {I s : Ideal P}
 
 /- warning: order.ideal.sup_mem -> Order.Ideal.sup_mem is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] {x : P} {y : P} {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x s) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) y s) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) x y) s)
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] {x : P} {y : P} {s : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x s) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) y s) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) x y) s)
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] {x : P} {y : P} {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x s) -> (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) y s) -> (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) x y) s)
 Case conversion may be inaccurate. Consider using '#align order.ideal.sup_mem Order.Ideal.sup_memₓ'. -/
@@ -508,7 +516,7 @@ theorem sup_mem (hx : x ∈ s) (hy : y ∈ s) : x ⊔ y ∈ s :=
 
 /- warning: order.ideal.sup_mem_iff -> Order.Ideal.sup_mem_iff is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] {x : P} {y : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) x y) I) (And (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) y I))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] {x : P} {y : P} {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) x y) I) (And (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) y I))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] {x : P} {y : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) x y) I) (And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) y I))
 Case conversion may be inaccurate. Consider using '#align order.ideal.sup_mem_iff Order.Ideal.sup_mem_iffₓ'. -/
@@ -575,7 +583,7 @@ instance : Lattice (Ideal P) :=
 
 /- warning: order.ideal.coe_sup -> Order.Ideal.coe_sup is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) s t)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (a : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) => Exists.{succ u1} P (fun (b : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) => LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) a b)))))))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {s : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) s t)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (a : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) => Exists.{succ u1} P (fun (b : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) => LE.le.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) a b)))))))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2870 : P) (x._@.Mathlib.Order.Ideal._hyg.2872 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2870 x._@.Mathlib.Order.Ideal._hyg.2872)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (a : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) (Exists.{succ u1} P (fun (b : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) a b)))))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.coe_sup Order.Ideal.coe_supₓ'. -/
@@ -586,7 +594,7 @@ theorem coe_sup : ↑(s ⊔ t) = { x | ∃ a ∈ s, ∃ b ∈ t, x ≤ a ⊔ b }
 
 /- warning: order.ideal.coe_inf -> Order.Ideal.coe_inf is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) s t)) (Inter.inter.{u1} (Set.{u1} P) (Set.hasInter.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) s) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) t))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {s : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) s t)) (Inter.inter.{u1} (Set.{u1} P) (Set.hasInter.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) s) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) t))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2969 : P) (x._@.Mathlib.Order.Ideal._hyg.2971 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2969 x._@.Mathlib.Order.Ideal._hyg.2971)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (Inter.inter.{u1} (Set.{u1} P) (Set.instInterSet.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) s) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) t))
 Case conversion may be inaccurate. Consider using '#align order.ideal.coe_inf Order.Ideal.coe_infₓ'. -/
@@ -597,7 +605,7 @@ theorem coe_inf : (↑(s ⊓ t) : Set P) = s ∩ t :=
 
 /- warning: order.ideal.mem_inf -> Order.Ideal.mem_inf is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) I J)) (And (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x J))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) I J)) (And (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x J))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3031 : P) (x._@.Mathlib.Order.Ideal._hyg.3033 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3031 x._@.Mathlib.Order.Ideal._hyg.3033)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x J))
 Case conversion may be inaccurate. Consider using '#align order.ideal.mem_inf Order.Ideal.mem_infₓ'. -/
@@ -608,7 +616,7 @@ theorem mem_inf : x ∈ I ⊓ J ↔ x ∈ I ∧ x ∈ J :=
 
 /- warning: order.ideal.mem_sup -> Order.Ideal.mem_sup is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) I J)) (Exists.{succ u1} P (fun (i : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) => Exists.{succ u1} P (fun (j : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) => LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) i j))))))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) I J)) (Exists.{succ u1} P (fun (i : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) => Exists.{succ u1} P (fun (j : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) => LE.le.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) i j))))))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3092 : P) (x._@.Mathlib.Order.Ideal._hyg.3094 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3092 x._@.Mathlib.Order.Ideal._hyg.3094)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (Exists.{succ u1} P (fun (i : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) (Exists.{succ u1} P (fun (j : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) i j))))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.mem_sup Order.Ideal.mem_supₓ'. -/
@@ -619,7 +627,7 @@ theorem mem_sup : x ∈ I ⊔ J ↔ ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j :=
 
 /- warning: order.ideal.lt_sup_principal_of_not_mem -> Order.Ideal.lt_sup_principal_of_not_mem is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Not (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I)) -> (LT.lt.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Preorder.toLT.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.partialOrder.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))))) I (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) I (Order.Ideal.principal.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)) x)))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Not (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I)) -> (LT.lt.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Preorder.toHasLt.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.partialOrder.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))))) I (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) I (Order.Ideal.principal.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)) x)))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3184 : P) (x._@.Mathlib.Order.Ideal._hyg.3186 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3184 x._@.Mathlib.Order.Ideal._hyg.3186)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Not (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I)) -> (LT.lt.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Preorder.toLT.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instPartialOrderIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))))) I (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I (Order.Ideal.principal.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)) x)))
 Case conversion may be inaccurate. Consider using '#align order.ideal.lt_sup_principal_of_not_mem Order.Ideal.lt_sup_principal_of_not_memₓ'. -/
@@ -650,7 +658,7 @@ variable {S : Set (Ideal P)}
 
 /- warning: order.ideal.coe_Inf -> Order.Ideal.coe_sInf is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))] {S : Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (InfSet.sInf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) S)) (Set.iInter.{u1, succ u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (fun (s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) => Set.iInter.{u1, 0} P (Membership.Mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.hasMem.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) (fun (H : Membership.Mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.hasMem.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) s)))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))] {S : Set.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (InfSet.sInf.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) S)) (Set.iInter.{u1, succ u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (fun (s : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) => Set.iInter.{u1, 0} P (Membership.Mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.hasMem.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) (fun (H : Membership.Mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.hasMem.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) s)))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))] {S : Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (InfSet.sInf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfSetIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) S)) (Set.iInter.{u1, succ u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (fun (s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) => Set.iInter.{u1, 0} P (Membership.mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.instMembershipSet.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) (fun (H : Membership.mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.instMembershipSet.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) => SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) s)))
 Case conversion may be inaccurate. Consider using '#align order.ideal.coe_Inf Order.Ideal.coe_sInfₓ'. -/
@@ -661,7 +669,7 @@ theorem coe_sInf : (↑(sInf S) : Set P) = ⋂ s ∈ S, ↑s :=
 
 /- warning: order.ideal.mem_Inf -> Order.Ideal.mem_sInf is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))] {x : P} {S : Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (InfSet.sInf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) S)) (forall (s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))), (Membership.Mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.hasMem.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x s))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))] {x : P} {S : Set.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (InfSet.sInf.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) S)) (forall (s : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))), (Membership.Mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.hasMem.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x s))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))] {x : P} {S : Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (InfSet.sInf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfSetIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) S)) (forall (s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))), (Membership.mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.instMembershipSet.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) -> (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x s))
 Case conversion may be inaccurate. Consider using '#align order.ideal.mem_Inf Order.Ideal.mem_sInfₓ'. -/
@@ -688,7 +696,7 @@ variable {I J : Ideal P}
 
 /- warning: order.ideal.eq_sup_of_le_sup -> Order.Ideal.eq_sup_of_le_sup is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : DistribLattice.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {x : P} {i : P} {j : P}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) -> (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))) x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i j)) -> (Exists.{succ u1} P (fun (i' : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i' I) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i' I) => Exists.{succ u1} P (fun (j' : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j' J) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j' J) => Eq.{succ u1} P x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i' j'))))))
+  forall {P : Type.{u1}} [_inst_1 : DistribLattice.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {J : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {x : P} {i : P} {j : P}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) -> (LE.le.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))) x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i j)) -> (Exists.{succ u1} P (fun (i' : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i' I) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i' I) => Exists.{succ u1} P (fun (j' : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j' J) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j' J) => Eq.{succ u1} P x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i' j'))))))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : DistribLattice.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {x : P} {i : P} {j : P}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) -> (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) -> (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i j)) -> (Exists.{succ u1} P (fun (i' : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i' I) (Exists.{succ u1} P (fun (j' : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j' J) (Eq.{succ u1} P x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i' j'))))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.eq_sup_of_le_sup Order.Ideal.eq_sup_of_le_supₓ'. -/
@@ -704,7 +712,7 @@ theorem eq_sup_of_le_sup {x i j : P} (hi : i ∈ I) (hj : j ∈ J) (hx : x ≤ i
 
 /- warning: order.ideal.coe_sup_eq -> Order.Ideal.coe_sup_eq is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : DistribLattice.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Order.Ideal.hasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)) (SemilatticeInf.to_isDirected_ge.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))) I J)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (i : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) => Exists.{succ u1} P (fun (j : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) => Eq.{succ u1} P x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i j)))))))
+  forall {P : Type.{u1}} [_inst_1 : DistribLattice.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {J : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Order.Ideal.hasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)) (SemilatticeInf.to_isDirected_ge.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))) I J)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (i : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) => Exists.{succ u1} P (fun (j : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) => Eq.{succ u1} P x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i j)))))))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : DistribLattice.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)) (SemilatticeInf.to_isDirected_ge.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))) I J)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (i : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) (Exists.{succ u1} P (fun (j : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) (Eq.{succ u1} P x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i j)))))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.coe_sup_eq Order.Ideal.coe_sup_eqₓ'. -/
@@ -720,7 +728,12 @@ section BooleanAlgebra
 
 variable [BooleanAlgebra P] {x : P} {I : Ideal P}
 
-#print Order.Ideal.IsProper.not_mem_of_compl_mem /-
+/- warning: order.ideal.is_proper.not_mem_of_compl_mem -> Order.Ideal.IsProper.not_mem_of_compl_mem is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} P] {x : P} {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))}, (Order.Ideal.IsProper.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1))))))) I) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1))))))))) (HasCompl.compl.{u1} P (BooleanAlgebra.toHasCompl.{u1} P _inst_1) x) I) -> (Not (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1))))))))) x I))
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} P] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))}, (Order.Ideal.IsProper.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1)))))))) I) -> (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1)))))))))) (HasCompl.compl.{u1} P (BooleanAlgebra.toHasCompl.{u1} P _inst_1) x) I) -> (Not (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1)))))))))) x I))
+Case conversion may be inaccurate. Consider using '#align order.ideal.is_proper.not_mem_of_compl_mem Order.Ideal.IsProper.not_mem_of_compl_memₓ'. -/
 theorem IsProper.not_mem_of_compl_mem (hI : IsProper I) (hxc : xᶜ ∈ I) : x ∉ I :=
   by
   intro hx
@@ -728,15 +741,18 @@ theorem IsProper.not_mem_of_compl_mem (hI : IsProper I) (hxc : xᶜ ∈ I) : x 
   have ht : x ⊔ xᶜ ∈ I := sup_mem ‹_› ‹_›
   rwa [sup_compl_eq_top] at ht
 #align order.ideal.is_proper.not_mem_of_compl_mem Order.Ideal.IsProper.not_mem_of_compl_mem
--/
 
-#print Order.Ideal.IsProper.not_mem_or_compl_not_mem /-
+/- warning: order.ideal.is_proper.not_mem_or_compl_not_mem -> Order.Ideal.IsProper.not_mem_or_compl_not_mem is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} P] {x : P} {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))}, (Order.Ideal.IsProper.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1))))))) I) -> (Or (Not (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1))))))))) x I)) (Not (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1)))))))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} P _inst_1))))))))) (HasCompl.compl.{u1} P (BooleanAlgebra.toHasCompl.{u1} P _inst_1) x) I)))
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} P] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))}, (Order.Ideal.IsProper.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1)))))))) I) -> (Or (Not (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1)))))))))) x I)) (Not (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1))))))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (GeneralizedCoheytingAlgebra.toLattice.{u1} P (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} P (BiheytingAlgebra.toCoheytingAlgebra.{u1} P (BooleanAlgebra.toBiheytingAlgebra.{u1} P _inst_1)))))))))) (HasCompl.compl.{u1} P (BooleanAlgebra.toHasCompl.{u1} P _inst_1) x) I)))
+Case conversion may be inaccurate. Consider using '#align order.ideal.is_proper.not_mem_or_compl_not_mem Order.Ideal.IsProper.not_mem_or_compl_not_memₓ'. -/
 theorem IsProper.not_mem_or_compl_not_mem (hI : IsProper I) : x ∉ I ∨ xᶜ ∉ I :=
   by
   have h : xᶜ ∈ I → x ∉ I := hI.not_mem_of_compl_mem
   tauto
 #align order.ideal.is_proper.not_mem_or_compl_not_mem Order.Ideal.IsProper.not_mem_or_compl_not_mem
--/
 
 end BooleanAlgebra
 
@@ -778,11 +794,15 @@ theorem above_mem : D.above x ∈ D :=
 #align order.cofinal.above_mem Order.Cofinal.above_mem
 -/
 
-#print Order.Cofinal.le_above /-
+/- warning: order.cofinal.le_above -> Order.Cofinal.le_above is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (D : Order.Cofinal.{u1} P _inst_1) (x : P), LE.le.{u1} P (Preorder.toHasLe.{u1} P _inst_1) x (Order.Cofinal.above.{u1} P _inst_1 D x)
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (D : Order.Cofinal.{u1} P _inst_1) (x : P), LE.le.{u1} P (Preorder.toLE.{u1} P _inst_1) x (Order.Cofinal.above.{u1} P _inst_1 D x)
+Case conversion may be inaccurate. Consider using '#align order.cofinal.le_above Order.Cofinal.le_aboveₓ'. -/
 theorem le_above : x ≤ D.above x :=
   Exists.elim (Classical.choose_spec <| D.mem_gt x) fun _ b => b
 #align order.cofinal.le_above Order.Cofinal.le_above
--/
 
 end Cofinal
 
@@ -832,7 +852,12 @@ theorem sequenceOfCofinals.encode_mem (i : ι) :
   apply cofinal.above_mem
 #align order.sequence_of_cofinals.encode_mem Order.sequenceOfCofinals.encode_mem
 
-#print Order.idealOfCofinals /-
+/- warning: order.ideal_of_cofinals -> Order.idealOfCofinals is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P], P -> (forall {ι : Type.{u2}} [_inst_2 : Encodable.{u2} ι], (ι -> (Order.Cofinal.{u1} P _inst_1)) -> (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)))
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P], P -> (forall {ι : Type.{u2}} [_inst_2 : Encodable.{u2} ι], (ι -> (Order.Cofinal.{u1} P _inst_1)) -> (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)))
+Case conversion may be inaccurate. Consider using '#align order.ideal_of_cofinals Order.idealOfCofinalsₓ'. -/
 /-- Given an element `p : P` and a family `𝒟` of cofinal subsets of a preorder `P`,
   indexed by a countable type, `ideal_of_cofinals p 𝒟` is an ideal in `P` which
   - contains `p`, according to `mem_ideal_of_cofinals p 𝒟`, and
@@ -848,11 +873,10 @@ def idealOfCofinals : Ideal P
     ⟨_, ⟨max n m, le_rfl⟩, le_trans hn <| sequenceOfCofinals.monotone p 𝒟 (le_max_left _ _),
       le_trans hm <| sequenceOfCofinals.monotone p 𝒟 (le_max_right _ _)⟩
 #align order.ideal_of_cofinals Order.idealOfCofinals
--/
 
 /- warning: order.mem_ideal_of_cofinals -> Order.mem_idealOfCofinals is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (p : P) {ι : Type.{u2}} [_inst_2 : Encodable.{u2} ι] (𝒟 : ι -> (Order.Cofinal.{u1} P _inst_1)), Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P _inst_1))) p (Order.idealOfCofinals.{u1, u2} P _inst_1 p ι _inst_2 𝒟)
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (p : P) {ι : Type.{u2}} [_inst_2 : Encodable.{u2} ι] (𝒟 : ι -> (Order.Cofinal.{u1} P _inst_1)), Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P _inst_1))) p (Order.idealOfCofinals.{u1, u2} P _inst_1 p ι _inst_2 𝒟)
 but is expected to have type
   forall {P : Type.{u2}} [_inst_1 : Preorder.{u2} P] (p : P) {ι : Type.{u1}} [_inst_2 : Encodable.{u1} ι] (𝒟 : ι -> (Order.Cofinal.{u2} P _inst_1)), Membership.mem.{u2, u2} P (Order.Ideal.{u2} P (Preorder.toLE.{u2} P _inst_1)) (SetLike.instMembership.{u2, u2} (Order.Ideal.{u2} P (Preorder.toLE.{u2} P _inst_1)) P (Order.Ideal.instSetLikeIdeal.{u2} P (Preorder.toLE.{u2} P _inst_1))) p (Order.idealOfCofinals.{u2, u1} P _inst_1 p ι _inst_2 𝒟)
 Case conversion may be inaccurate. Consider using '#align order.mem_ideal_of_cofinals Order.mem_idealOfCofinalsₓ'. -/
@@ -862,7 +886,7 @@ theorem mem_idealOfCofinals : p ∈ idealOfCofinals p 𝒟 :=
 
 /- warning: order.cofinal_meets_ideal_of_cofinals -> Order.cofinal_meets_idealOfCofinals is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (p : P) {ι : Type.{u2}} [_inst_2 : Encodable.{u2} ι] (𝒟 : ι -> (Order.Cofinal.{u1} P _inst_1)) (i : ι), Exists.{succ u1} P (fun (x : P) => And (Membership.Mem.{u1, u1} P (Order.Cofinal.{u1} P _inst_1) (Order.Cofinal.hasMem.{u1} P _inst_1) x (𝒟 i)) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P _inst_1))) x (Order.idealOfCofinals.{u1, u2} P _inst_1 p ι _inst_2 𝒟)))
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (p : P) {ι : Type.{u2}} [_inst_2 : Encodable.{u2} ι] (𝒟 : ι -> (Order.Cofinal.{u1} P _inst_1)) (i : ι), Exists.{succ u1} P (fun (x : P) => And (Membership.Mem.{u1, u1} P (Order.Cofinal.{u1} P _inst_1) (Order.Cofinal.hasMem.{u1} P _inst_1) x (𝒟 i)) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P _inst_1))) x (Order.idealOfCofinals.{u1, u2} P _inst_1 p ι _inst_2 𝒟)))
 but is expected to have type
   forall {P : Type.{u2}} [_inst_1 : Preorder.{u2} P] (p : P) {ι : Type.{u1}} [_inst_2 : Encodable.{u1} ι] (𝒟 : ι -> (Order.Cofinal.{u2} P _inst_1)) (i : ι), Exists.{succ u2} P (fun (x : P) => And (Membership.mem.{u2, u2} P (Order.Cofinal.{u2} P _inst_1) (Order.Cofinal.instMembershipCofinal.{u2} P _inst_1) x (𝒟 i)) (Membership.mem.{u2, u2} P (Order.Ideal.{u2} P (Preorder.toLE.{u2} P _inst_1)) (SetLike.instMembership.{u2, u2} (Order.Ideal.{u2} P (Preorder.toLE.{u2} P _inst_1)) P (Order.Ideal.instSetLikeIdeal.{u2} P (Preorder.toLE.{u2} P _inst_1))) x (Order.idealOfCofinals.{u2, u1} P _inst_1 p ι _inst_2 𝒟)))
 Case conversion may be inaccurate. Consider using '#align order.cofinal_meets_ideal_of_cofinals Order.cofinal_meets_idealOfCofinalsₓ'. -/

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

@@ -638,37 +638,37 @@ instance : InfSet (Ideal P) :=
     { toLowerSet := ⨅ s ∈ S, toLowerSet s
       nonempty' :=
         ⟨⊥, by
-          rw [LowerSet.carrier_eq_coe, LowerSet.coe_infᵢ₂, Set.mem_interᵢ₂]
+          rw [LowerSet.carrier_eq_coe, LowerSet.coe_iInf₂, Set.mem_iInter₂]
           exact fun s _ => s.bot_mem⟩
       directed' := fun a ha b hb =>
         ⟨a ⊔ b,
           ⟨by
-            rw [LowerSet.carrier_eq_coe, LowerSet.coe_infᵢ₂, Set.mem_interᵢ₂] at ha hb⊢
+            rw [LowerSet.carrier_eq_coe, LowerSet.coe_iInf₂, Set.mem_iInter₂] at ha hb⊢
             exact fun s hs => sup_mem (ha _ hs) (hb _ hs), le_sup_left, le_sup_right⟩⟩ }⟩
 
 variable {S : Set (Ideal P)}
 
-/- warning: order.ideal.coe_Inf -> Order.Ideal.coe_infₛ is a dubious translation:
+/- warning: order.ideal.coe_Inf -> Order.Ideal.coe_sInf is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))] {S : Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (InfSet.infₛ.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) S)) (Set.interᵢ.{u1, succ u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (fun (s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) => Set.interᵢ.{u1, 0} P (Membership.Mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.hasMem.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) (fun (H : Membership.Mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.hasMem.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) s)))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))] {S : Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (InfSet.sInf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) S)) (Set.iInter.{u1, succ u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (fun (s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) => Set.iInter.{u1, 0} P (Membership.Mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.hasMem.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) (fun (H : Membership.Mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.hasMem.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) s)))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))] {S : Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (InfSet.infₛ.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfSetIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) S)) (Set.interᵢ.{u1, succ u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (fun (s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) => Set.interᵢ.{u1, 0} P (Membership.mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.instMembershipSet.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) (fun (H : Membership.mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.instMembershipSet.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) => SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) s)))
-Case conversion may be inaccurate. Consider using '#align order.ideal.coe_Inf Order.Ideal.coe_infₛₓ'. -/
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))] {S : Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (InfSet.sInf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfSetIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) S)) (Set.iInter.{u1, succ u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (fun (s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) => Set.iInter.{u1, 0} P (Membership.mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.instMembershipSet.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) (fun (H : Membership.mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.instMembershipSet.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) => SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) s)))
+Case conversion may be inaccurate. Consider using '#align order.ideal.coe_Inf Order.Ideal.coe_sInfₓ'. -/
 @[simp]
-theorem coe_infₛ : (↑(infₛ S) : Set P) = ⋂ s ∈ S, ↑s :=
-  LowerSet.coe_infᵢ₂ _
-#align order.ideal.coe_Inf Order.Ideal.coe_infₛ
+theorem coe_sInf : (↑(sInf S) : Set P) = ⋂ s ∈ S, ↑s :=
+  LowerSet.coe_iInf₂ _
+#align order.ideal.coe_Inf Order.Ideal.coe_sInf
 
-/- warning: order.ideal.mem_Inf -> Order.Ideal.mem_infₛ is a dubious translation:
+/- warning: order.ideal.mem_Inf -> Order.Ideal.mem_sInf is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))] {x : P} {S : Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (InfSet.infₛ.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) S)) (forall (s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))), (Membership.Mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.hasMem.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x s))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))] {x : P} {S : Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (InfSet.sInf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) S)) (forall (s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))), (Membership.Mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.hasMem.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x s))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))] {x : P} {S : Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (InfSet.infₛ.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfSetIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) S)) (forall (s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))), (Membership.mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.instMembershipSet.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) -> (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x s))
-Case conversion may be inaccurate. Consider using '#align order.ideal.mem_Inf Order.Ideal.mem_infₛₓ'. -/
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : OrderBot.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))] {x : P} {S : Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (InfSet.sInf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfSetIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) S)) (forall (s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))), (Membership.mem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Set.instMembershipSet.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) s S) -> (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x s))
+Case conversion may be inaccurate. Consider using '#align order.ideal.mem_Inf Order.Ideal.mem_sInfₓ'. -/
 @[simp]
-theorem mem_infₛ : x ∈ infₛ S ↔ ∀ s ∈ S, x ∈ s := by
+theorem mem_sInf : x ∈ sInf S ↔ ∀ s ∈ S, x ∈ s := by
   simp_rw [← SetLike.mem_coe, coe_Inf, mem_Inter₂]
-#align order.ideal.mem_Inf Order.Ideal.mem_infₛ
+#align order.ideal.mem_Inf Order.Ideal.mem_sInf
 
 instance : CompleteLattice (Ideal P) :=
   { Ideal.lattice,

mathlib commit https://github.com/leanprover-community/mathlib/commit/2651125b48fc5c170ab1111afd0817c903b1fc6c

@@ -301,21 +301,21 @@ Case conversion may be inaccurate. Consider using '#align order.ideal.is_proper.
 theorem IsProper.ne_top (hI : IsProper I) : I ≠ ⊤ := fun h => IsProper.ne_univ <| congr_arg coe h
 #align order.ideal.is_proper.ne_top Order.Ideal.IsProper.ne_top
 
-/- warning: is_coatom.is_proper -> Order.Ideal.IsCoatom.isProper is a dubious translation:
+/- warning: is_coatom.is_proper -> IsCoatom.isProper is a dubious translation:
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1)) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3) I) -> (Order.Ideal.IsProper.{u1} P _inst_1 I)
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1226 : P) (x._@.Mathlib.Order.Ideal._hyg.1228 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1226 x._@.Mathlib.Order.Ideal._hyg.1228)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I) -> (Order.Ideal.IsProper.{u1} P _inst_1 I)
-Case conversion may be inaccurate. Consider using '#align is_coatom.is_proper Order.Ideal.IsCoatom.isProperₓ'. -/
-theorem Order.Ideal.IsCoatom.isProper (hI : IsCoatom I) : IsProper I :=
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1223 : P) (x._@.Mathlib.Order.Ideal._hyg.1225 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1223 x._@.Mathlib.Order.Ideal._hyg.1225)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I) -> (Order.Ideal.IsProper.{u1} P _inst_1 I)
+Case conversion may be inaccurate. Consider using '#align is_coatom.is_proper IsCoatom.isProperₓ'. -/
+theorem IsCoatom.isProper (hI : IsCoatom I) : IsProper I :=
   isProper_of_ne_top hI.1
-#align is_coatom.is_proper Order.Ideal.IsCoatom.isProper
+#align is_coatom.is_proper IsCoatom.isProper
 
 /- warning: order.ideal.is_proper_iff_ne_top -> Order.Ideal.isProper_iff_ne_top is a dubious translation:
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, Iff (Order.Ideal.IsProper.{u1} P _inst_1 I) (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3))))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1262 : P) (x._@.Mathlib.Order.Ideal._hyg.1264 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1262 x._@.Mathlib.Order.Ideal._hyg.1264)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, Iff (Order.Ideal.IsProper.{u1} P _inst_1 I) (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3))))
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1258 : P) (x._@.Mathlib.Order.Ideal._hyg.1260 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1258 x._@.Mathlib.Order.Ideal._hyg.1260)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, Iff (Order.Ideal.IsProper.{u1} P _inst_1 I) (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.is_proper_iff_ne_top Order.Ideal.isProper_iff_ne_topₓ'. -/
 theorem isProper_iff_ne_top : IsProper I ↔ I ≠ ⊤ :=
   ⟨fun h => h.ne_top, fun h => isProper_of_ne_top h⟩
@@ -325,7 +325,7 @@ theorem isProper_iff_ne_top : IsProper I ↔ I ≠ ⊤ :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Order.Ideal.IsMaximal.{u1} P _inst_1 I) -> (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1)) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3) I)
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1317 : P) (x._@.Mathlib.Order.Ideal._hyg.1319 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1317 x._@.Mathlib.Order.Ideal._hyg.1319)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Order.Ideal.IsMaximal.{u1} P _inst_1 I) -> (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I)
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1313 : P) (x._@.Mathlib.Order.Ideal._hyg.1315 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1313 x._@.Mathlib.Order.Ideal._hyg.1315)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Order.Ideal.IsMaximal.{u1} P _inst_1 I) -> (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I)
 Case conversion may be inaccurate. Consider using '#align order.ideal.is_maximal.is_coatom Order.Ideal.IsMaximal.isCoatomₓ'. -/
 theorem IsMaximal.isCoatom (h : IsMaximal I) : IsCoatom I :=
   ⟨IsMaximal.to_isProper.ne_top, fun J h => ext <| IsMaximal.maximal_proper h⟩
@@ -335,27 +335,27 @@ theorem IsMaximal.isCoatom (h : IsMaximal I) : IsCoatom I :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1} [_inst_4 : Order.Ideal.IsMaximal.{u1} P _inst_1 I], IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1)) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3) I
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1368 : P) (x._@.Mathlib.Order.Ideal._hyg.1370 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1368 x._@.Mathlib.Order.Ideal._hyg.1370)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1} [_inst_4 : Order.Ideal.IsMaximal.{u1} P _inst_1 I], IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1364 : P) (x._@.Mathlib.Order.Ideal._hyg.1366 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1364 x._@.Mathlib.Order.Ideal._hyg.1366)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1} [_inst_4 : Order.Ideal.IsMaximal.{u1} P _inst_1 I], IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I
 Case conversion may be inaccurate. Consider using '#align order.ideal.is_maximal.is_coatom' Order.Ideal.IsMaximal.isCoatom'ₓ'. -/
 theorem IsMaximal.isCoatom' [IsMaximal I] : IsCoatom I :=
   IsMaximal.isCoatom ‹_›
 #align order.ideal.is_maximal.is_coatom' Order.Ideal.IsMaximal.isCoatom'
 
-/- warning: is_coatom.is_maximal -> Order.Ideal.IsCoatom.isMaximal is a dubious translation:
+/- warning: is_coatom.is_maximal -> IsCoatom.isMaximal is a dubious translation:
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1)) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3) I) -> (Order.Ideal.IsMaximal.{u1} P _inst_1 I)
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1416 : P) (x._@.Mathlib.Order.Ideal._hyg.1418 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1416 x._@.Mathlib.Order.Ideal._hyg.1418)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I) -> (Order.Ideal.IsMaximal.{u1} P _inst_1 I)
-Case conversion may be inaccurate. Consider using '#align is_coatom.is_maximal Order.Ideal.IsCoatom.isMaximalₓ'. -/
-theorem Order.Ideal.IsCoatom.isMaximal (hI : IsCoatom I) : IsMaximal I :=
-  { Order.Ideal.IsCoatom.isProper ‹_› with maximal_proper := fun _ _ => by simp [hI.2 _ ‹_›] }
-#align is_coatom.is_maximal Order.Ideal.IsCoatom.isMaximal
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1409 : P) (x._@.Mathlib.Order.Ideal._hyg.1411 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1409 x._@.Mathlib.Order.Ideal._hyg.1411)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I) -> (Order.Ideal.IsMaximal.{u1} P _inst_1 I)
+Case conversion may be inaccurate. Consider using '#align is_coatom.is_maximal IsCoatom.isMaximalₓ'. -/
+theorem IsCoatom.isMaximal (hI : IsCoatom I) : IsMaximal I :=
+  { IsCoatom.isProper ‹_› with maximal_proper := fun _ _ => by simp [hI.2 _ ‹_›] }
+#align is_coatom.is_maximal IsCoatom.isMaximal
 
 /- warning: order.ideal.is_maximal_iff_is_coatom -> Order.Ideal.isMaximal_iff_isCoatom is a dubious translation:
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, Iff (Order.Ideal.IsMaximal.{u1} P _inst_1 I) (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1)) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3) I)
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1476 : P) (x._@.Mathlib.Order.Ideal._hyg.1478 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1476 x._@.Mathlib.Order.Ideal._hyg.1478)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, Iff (Order.Ideal.IsMaximal.{u1} P _inst_1 I) (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I)
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1468 : P) (x._@.Mathlib.Order.Ideal._hyg.1470 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1468 x._@.Mathlib.Order.Ideal._hyg.1470)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, Iff (Order.Ideal.IsMaximal.{u1} P _inst_1 I) (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I)
 Case conversion may be inaccurate. Consider using '#align order.ideal.is_maximal_iff_is_coatom Order.Ideal.isMaximal_iff_isCoatomₓ'. -/
 theorem isMaximal_iff_isCoatom : IsMaximal I ↔ IsCoatom I :=
   ⟨fun h => h.IsCoatom, fun h => h.IsMaximal⟩
@@ -577,7 +577,7 @@ instance : Lattice (Ideal P) :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) s t)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (a : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) => Exists.{succ u1} P (fun (b : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) => LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) a b)))))))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2878 : P) (x._@.Mathlib.Order.Ideal._hyg.2880 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2878 x._@.Mathlib.Order.Ideal._hyg.2880)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (a : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) (Exists.{succ u1} P (fun (b : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) a b)))))))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2870 : P) (x._@.Mathlib.Order.Ideal._hyg.2872 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2870 x._@.Mathlib.Order.Ideal._hyg.2872)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (a : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) (Exists.{succ u1} P (fun (b : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) a b)))))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.coe_sup Order.Ideal.coe_supₓ'. -/
 @[simp]
 theorem coe_sup : ↑(s ⊔ t) = { x | ∃ a ∈ s, ∃ b ∈ t, x ≤ a ⊔ b } :=
@@ -588,7 +588,7 @@ theorem coe_sup : ↑(s ⊔ t) = { x | ∃ a ∈ s, ∃ b ∈ t, x ≤ a ⊔ b }
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) s t)) (Inter.inter.{u1} (Set.{u1} P) (Set.hasInter.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) s) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) t))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2977 : P) (x._@.Mathlib.Order.Ideal._hyg.2979 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2977 x._@.Mathlib.Order.Ideal._hyg.2979)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (Inter.inter.{u1} (Set.{u1} P) (Set.instInterSet.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) s) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) t))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2969 : P) (x._@.Mathlib.Order.Ideal._hyg.2971 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2969 x._@.Mathlib.Order.Ideal._hyg.2971)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (Inter.inter.{u1} (Set.{u1} P) (Set.instInterSet.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) s) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) t))
 Case conversion may be inaccurate. Consider using '#align order.ideal.coe_inf Order.Ideal.coe_infₓ'. -/
 @[simp]
 theorem coe_inf : (↑(s ⊓ t) : Set P) = s ∩ t :=
@@ -599,7 +599,7 @@ theorem coe_inf : (↑(s ⊓ t) : Set P) = s ∩ t :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) I J)) (And (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x J))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3039 : P) (x._@.Mathlib.Order.Ideal._hyg.3041 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3039 x._@.Mathlib.Order.Ideal._hyg.3041)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x J))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3031 : P) (x._@.Mathlib.Order.Ideal._hyg.3033 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3031 x._@.Mathlib.Order.Ideal._hyg.3033)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x J))
 Case conversion may be inaccurate. Consider using '#align order.ideal.mem_inf Order.Ideal.mem_infₓ'. -/
 @[simp]
 theorem mem_inf : x ∈ I ⊓ J ↔ x ∈ I ∧ x ∈ J :=
@@ -610,7 +610,7 @@ theorem mem_inf : x ∈ I ⊓ J ↔ x ∈ I ∧ x ∈ J :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) I J)) (Exists.{succ u1} P (fun (i : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) => Exists.{succ u1} P (fun (j : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) => LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) i j))))))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3100 : P) (x._@.Mathlib.Order.Ideal._hyg.3102 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3100 x._@.Mathlib.Order.Ideal._hyg.3102)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (Exists.{succ u1} P (fun (i : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) (Exists.{succ u1} P (fun (j : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) i j))))))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3092 : P) (x._@.Mathlib.Order.Ideal._hyg.3094 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3092 x._@.Mathlib.Order.Ideal._hyg.3094)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (Exists.{succ u1} P (fun (i : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) (Exists.{succ u1} P (fun (j : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) i j))))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.mem_sup Order.Ideal.mem_supₓ'. -/
 @[simp]
 theorem mem_sup : x ∈ I ⊔ J ↔ ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j :=
@@ -621,7 +621,7 @@ theorem mem_sup : x ∈ I ⊔ J ↔ ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Not (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I)) -> (LT.lt.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Preorder.toLT.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.partialOrder.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))))) I (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) I (Order.Ideal.principal.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)) x)))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3192 : P) (x._@.Mathlib.Order.Ideal._hyg.3194 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3192 x._@.Mathlib.Order.Ideal._hyg.3194)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Not (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I)) -> (LT.lt.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Preorder.toLT.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instPartialOrderIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))))) I (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I (Order.Ideal.principal.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)) x)))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3184 : P) (x._@.Mathlib.Order.Ideal._hyg.3186 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3184 x._@.Mathlib.Order.Ideal._hyg.3186)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Not (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I)) -> (LT.lt.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Preorder.toLT.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instPartialOrderIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))))) I (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I (Order.Ideal.principal.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)) x)))
 Case conversion may be inaccurate. Consider using '#align order.ideal.lt_sup_principal_of_not_mem Order.Ideal.lt_sup_principal_of_not_memₓ'. -/
 theorem lt_sup_principal_of_not_mem (hx : x ∉ I) : I < I ⊔ principal x :=
   le_sup_left.lt_of_ne fun h => hx <| by simpa only [left_eq_sup, principal_le_iff] using h

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

@@ -577,7 +577,7 @@ instance : Lattice (Ideal P) :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) s t)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (a : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) => Exists.{succ u1} P (fun (b : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) => LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) a b)))))))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2881 : P) (x._@.Mathlib.Order.Ideal._hyg.2883 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2881 x._@.Mathlib.Order.Ideal._hyg.2883)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (a : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) (Exists.{succ u1} P (fun (b : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) a b)))))))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2878 : P) (x._@.Mathlib.Order.Ideal._hyg.2880 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2878 x._@.Mathlib.Order.Ideal._hyg.2880)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (a : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) (Exists.{succ u1} P (fun (b : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) a b)))))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.coe_sup Order.Ideal.coe_supₓ'. -/
 @[simp]
 theorem coe_sup : ↑(s ⊔ t) = { x | ∃ a ∈ s, ∃ b ∈ t, x ≤ a ⊔ b } :=
@@ -588,7 +588,7 @@ theorem coe_sup : ↑(s ⊔ t) = { x | ∃ a ∈ s, ∃ b ∈ t, x ≤ a ⊔ b }
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) s t)) (Inter.inter.{u1} (Set.{u1} P) (Set.hasInter.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) s) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) t))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2980 : P) (x._@.Mathlib.Order.Ideal._hyg.2982 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2980 x._@.Mathlib.Order.Ideal._hyg.2982)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (Inter.inter.{u1} (Set.{u1} P) (Set.instInterSet.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) s) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) t))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2977 : P) (x._@.Mathlib.Order.Ideal._hyg.2979 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2977 x._@.Mathlib.Order.Ideal._hyg.2979)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (Inter.inter.{u1} (Set.{u1} P) (Set.instInterSet.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) s) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) t))
 Case conversion may be inaccurate. Consider using '#align order.ideal.coe_inf Order.Ideal.coe_infₓ'. -/
 @[simp]
 theorem coe_inf : (↑(s ⊓ t) : Set P) = s ∩ t :=
@@ -599,7 +599,7 @@ theorem coe_inf : (↑(s ⊓ t) : Set P) = s ∩ t :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) I J)) (And (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x J))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3042 : P) (x._@.Mathlib.Order.Ideal._hyg.3044 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3042 x._@.Mathlib.Order.Ideal._hyg.3044)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x J))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3039 : P) (x._@.Mathlib.Order.Ideal._hyg.3041 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3039 x._@.Mathlib.Order.Ideal._hyg.3041)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x J))
 Case conversion may be inaccurate. Consider using '#align order.ideal.mem_inf Order.Ideal.mem_infₓ'. -/
 @[simp]
 theorem mem_inf : x ∈ I ⊓ J ↔ x ∈ I ∧ x ∈ J :=
@@ -610,7 +610,7 @@ theorem mem_inf : x ∈ I ⊓ J ↔ x ∈ I ∧ x ∈ J :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) I J)) (Exists.{succ u1} P (fun (i : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) => Exists.{succ u1} P (fun (j : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) => LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) i j))))))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3103 : P) (x._@.Mathlib.Order.Ideal._hyg.3105 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3103 x._@.Mathlib.Order.Ideal._hyg.3105)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (Exists.{succ u1} P (fun (i : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) (Exists.{succ u1} P (fun (j : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) i j))))))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3100 : P) (x._@.Mathlib.Order.Ideal._hyg.3102 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3100 x._@.Mathlib.Order.Ideal._hyg.3102)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (Exists.{succ u1} P (fun (i : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) (Exists.{succ u1} P (fun (j : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) i j))))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.mem_sup Order.Ideal.mem_supₓ'. -/
 @[simp]
 theorem mem_sup : x ∈ I ⊔ J ↔ ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j :=
@@ -621,7 +621,7 @@ theorem mem_sup : x ∈ I ⊔ J ↔ ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Not (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I)) -> (LT.lt.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Preorder.toLT.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.partialOrder.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))))) I (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) I (Order.Ideal.principal.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)) x)))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3195 : P) (x._@.Mathlib.Order.Ideal._hyg.3197 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3195 x._@.Mathlib.Order.Ideal._hyg.3197)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Not (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I)) -> (LT.lt.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Preorder.toLT.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instPartialOrderIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))))) I (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I (Order.Ideal.principal.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)) x)))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3192 : P) (x._@.Mathlib.Order.Ideal._hyg.3194 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3192 x._@.Mathlib.Order.Ideal._hyg.3194)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Not (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I)) -> (LT.lt.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Preorder.toLT.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instPartialOrderIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))))) I (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I (Order.Ideal.principal.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)) x)))
 Case conversion may be inaccurate. Consider using '#align order.ideal.lt_sup_principal_of_not_mem Order.Ideal.lt_sup_principal_of_not_memₓ'. -/
 theorem lt_sup_principal_of_not_mem (hx : x ∉ I) : I < I ⊔ principal x :=
   le_sup_left.lt_of_ne fun h => hx <| by simpa only [left_eq_sup, principal_le_iff] using h

mathlib commit https://github.com/leanprover-community/mathlib/commit/4c586d291f189eecb9d00581aeb3dd998ac34442

@@ -553,8 +553,8 @@ instance : Sup (Ideal P) :=
           le_sup_left, le_sup_right⟩
       lower' := fun x y h ⟨yi, _, yj, _, _⟩ => ⟨yi, ‹_›, yj, ‹_›, h.trans ‹_›⟩ }⟩
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:628:2: warning: expanding binder collection (i «expr ∈ » I) -/
-/- ./././Mathport/Syntax/Translate/Basic.lean:628:2: warning: expanding binder collection (j «expr ∈ » J) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (i «expr ∈ » I) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (j «expr ∈ » J) -/
 instance : Lattice (Ideal P) :=
   { Ideal.partialOrder with
     sup := (· ⊔ ·)

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

@@ -238,7 +238,7 @@ class IsMaximal (I : Ideal P) extends IsProper I : Prop where
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P _inst_1)] (I : Order.Ideal.{u1} P _inst_1) (J : Order.Ideal.{u1} P _inst_1), Set.Nonempty.{u1} P (Inter.inter.{u1} (Set.{u1} P) (Set.hasInter.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) I) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) J))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.882 : P) (x._@.Mathlib.Order.Ideal._hyg.884 : P) => GE.ge.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.882 x._@.Mathlib.Order.Ideal._hyg.884)] (I : Order.Ideal.{u1} P _inst_1) (J : Order.Ideal.{u1} P _inst_1), Set.Nonempty.{u1} P (Inter.inter.{u1} (Set.{u1} P) (Set.instInterSet.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) I) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) J))
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.883 : P) (x._@.Mathlib.Order.Ideal._hyg.885 : P) => GE.ge.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.883 x._@.Mathlib.Order.Ideal._hyg.885)] (I : Order.Ideal.{u1} P _inst_1) (J : Order.Ideal.{u1} P _inst_1), Set.Nonempty.{u1} P (Inter.inter.{u1} (Set.{u1} P) (Set.instInterSet.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) I) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) J))
 Case conversion may be inaccurate. Consider using '#align order.ideal.inter_nonempty Order.Ideal.inter_nonemptyₓ'. -/
 theorem inter_nonempty [IsDirected P (· ≥ ·)] (I J : Ideal P) : (I ∩ J : Set P).Nonempty :=
   by
@@ -264,7 +264,7 @@ instance : OrderTop (Ideal P)
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P], Eq.{succ u1} (LowerSet.{u1} P _inst_1) (Order.Ideal.toLowerSet.{u1} P _inst_1 (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3)))) (Top.top.{u1} (LowerSet.{u1} P _inst_1) (LowerSet.hasTop.{u1} P _inst_1))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1033 : P) (x._@.Mathlib.Order.Ideal._hyg.1035 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1033 x._@.Mathlib.Order.Ideal._hyg.1035)] [_inst_3 : Nonempty.{succ u1} P], Eq.{succ u1} (LowerSet.{u1} P _inst_1) (Order.Ideal.toLowerSet.{u1} P _inst_1 (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3)))) (Top.top.{u1} (LowerSet.{u1} P _inst_1) (LowerSet.instTopLowerSet.{u1} P _inst_1))
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1034 : P) (x._@.Mathlib.Order.Ideal._hyg.1036 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1034 x._@.Mathlib.Order.Ideal._hyg.1036)] [_inst_3 : Nonempty.{succ u1} P], Eq.{succ u1} (LowerSet.{u1} P _inst_1) (Order.Ideal.toLowerSet.{u1} P _inst_1 (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3)))) (Top.top.{u1} (LowerSet.{u1} P _inst_1) (LowerSet.instTopLowerSet.{u1} P _inst_1))
 Case conversion may be inaccurate. Consider using '#align order.ideal.top_to_lower_set Order.Ideal.top_toLowerSetₓ'. -/
 @[simp]
 theorem top_toLowerSet : (⊤ : Ideal P).toLowerSet = ⊤ :=
@@ -275,7 +275,7 @@ theorem top_toLowerSet : (⊤ : Ideal P).toLowerSet = ⊤ :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P], Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P _inst_1) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.setLike.{u1} P _inst_1)))) (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3)))) (Set.univ.{u1} P)
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1076 : P) (x._@.Mathlib.Order.Ideal._hyg.1078 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1076 x._@.Mathlib.Order.Ideal._hyg.1078)] [_inst_3 : Nonempty.{succ u1} P], Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3)))) (Set.univ.{u1} P)
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1077 : P) (x._@.Mathlib.Order.Ideal._hyg.1079 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1077 x._@.Mathlib.Order.Ideal._hyg.1079)] [_inst_3 : Nonempty.{succ u1} P], Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P _inst_1) P (Order.Ideal.instSetLikeIdeal.{u1} P _inst_1) (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3)))) (Set.univ.{u1} P)
 Case conversion may be inaccurate. Consider using '#align order.ideal.coe_top Order.Ideal.coe_topₓ'. -/
 @[simp]
 theorem coe_top : ((⊤ : Ideal P) : Set P) = univ :=
@@ -286,7 +286,7 @@ theorem coe_top : ((⊤ : Ideal P) : Set P) = univ :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3)))) -> (Order.Ideal.IsProper.{u1} P _inst_1 I)
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1122 : P) (x._@.Mathlib.Order.Ideal._hyg.1124 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1122 x._@.Mathlib.Order.Ideal._hyg.1124)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3)))) -> (Order.Ideal.IsProper.{u1} P _inst_1 I)
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1123 : P) (x._@.Mathlib.Order.Ideal._hyg.1125 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1123 x._@.Mathlib.Order.Ideal._hyg.1125)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3)))) -> (Order.Ideal.IsProper.{u1} P _inst_1 I)
 Case conversion may be inaccurate. Consider using '#align order.ideal.is_proper_of_ne_top Order.Ideal.isProper_of_ne_topₓ'. -/
 theorem isProper_of_ne_top (ne_top : I ≠ ⊤) : IsProper I :=
   ⟨fun h => ne_top <| ext h⟩
@@ -296,7 +296,7 @@ theorem isProper_of_ne_top (ne_top : I ≠ ⊤) : IsProper I :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Order.Ideal.IsProper.{u1} P _inst_1 I) -> (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3))))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1173 : P) (x._@.Mathlib.Order.Ideal._hyg.1175 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1173 x._@.Mathlib.Order.Ideal._hyg.1175)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Order.Ideal.IsProper.{u1} P _inst_1 I) -> (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3))))
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1174 : P) (x._@.Mathlib.Order.Ideal._hyg.1176 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1174 x._@.Mathlib.Order.Ideal._hyg.1176)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Order.Ideal.IsProper.{u1} P _inst_1 I) -> (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.is_proper.ne_top Order.Ideal.IsProper.ne_topₓ'. -/
 theorem IsProper.ne_top (hI : IsProper I) : I ≠ ⊤ := fun h => IsProper.ne_univ <| congr_arg coe h
 #align order.ideal.is_proper.ne_top Order.Ideal.IsProper.ne_top
@@ -305,7 +305,7 @@ theorem IsProper.ne_top (hI : IsProper I) : I ≠ ⊤ := fun h => IsProper.ne_un
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1)) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3) I) -> (Order.Ideal.IsProper.{u1} P _inst_1 I)
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1225 : P) (x._@.Mathlib.Order.Ideal._hyg.1227 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1225 x._@.Mathlib.Order.Ideal._hyg.1227)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I) -> (Order.Ideal.IsProper.{u1} P _inst_1 I)
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1226 : P) (x._@.Mathlib.Order.Ideal._hyg.1228 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1226 x._@.Mathlib.Order.Ideal._hyg.1228)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I) -> (Order.Ideal.IsProper.{u1} P _inst_1 I)
 Case conversion may be inaccurate. Consider using '#align is_coatom.is_proper Order.Ideal.IsCoatom.isProperₓ'. -/
 theorem Order.Ideal.IsCoatom.isProper (hI : IsCoatom I) : IsProper I :=
   isProper_of_ne_top hI.1
@@ -315,7 +315,7 @@ theorem Order.Ideal.IsCoatom.isProper (hI : IsCoatom I) : IsProper I :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, Iff (Order.Ideal.IsProper.{u1} P _inst_1 I) (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toHasTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1))) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3))))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1261 : P) (x._@.Mathlib.Order.Ideal._hyg.1263 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1261 x._@.Mathlib.Order.Ideal._hyg.1263)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, Iff (Order.Ideal.IsProper.{u1} P _inst_1 I) (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3))))
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1262 : P) (x._@.Mathlib.Order.Ideal._hyg.1264 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1262 x._@.Mathlib.Order.Ideal._hyg.1264)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, Iff (Order.Ideal.IsProper.{u1} P _inst_1 I) (Ne.{succ u1} (Order.Ideal.{u1} P _inst_1) I (Top.top.{u1} (Order.Ideal.{u1} P _inst_1) (OrderTop.toTop.{u1} (Order.Ideal.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1))) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.is_proper_iff_ne_top Order.Ideal.isProper_iff_ne_topₓ'. -/
 theorem isProper_iff_ne_top : IsProper I ↔ I ≠ ⊤ :=
   ⟨fun h => h.ne_top, fun h => isProper_of_ne_top h⟩
@@ -325,7 +325,7 @@ theorem isProper_iff_ne_top : IsProper I ↔ I ≠ ⊤ :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Order.Ideal.IsMaximal.{u1} P _inst_1 I) -> (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1)) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3) I)
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1316 : P) (x._@.Mathlib.Order.Ideal._hyg.1318 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1316 x._@.Mathlib.Order.Ideal._hyg.1318)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Order.Ideal.IsMaximal.{u1} P _inst_1 I) -> (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I)
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1317 : P) (x._@.Mathlib.Order.Ideal._hyg.1319 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1317 x._@.Mathlib.Order.Ideal._hyg.1319)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (Order.Ideal.IsMaximal.{u1} P _inst_1 I) -> (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I)
 Case conversion may be inaccurate. Consider using '#align order.ideal.is_maximal.is_coatom Order.Ideal.IsMaximal.isCoatomₓ'. -/
 theorem IsMaximal.isCoatom (h : IsMaximal I) : IsCoatom I :=
   ⟨IsMaximal.to_isProper.ne_top, fun J h => ext <| IsMaximal.maximal_proper h⟩
@@ -335,7 +335,7 @@ theorem IsMaximal.isCoatom (h : IsMaximal I) : IsCoatom I :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1} [_inst_4 : Order.Ideal.IsMaximal.{u1} P _inst_1 I], IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1)) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3) I
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1367 : P) (x._@.Mathlib.Order.Ideal._hyg.1369 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1367 x._@.Mathlib.Order.Ideal._hyg.1369)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1} [_inst_4 : Order.Ideal.IsMaximal.{u1} P _inst_1 I], IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1368 : P) (x._@.Mathlib.Order.Ideal._hyg.1370 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1368 x._@.Mathlib.Order.Ideal._hyg.1370)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1} [_inst_4 : Order.Ideal.IsMaximal.{u1} P _inst_1 I], IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I
 Case conversion may be inaccurate. Consider using '#align order.ideal.is_maximal.is_coatom' Order.Ideal.IsMaximal.isCoatom'ₓ'. -/
 theorem IsMaximal.isCoatom' [IsMaximal I] : IsCoatom I :=
   IsMaximal.isCoatom ‹_›
@@ -345,7 +345,7 @@ theorem IsMaximal.isCoatom' [IsMaximal I] : IsCoatom I :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1)) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3) I) -> (Order.Ideal.IsMaximal.{u1} P _inst_1 I)
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1415 : P) (x._@.Mathlib.Order.Ideal._hyg.1417 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1415 x._@.Mathlib.Order.Ideal._hyg.1417)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I) -> (Order.Ideal.IsMaximal.{u1} P _inst_1 I)
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1416 : P) (x._@.Mathlib.Order.Ideal._hyg.1418 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1416 x._@.Mathlib.Order.Ideal._hyg.1418)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I) -> (Order.Ideal.IsMaximal.{u1} P _inst_1 I)
 Case conversion may be inaccurate. Consider using '#align is_coatom.is_maximal Order.Ideal.IsCoatom.isMaximalₓ'. -/
 theorem Order.Ideal.IsCoatom.isMaximal (hI : IsCoatom I) : IsMaximal I :=
   { Order.Ideal.IsCoatom.isProper ‹_› with maximal_proper := fun _ _ => by simp [hI.2 _ ‹_›] }
@@ -355,7 +355,7 @@ theorem Order.Ideal.IsCoatom.isMaximal (hI : IsCoatom I) : IsMaximal I :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (LE.le.{u1} P _inst_1)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, Iff (Order.Ideal.IsMaximal.{u1} P _inst_1 I) (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.partialOrder.{u1} P _inst_1)) (Order.Ideal.orderTop.{u1} P _inst_1 _inst_2 _inst_3) I)
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1475 : P) (x._@.Mathlib.Order.Ideal._hyg.1477 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1475 x._@.Mathlib.Order.Ideal._hyg.1477)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, Iff (Order.Ideal.IsMaximal.{u1} P _inst_1 I) (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I)
+  forall {P : Type.{u1}} [_inst_1 : LE.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.1476 : P) (x._@.Mathlib.Order.Ideal._hyg.1478 : P) => LE.le.{u1} P _inst_1 x._@.Mathlib.Order.Ideal._hyg.1476 x._@.Mathlib.Order.Ideal._hyg.1478)] [_inst_3 : Nonempty.{succ u1} P] {I : Order.Ideal.{u1} P _inst_1}, Iff (Order.Ideal.IsMaximal.{u1} P _inst_1 I) (IsCoatom.{u1} (Order.Ideal.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P _inst_1) (Order.Ideal.instPartialOrderIdeal.{u1} P _inst_1)) (Order.Ideal.instOrderTopIdealToLEToPreorderInstPartialOrderIdeal.{u1} P _inst_1 _inst_2 _inst_3) I)
 Case conversion may be inaccurate. Consider using '#align order.ideal.is_maximal_iff_is_coatom Order.Ideal.isMaximal_iff_isCoatomₓ'. -/
 theorem isMaximal_iff_isCoatom : IsMaximal I ↔ IsCoatom I :=
   ⟨fun h => h.IsCoatom, fun h => h.IsMaximal⟩
@@ -577,7 +577,7 @@ instance : Lattice (Ideal P) :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) s t)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (a : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) => Exists.{succ u1} P (fun (b : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) => LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) a b)))))))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2880 : P) (x._@.Mathlib.Order.Ideal._hyg.2882 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2880 x._@.Mathlib.Order.Ideal._hyg.2882)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (a : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) (Exists.{succ u1} P (fun (b : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) a b)))))))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2881 : P) (x._@.Mathlib.Order.Ideal._hyg.2883 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2881 x._@.Mathlib.Order.Ideal._hyg.2883)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (a : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) (Exists.{succ u1} P (fun (b : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) a b)))))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.coe_sup Order.Ideal.coe_supₓ'. -/
 @[simp]
 theorem coe_sup : ↑(s ⊔ t) = { x | ∃ a ∈ s, ∃ b ∈ t, x ≤ a ⊔ b } :=
@@ -588,7 +588,7 @@ theorem coe_sup : ↑(s ⊔ t) = { x | ∃ a ∈ s, ∃ b ∈ t, x ≤ a ⊔ b }
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) s t)) (Inter.inter.{u1} (Set.{u1} P) (Set.hasInter.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) s) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) t))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2979 : P) (x._@.Mathlib.Order.Ideal._hyg.2981 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2979 x._@.Mathlib.Order.Ideal._hyg.2981)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (Inter.inter.{u1} (Set.{u1} P) (Set.instInterSet.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) s) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) t))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2980 : P) (x._@.Mathlib.Order.Ideal._hyg.2982 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2980 x._@.Mathlib.Order.Ideal._hyg.2982)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (Inter.inter.{u1} (Set.{u1} P) (Set.instInterSet.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) s) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) t))
 Case conversion may be inaccurate. Consider using '#align order.ideal.coe_inf Order.Ideal.coe_infₓ'. -/
 @[simp]
 theorem coe_inf : (↑(s ⊓ t) : Set P) = s ∩ t :=
@@ -599,7 +599,7 @@ theorem coe_inf : (↑(s ⊓ t) : Set P) = s ∩ t :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) I J)) (And (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x J))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3041 : P) (x._@.Mathlib.Order.Ideal._hyg.3043 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3041 x._@.Mathlib.Order.Ideal._hyg.3043)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x J))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3042 : P) (x._@.Mathlib.Order.Ideal._hyg.3044 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3042 x._@.Mathlib.Order.Ideal._hyg.3044)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x J))
 Case conversion may be inaccurate. Consider using '#align order.ideal.mem_inf Order.Ideal.mem_infₓ'. -/
 @[simp]
 theorem mem_inf : x ∈ I ⊓ J ↔ x ∈ I ∧ x ∈ J :=
@@ -610,7 +610,7 @@ theorem mem_inf : x ∈ I ⊓ J ↔ x ∈ I ∧ x ∈ J :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) I J)) (Exists.{succ u1} P (fun (i : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) => Exists.{succ u1} P (fun (j : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) => LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) i j))))))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3102 : P) (x._@.Mathlib.Order.Ideal._hyg.3104 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3102 x._@.Mathlib.Order.Ideal._hyg.3104)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (Exists.{succ u1} P (fun (i : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) (Exists.{succ u1} P (fun (j : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) i j))))))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3103 : P) (x._@.Mathlib.Order.Ideal._hyg.3105 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3103 x._@.Mathlib.Order.Ideal._hyg.3105)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (Exists.{succ u1} P (fun (i : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) (Exists.{succ u1} P (fun (j : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) i j))))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.mem_sup Order.Ideal.mem_supₓ'. -/
 @[simp]
 theorem mem_sup : x ∈ I ⊔ J ↔ ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j :=
@@ -621,7 +621,7 @@ theorem mem_sup : x ∈ I ⊔ J ↔ ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Not (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I)) -> (LT.lt.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Preorder.toLT.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.partialOrder.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))))) I (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) I (Order.Ideal.principal.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)) x)))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3194 : P) (x._@.Mathlib.Order.Ideal._hyg.3196 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3194 x._@.Mathlib.Order.Ideal._hyg.3196)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Not (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I)) -> (LT.lt.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Preorder.toLT.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instPartialOrderIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))))) I (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I (Order.Ideal.principal.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)) x)))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3195 : P) (x._@.Mathlib.Order.Ideal._hyg.3197 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3195 x._@.Mathlib.Order.Ideal._hyg.3197)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Not (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I)) -> (LT.lt.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Preorder.toLT.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instPartialOrderIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))))) I (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I (Order.Ideal.principal.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)) x)))
 Case conversion may be inaccurate. Consider using '#align order.ideal.lt_sup_principal_of_not_mem Order.Ideal.lt_sup_principal_of_not_memₓ'. -/
 theorem lt_sup_principal_of_not_mem (hx : x ∉ I) : I < I ⊔ principal x :=
   le_sup_left.lt_of_ne fun h => hx <| by simpa only [left_eq_sup, principal_le_iff] using h

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

@@ -494,20 +494,28 @@ section SemilatticeSup
 
 variable [SemilatticeSup P] {x y : P} {I s : Ideal P}
 
-#print Order.Ideal.sup_mem /-
+/- warning: order.ideal.sup_mem -> Order.Ideal.sup_mem is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] {x : P} {y : P} {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x s) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) y s) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) x y) s)
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] {x : P} {y : P} {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x s) -> (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) y s) -> (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) x y) s)
+Case conversion may be inaccurate. Consider using '#align order.ideal.sup_mem Order.Ideal.sup_memₓ'. -/
 /-- A specific witness of `I.directed` when `P` has joins. -/
 theorem sup_mem (hx : x ∈ s) (hy : y ∈ s) : x ⊔ y ∈ s :=
   let ⟨z, hz, hx, hy⟩ := s.Directed x hx y hy
   s.lower (sup_le hx hy) hz
 #align order.ideal.sup_mem Order.Ideal.sup_mem
--/
 
-#print Order.Ideal.sup_mem_iff /-
+/- warning: order.ideal.sup_mem_iff -> Order.Ideal.sup_mem_iff is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] {x : P} {y : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) x y) I) (And (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) y I))
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] {x : P} {y : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) x y) I) (And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) y I))
+Case conversion may be inaccurate. Consider using '#align order.ideal.sup_mem_iff Order.Ideal.sup_mem_iffₓ'. -/
 @[simp]
 theorem sup_mem_iff : x ⊔ y ∈ I ↔ x ∈ I ∧ y ∈ I :=
   ⟨fun h => ⟨I.lower le_sup_left h, I.lower le_sup_right h⟩, fun h => sup_mem h.1 h.2⟩
 #align order.ideal.sup_mem_iff Order.Ideal.sup_mem_iff
--/
 
 end SemilatticeSup
 
@@ -516,7 +524,7 @@ section SemilatticeSupDirected
 variable [SemilatticeSup P] [IsDirected P (· ≥ ·)] {x : P} {I J K s t : Ideal P}
 
 /-- The infimum of two ideals of a co-directed order is their intersection. -/
-instance : HasInf (Ideal P) :=
+instance : Inf (Ideal P) :=
   ⟨fun I J =>
     { toLowerSet := I.toLowerSet ⊓ J.toLowerSet
       nonempty' := inter_nonempty I J
@@ -524,7 +532,7 @@ instance : HasInf (Ideal P) :=
 
 /-- The supremum of two ideals of a co-directed order is the union of the down sets of the pointwise
 supremum of `I` and `J`. -/
-instance : HasSup (Ideal P) :=
+instance : Sup (Ideal P) :=
   ⟨fun I J =>
     { carrier := { x | ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j }
       nonempty' := by
@@ -567,9 +575,9 @@ instance : Lattice (Ideal P) :=
 
 /- warning: order.ideal.coe_sup -> Order.Ideal.coe_sup is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (HasSup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) s t)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (a : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) => Exists.{succ u1} P (fun (b : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) => LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (HasSup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) a b)))))))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) s t)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (a : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) => Exists.{succ u1} P (fun (b : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) => LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) a b)))))))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2880 : P) (x._@.Mathlib.Order.Ideal._hyg.2882 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2880 x._@.Mathlib.Order.Ideal._hyg.2882)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (HasSup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instHasSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (a : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) (Exists.{succ u1} P (fun (b : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (HasSup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) a b)))))))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2880 : P) (x._@.Mathlib.Order.Ideal._hyg.2882 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2880 x._@.Mathlib.Order.Ideal._hyg.2882)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (a : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) a s) (Exists.{succ u1} P (fun (b : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) b t) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) a b)))))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.coe_sup Order.Ideal.coe_supₓ'. -/
 @[simp]
 theorem coe_sup : ↑(s ⊔ t) = { x | ∃ a ∈ s, ∃ b ∈ t, x ≤ a ⊔ b } :=
@@ -578,9 +586,9 @@ theorem coe_sup : ↑(s ⊔ t) = { x | ∃ a ∈ s, ∃ b ∈ t, x ≤ a ⊔ b }
 
 /- warning: order.ideal.coe_inf -> Order.Ideal.coe_inf is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (HasInf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) s t)) (Inter.inter.{u1} (Set.{u1} P) (Set.hasInter.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) s) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) t))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) s t)) (Inter.inter.{u1} (Set.{u1} P) (Set.hasInter.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) s) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))))) t))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2979 : P) (x._@.Mathlib.Order.Ideal._hyg.2981 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2979 x._@.Mathlib.Order.Ideal._hyg.2981)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (HasInf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instHasInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (Inter.inter.{u1} (Set.{u1} P) (Set.instInterSet.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) s) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) t))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.2979 : P) (x._@.Mathlib.Order.Ideal._hyg.2981 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.2979 x._@.Mathlib.Order.Ideal._hyg.2981)] {s : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {t : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) s t)) (Inter.inter.{u1} (Set.{u1} P) (Set.instInterSet.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) s) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) t))
 Case conversion may be inaccurate. Consider using '#align order.ideal.coe_inf Order.Ideal.coe_infₓ'. -/
 @[simp]
 theorem coe_inf : (↑(s ⊓ t) : Set P) = s ∩ t :=
@@ -589,9 +597,9 @@ theorem coe_inf : (↑(s ⊓ t) : Set P) = s ∩ t :=
 
 /- warning: order.ideal.mem_inf -> Order.Ideal.mem_inf is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (HasInf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) I J)) (And (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x J))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasInf.{u1} P _inst_1 _inst_2) I J)) (And (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x J))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3041 : P) (x._@.Mathlib.Order.Ideal._hyg.3043 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3041 x._@.Mathlib.Order.Ideal._hyg.3043)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (HasInf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instHasInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x J))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3041 : P) (x._@.Mathlib.Order.Ideal._hyg.3043 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3041 x._@.Mathlib.Order.Ideal._hyg.3043)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Inf.inf.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instInfIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x J))
 Case conversion may be inaccurate. Consider using '#align order.ideal.mem_inf Order.Ideal.mem_infₓ'. -/
 @[simp]
 theorem mem_inf : x ∈ I ⊓ J ↔ x ∈ I ∧ x ∈ J :=
@@ -600,9 +608,9 @@ theorem mem_inf : x ∈ I ⊓ J ↔ x ∈ I ∧ x ∈ J :=
 
 /- warning: order.ideal.mem_sup -> Order.Ideal.mem_sup is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (HasSup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) I J)) (Exists.{succ u1} P (fun (i : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) => Exists.{succ u1} P (fun (j : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) => LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (HasSup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) i j))))))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) I J)) (Exists.{succ u1} P (fun (i : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) => Exists.{succ u1} P (fun (j : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) => LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) i j))))))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3102 : P) (x._@.Mathlib.Order.Ideal._hyg.3104 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3102 x._@.Mathlib.Order.Ideal._hyg.3104)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (HasSup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instHasSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (Exists.{succ u1} P (fun (i : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) (Exists.{succ u1} P (fun (j : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (HasSup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P _inst_1) i j))))))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3102 : P) (x._@.Mathlib.Order.Ideal._hyg.3104 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3102 x._@.Mathlib.Order.Ideal._hyg.3104)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, Iff (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I J)) (Exists.{succ u1} P (fun (i : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) i I) (Exists.{succ u1} P (fun (j : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) j J) (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P _inst_1) i j))))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.mem_sup Order.Ideal.mem_supₓ'. -/
 @[simp]
 theorem mem_sup : x ∈ I ⊔ J ↔ ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j :=
@@ -611,9 +619,9 @@ theorem mem_sup : x ∈ I ⊔ J ↔ ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j :=
 
 /- warning: order.ideal.lt_sup_principal_of_not_mem -> Order.Ideal.lt_sup_principal_of_not_mem is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Not (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I)) -> (LT.lt.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Preorder.toLT.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.partialOrder.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))))) I (HasSup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) I (Order.Ideal.principal.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)) x)))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Not (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I)) -> (LT.lt.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Preorder.toLT.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.partialOrder.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))))) I (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.hasSup.{u1} P _inst_1 _inst_2) I (Order.Ideal.principal.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)) x)))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3194 : P) (x._@.Mathlib.Order.Ideal._hyg.3196 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3194 x._@.Mathlib.Order.Ideal._hyg.3196)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Not (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I)) -> (LT.lt.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Preorder.toLT.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instPartialOrderIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))))) I (HasSup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instHasSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I (Order.Ideal.principal.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)) x)))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} P] [_inst_2 : IsDirected.{u1} P (fun (x._@.Mathlib.Order.Ideal._hyg.3194 : P) (x._@.Mathlib.Order.Ideal._hyg.3196 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))) x._@.Mathlib.Order.Ideal._hyg.3194 x._@.Mathlib.Order.Ideal._hyg.3196)] {x : P} {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))}, (Not (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1))))) x I)) -> (LT.lt.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Preorder.toLT.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instPartialOrderIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))))) I (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P _inst_1 _inst_2) I (Order.Ideal.principal.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeSup.toPartialOrder.{u1} P _inst_1)) x)))
 Case conversion may be inaccurate. Consider using '#align order.ideal.lt_sup_principal_of_not_mem Order.Ideal.lt_sup_principal_of_not_memₓ'. -/
 theorem lt_sup_principal_of_not_mem (hx : x ∉ I) : I < I ⊔ principal x :=
   le_sup_left.lt_of_ne fun h => hx <| by simpa only [left_eq_sup, principal_le_iff] using h
@@ -680,9 +688,9 @@ variable {I J : Ideal P}
 
 /- warning: order.ideal.eq_sup_of_le_sup -> Order.Ideal.eq_sup_of_le_sup is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : DistribLattice.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {x : P} {i : P} {j : P}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) -> (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))) x (HasSup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i j)) -> (Exists.{succ u1} P (fun (i' : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i' I) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i' I) => Exists.{succ u1} P (fun (j' : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j' J) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j' J) => Eq.{succ u1} P x (HasSup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i' j'))))))
+  forall {P : Type.{u1}} [_inst_1 : DistribLattice.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {x : P} {i : P} {j : P}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) -> (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) -> (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))) x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i j)) -> (Exists.{succ u1} P (fun (i' : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i' I) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i' I) => Exists.{succ u1} P (fun (j' : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j' J) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j' J) => Eq.{succ u1} P x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i' j'))))))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : DistribLattice.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {x : P} {i : P} {j : P}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) -> (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) -> (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))) x (HasSup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i j)) -> (Exists.{succ u1} P (fun (i' : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i' I) (Exists.{succ u1} P (fun (j' : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j' J) (Eq.{succ u1} P x (HasSup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i' j'))))))
+  forall {P : Type.{u1}} [_inst_1 : DistribLattice.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {x : P} {i : P} {j : P}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) -> (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) -> (LE.le.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))) x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i j)) -> (Exists.{succ u1} P (fun (i' : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i' I) (Exists.{succ u1} P (fun (j' : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j' J) (Eq.{succ u1} P x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i' j'))))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.eq_sup_of_le_sup Order.Ideal.eq_sup_of_le_supₓ'. -/
 theorem eq_sup_of_le_sup {x i j : P} (hi : i ∈ I) (hj : j ∈ J) (hx : x ≤ i ⊔ j) :
     ∃ i' ∈ I, ∃ j' ∈ J, x = i' ⊔ j' :=
@@ -696,9 +704,9 @@ theorem eq_sup_of_le_sup {x i j : P} (hi : i ∈ I) (hj : j ∈ J) (hx : x ≤ i
 
 /- warning: order.ideal.coe_sup_eq -> Order.Ideal.coe_sup_eq is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : DistribLattice.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))))) (HasSup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Order.Ideal.hasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)) (SemilatticeInf.to_isDirected_ge.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))) I J)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (i : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) => Exists.{succ u1} P (fun (j : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) => Eq.{succ u1} P x (HasSup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i j)))))))
+  forall {P : Type.{u1}} [_inst_1 : DistribLattice.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))}, Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Order.Ideal.hasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)) (SemilatticeInf.to_isDirected_ge.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))) I J)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (i : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) => Exists.{succ u1} P (fun (j : P) => Exists.{0} (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) (fun (H : Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) => Eq.{succ u1} P x (Sup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i j)))))))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : DistribLattice.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (HasSup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Order.Ideal.instHasSupIdealToLEToPreorderToPartialOrder.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)) (SemilatticeInf.to_isDirected_ge.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))) I J)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (i : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) (Exists.{succ u1} P (fun (j : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) (Eq.{succ u1} P x (HasSup.sup.{u1} P (SemilatticeSup.toHasSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i j)))))))
+  forall {P : Type.{u1}} [_inst_1 : DistribLattice.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))} {J : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))}, Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Sup.sup.{u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (Order.Ideal.instSupIdealToLEToPreorderToPartialOrder.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)) (SemilatticeInf.to_isDirected_ge.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))) I J)) (setOf.{u1} P (fun (x : P) => Exists.{succ u1} P (fun (i : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) i I) (Exists.{succ u1} P (fun (j : P) => And (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))))))) j J) (Eq.{succ u1} P x (Sup.sup.{u1} P (SemilatticeSup.toSup.{u1} P (Lattice.toSemilatticeSup.{u1} P (DistribLattice.toLattice.{u1} P _inst_1))) i j)))))))
 Case conversion may be inaccurate. Consider using '#align order.ideal.coe_sup_eq Order.Ideal.coe_sup_eqₓ'. -/
 theorem coe_sup_eq : ↑(I ⊔ J) = { x | ∃ i ∈ I, ∃ j ∈ J, x = i ⊔ j } :=
   Set.ext fun _ =>

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

Moves definition of and lemmas related to Set.Subsingleton and Set.Nontrivial to a new file, so that Basic can be shorter.

@@ -6,7 +6,7 @@ Authors: David Wärn
 import Mathlib.Logic.Encodable.Basic
 import Mathlib.Order.Atoms
 import Mathlib.Order.UpperLower.Basic
-import Mathlib.Data.Set.Basic
+import Mathlib.Data.Set.Subsingleton
 
 #align_import order.ideal from "leanprover-community/mathlib"@"59694bd07f0a39c5beccba34bd9f413a160782bf"
 

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

@@ -468,7 +468,6 @@ end SemilatticeSupOrderBot
 section DistribLattice
 
 variable [DistribLattice P]
-
 variable {I J : Ideal P}
 
 theorem eq_sup_of_le_sup {x i j : P} (hi : i ∈ I) (hj : j ∈ J) (hx : x ≤ i ⊔ j) :

Classifies by adding issue number #11215 to porting notes claiming "TODO".

@@ -64,7 +64,7 @@ structure Ideal (P) [LE P] extends LowerSet P where
   directed' : DirectedOn (· ≤ ·) carrier
 #align order.ideal Order.Ideal
 
--- Porting note: todo: remove this configuration and use the default configuration.
+-- Porting note (#11215): TODO: remove this configuration and use the default configuration.
 -- We keep this to be consistent with Lean 3.
 initialize_simps_projections Ideal (+toLowerSet, -carrier)
 

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

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

Also marks CauSeq.ext @[ext].

Order.BoundedOrder

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

Order.Lattice

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

Order.MinMax

• max_min_distrib_left
• max_min_distrib_right
• min_max_distrib_left
• min_max_distrib_right

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

@@ -476,7 +476,7 @@ theorem eq_sup_of_le_sup {x i j : P} (hi : i ∈ I) (hj : j ∈ J) (hx : x ≤ i
   refine' ⟨x ⊓ i, I.lower inf_le_right hi, x ⊓ j, J.lower inf_le_right hj, _⟩
   calc
     x = x ⊓ (i ⊔ j) := left_eq_inf.mpr hx
-    _ = x ⊓ i ⊔ x ⊓ j := inf_sup_left
+    _ = x ⊓ i ⊔ x ⊓ j := inf_sup_left _ _ _
 #align order.ideal.eq_sup_of_le_sup Order.Ideal.eq_sup_of_le_sup
 
 theorem coe_sup_eq : ↑(I ⊔ J) = { x | ∃ i ∈ I, ∃ j ∈ J, x = i ⊔ j } :=

Classify by adding issue number (#10618) to porting notes claiming anything semantically equivalent to simp can prove this or simp can simplify this.

@@ -147,12 +147,12 @@ theorem mem_compl_of_ge {x y : P} : x ≤ y → x ∈ (I : Set P)ᶜ → y ∈ (
 instance instPartialOrderIdeal : PartialOrder (Ideal P) :=
   PartialOrder.lift SetLike.coe SetLike.coe_injective
 
--- @[simp] -- Porting note: simp can prove this
+-- @[simp] -- Porting note (#10618): simp can prove this
 theorem coe_subset_coe : (s : Set P) ⊆ t ↔ s ≤ t :=
   Iff.rfl
 #align order.ideal.coe_subset_coe Order.Ideal.coe_subset_coe
 
--- @[simp] -- Porting note: simp can prove this
+-- @[simp] -- Porting note (#10618): simp can prove this
 theorem coe_ssubset_coe : (s : Set P) ⊂ t ↔ s < t :=
   Iff.rfl
 #align order.ideal.coe_ssubset_coe Order.Ideal.coe_ssubset_coe

• Remove Data.Set.Basic from scripts/noshake.json.
• Remove an exception that was used by examples only, move these examples to a new test file.
• Drop an exception for Order.Filter.Basic dependency on Control.Traversable.Instances, as the relevant parts were moved to Order.Filter.ListTraverse.
• Run lake exe shake --fix.

@@ -6,6 +6,7 @@ Authors: David Wärn
 import Mathlib.Logic.Encodable.Basic
 import Mathlib.Order.Atoms
 import Mathlib.Order.UpperLower.Basic
+import Mathlib.Data.Set.Basic
 
 #align_import order.ideal from "leanprover-community/mathlib"@"59694bd07f0a39c5beccba34bd9f413a160782bf"
 

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

This has nice performance benefits.

@@ -50,7 +50,7 @@ open Function Set
 
 namespace Order
 
-variable {P : Type _}
+variable {P : Type*}
 
 /-- An ideal on an order `P` is a subset of `P` that is
   - nonempty
@@ -546,7 +546,7 @@ end Cofinal
 
 section IdealOfCofinals
 
-variable [Preorder P] (p : P) {ι : Type _} [Encodable ι] (𝒟 : ι → Cofinal P)
+variable [Preorder P] (p : P) {ι : Type*} [Encodable ι] (𝒟 : ι → Cofinal P)
 
 /-- Given a starting point, and a countable family of cofinal sets,
   this is an increasing sequence that intersects each cofinal set. -/

Per https://github.com/leanprover/lean4/issues/2343, we are going to need to change the automatic generation of instance names, as they become too long.

This PR ensures that everywhere in Mathlib that refers to an instance by name, that name is given explicitly, rather than being automatically generated.

There are four exceptions, which are now commented, with links to https://github.com/leanprover/lean4/issues/2343.

This was implemented by running Mathlib against a modified Lean that appended _ᾰ to all automatically generated names, and fixing everything.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -143,7 +143,7 @@ theorem mem_compl_of_ge {x y : P} : x ≤ y → x ∈ (I : Set P)ᶜ → y ∈ (
 #align order.ideal.mem_compl_of_ge Order.Ideal.mem_compl_of_ge
 
 /-- The partial ordering by subset inclusion, inherited from `Set P`. -/
-instance : PartialOrder (Ideal P) :=
+instance instPartialOrderIdeal : PartialOrder (Ideal P) :=
   PartialOrder.lift SetLike.coe SetLike.coe_injective
 
 -- @[simp] -- Porting note: simp can prove this

• depends on: #5966

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

@@ -2,16 +2,13 @@
 Copyright (c) 2020 David Wärn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: David Wärn
-
-! This file was ported from Lean 3 source module order.ideal
-! leanprover-community/mathlib commit 59694bd07f0a39c5beccba34bd9f413a160782bf
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Logic.Encodable.Basic
 import Mathlib.Order.Atoms
 import Mathlib.Order.UpperLower.Basic
 
+#align_import order.ideal from "leanprover-community/mathlib"@"59694bd07f0a39c5beccba34bd9f413a160782bf"
+
 /-!
 # Order ideals, cofinal sets, and the Rasiowa–Sikorski lemma
 

Grepping for [^ .:{-] [^ :] and reviewing the results. Once I started I couldn't stop. :-)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -375,7 +375,7 @@ instance : Sup (Ideal P) :=
         cases' inter_nonempty I J with w h
         exact ⟨w, w, h.1, w, h.2, le_sup_left⟩
       directed' := fun x ⟨xi, _, xj, _, _⟩ y ⟨yi, _, yj, _, _⟩ ↦
-        ⟨x ⊔ y,  ⟨xi ⊔ yi, sup_mem ‹_› ‹_›, xj ⊔ yj, sup_mem ‹_› ‹_›,
+        ⟨x ⊔ y, ⟨xi ⊔ yi, sup_mem ‹_› ‹_›, xj ⊔ yj, sup_mem ‹_› ‹_›,
             sup_le
               (calc
                 x ≤ xi ⊔ xj := ‹_›

Changes are of the form

• some_tactic at h⊢ -> some_tactic at h ⊢
• some_tactic at h -> some_tactic at h

@@ -443,7 +443,7 @@ instance : InfSet (Ideal P) :=
       directed' := fun a ha b hb ↦
         ⟨a ⊔ b,
           ⟨by
-            rw [LowerSet.carrier_eq_coe, LowerSet.coe_iInf₂, Set.mem_iInter₂] at ha hb⊢
+            rw [LowerSet.carrier_eq_coe, LowerSet.coe_iInf₂, Set.mem_iInter₂] at ha hb ⊢
             exact fun s hs ↦ sup_mem (ha _ hs) (hb _ hs), le_sup_left, le_sup_right⟩⟩ }⟩
 
 variable {S : Set (Ideal P)}

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>

@@ -438,32 +438,32 @@ instance : InfSet (Ideal P) :=
     { toLowerSet := ⨅ s ∈ S, toLowerSet s
       nonempty' :=
         ⟨⊥, by
-          rw [LowerSet.carrier_eq_coe, LowerSet.coe_infᵢ₂, Set.mem_interᵢ₂]
+          rw [LowerSet.carrier_eq_coe, LowerSet.coe_iInf₂, Set.mem_iInter₂]
           exact fun s _ ↦ s.bot_mem⟩
       directed' := fun a ha b hb ↦
         ⟨a ⊔ b,
           ⟨by
-            rw [LowerSet.carrier_eq_coe, LowerSet.coe_infᵢ₂, Set.mem_interᵢ₂] at ha hb⊢
+            rw [LowerSet.carrier_eq_coe, LowerSet.coe_iInf₂, Set.mem_iInter₂] at ha hb⊢
             exact fun s hs ↦ sup_mem (ha _ hs) (hb _ hs), le_sup_left, le_sup_right⟩⟩ }⟩
 
 variable {S : Set (Ideal P)}
 
 @[simp]
-theorem coe_infₛ : (↑(infₛ S) : Set P) = ⋂ s ∈ S, ↑s :=
-  LowerSet.coe_infᵢ₂ _
-#align order.ideal.coe_Inf Order.Ideal.coe_infₛ
+theorem coe_sInf : (↑(sInf S) : Set P) = ⋂ s ∈ S, ↑s :=
+  LowerSet.coe_iInf₂ _
+#align order.ideal.coe_Inf Order.Ideal.coe_sInf
 
 @[simp]
-theorem mem_infₛ : x ∈ infₛ S ↔ ∀ s ∈ S, x ∈ s := by
-  simp_rw [← SetLike.mem_coe, coe_infₛ, mem_interᵢ₂]
-#align order.ideal.mem_Inf Order.Ideal.mem_infₛ
+theorem mem_sInf : x ∈ sInf S ↔ ∀ s ∈ S, x ∈ s := by
+  simp_rw [← SetLike.mem_coe, coe_sInf, mem_iInter₂]
+#align order.ideal.mem_Inf Order.Ideal.mem_sInf
 
 instance : CompleteLattice (Ideal P) :=
   { (inferInstance : Lattice (Ideal P)),
     completeLatticeOfInf (Ideal P) fun S ↦ by
-      refine' ⟨fun s hs ↦ _, fun s hs ↦ by rwa [← coe_subset_coe, coe_infₛ, subset_interᵢ₂_iff]⟩
-      rw [← coe_subset_coe, coe_infₛ]
-      exact binterᵢ_subset_of_mem hs with }
+      refine' ⟨fun s hs ↦ _, fun s hs ↦ by rwa [← coe_subset_coe, coe_sInf, subset_iInter₂_iff]⟩
+      rw [← coe_subset_coe, coe_sInf]
+      exact biInter_subset_of_mem hs with }
 
 end SemilatticeSupOrderBot
 

Mathport doesn't understand this, and apparently nor do many of the humans fixing the errors it creates.

If your #align statement complains the def doesn't exist, don't change the #align; work out why it doesn't exist instead.

Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -225,9 +225,9 @@ theorem IsProper.ne_top (_ : IsProper I) : I ≠ ⊤ :=
   fun h ↦ IsProper.ne_univ <| congr_arg SetLike.coe h
 #align order.ideal.is_proper.ne_top Order.Ideal.IsProper.ne_top
 
-theorem IsCoatom.isProper (hI : IsCoatom I) : IsProper I :=
+theorem _root_.IsCoatom.isProper (hI : IsCoatom I) : IsProper I :=
   isProper_of_ne_top hI.1
-#align is_coatom.is_proper Order.Ideal.IsCoatom.isProper
+#align is_coatom.is_proper IsCoatom.isProper
 
 theorem isProper_iff_ne_top : IsProper I ↔ I ≠ ⊤ :=
   ⟨fun h ↦ h.ne_top, fun h ↦ isProper_of_ne_top h⟩
@@ -241,9 +241,9 @@ theorem IsMaximal.isCoatom' [IsMaximal I] : IsCoatom I :=
   IsMaximal.isCoatom ‹_›
 #align order.ideal.is_maximal.is_coatom' Order.Ideal.IsMaximal.isCoatom'
 
-theorem IsCoatom.isMaximal (hI : IsCoatom I) : IsMaximal I :=
+theorem _root_.IsCoatom.isMaximal (hI : IsCoatom I) : IsMaximal I :=
   { IsCoatom.isProper hI with maximal_proper := fun _ hJ ↦ by simp [hI.2 _ hJ] }
-#align is_coatom.is_maximal Order.Ideal.IsCoatom.isMaximal
+#align is_coatom.is_maximal IsCoatom.isMaximal
 
 theorem isMaximal_iff_isCoatom : IsMaximal I ↔ IsCoatom I :=
   ⟨fun h ↦ h.isCoatom, fun h ↦ IsCoatom.isMaximal h⟩

This PR fixes two things:

• Most align statements for definitions and theorems and instances that are separated by two newlines from the relevant declaration (s/\n\n#align/\n#align). This is often seen in the mathport output after ending calc blocks.
• All remaining more-than-one-line #align statements. (This was needed for a script I wrote for #3630.)

@@ -479,7 +479,6 @@ theorem eq_sup_of_le_sup {x i j : P} (hi : i ∈ I) (hj : j ∈ J) (hx : x ≤ i
   calc
     x = x ⊓ (i ⊔ j) := left_eq_inf.mpr hx
     _ = x ⊓ i ⊔ x ⊓ j := inf_sup_left
-
 #align order.ideal.eq_sup_of_le_sup Order.Ideal.eq_sup_of_le_sup
 
 theorem coe_sup_eq : ↑(I ⊔ J) = { x | ∃ i ∈ I, ∃ j ∈ J, x = i ⊔ j } :=

@@ -372,8 +372,7 @@ instance : Sup (Ideal P) :=
   ⟨fun I J ↦
     { carrier := { x | ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j }
       nonempty' := by
-        cases inter_nonempty I J
-        rename_i w h
+        cases' inter_nonempty I J with w h
         exact ⟨w, w, h.1, w, h.2, le_sup_left⟩
       directed' := fun x ⟨xi, _, xj, _, _⟩ y ⟨yi, _, yj, _, _⟩ ↦
         ⟨x ⊔ y,  ⟨xi ⊔ yi, sup_mem ‹_› ‹_›, xj ⊔ yj, sup_mem ‹_› ‹_›,

• initialize_simps_projections now by default generates all projections of all parent structures, and doesn't generate the projections to those parent structures.
• You can also rename a nested projection directly, without having to specify intermediate parent structures
• Added the option to turn the default behavior off (done in e.g. TwoPointed)

Internal changes:

• Move most declarations to the Simps namespace, and shorten their names
• Restructure ParsedProjectionData to avoid the bug reported here (and to another bug where it seemed that the wrong data was inserted in ParsedProjectionData, but it was hard to minimize because of all the crashes). If we manage to fix the bug in that Zulip thread, I'll see if I can track down the other bug in commit 97454284

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

@@ -66,6 +66,10 @@ structure Ideal (P) [LE P] extends LowerSet P where
   directed' : DirectedOn (· ≤ ·) carrier
 #align order.ideal Order.Ideal
 
+-- Porting note: todo: remove this configuration and use the default configuration.
+-- We keep this to be consistent with Lean 3.
+initialize_simps_projections Ideal (+toLowerSet, -carrier)
+
 /-- A subset of a preorder `P` is an ideal if it is
   - nonempty
   - upward directed (any pair of elements in the ideal has an upper bound in the ideal)

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

@@ -356,7 +356,7 @@ section SemilatticeSupDirected
 variable [SemilatticeSup P] [IsDirected P (· ≥ ·)] {x : P} {I J K s t : Ideal P}
 
 /-- The infimum of two ideals of a co-directed order is their intersection. -/
-instance : HasInf (Ideal P) :=
+instance : Inf (Ideal P) :=
   ⟨fun I J ↦
     { toLowerSet := I.toLowerSet ⊓ J.toLowerSet
       nonempty' := inter_nonempty I J
@@ -364,7 +364,7 @@ instance : HasInf (Ideal P) :=
 
 /-- The supremum of two ideals of a co-directed order is the union of the down sets of the pointwise
 supremum of `I` and `J`. -/
-instance : HasSup (Ideal P) :=
+instance : Sup (Ideal P) :=
   ⟨fun I J ↦
     { carrier := { x | ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j }
       nonempty' := by

@@ -151,9 +151,9 @@ theorem coe_subset_coe : (s : Set P) ⊆ t ↔ s ≤ t :=
 #align order.ideal.coe_subset_coe Order.Ideal.coe_subset_coe
 
 -- @[simp] -- Porting note: simp can prove this
-theorem coe_sSubset_coe : (s : Set P) ⊂ t ↔ s < t :=
+theorem coe_ssubset_coe : (s : Set P) ⊂ t ↔ s < t :=
   Iff.rfl
-#align order.ideal.coe_ssubset_coe Order.Ideal.coe_sSubset_coe
+#align order.ideal.coe_ssubset_coe Order.Ideal.coe_ssubset_coe
 
 @[trans]
 theorem mem_of_mem_of_le {x : P} {I J : Ideal P} : x ∈ I → I ≤ J → x ∈ J :=

@@ -199,10 +199,9 @@ section Directed
 variable [IsDirected P (· ≤ ·)] [Nonempty P] {I : Ideal P}
 
 /-- In a directed and nonempty order, the top ideal of a is `univ`. -/
-instance : OrderTop (Ideal P)
-    where
+instance : OrderTop (Ideal P) where
   top := ⟨⊤, univ_nonempty, directedOn_univ⟩
-  le_top := fun _ _ _ ↦ LowerSet.mem_top
+  le_top _ _ _ := LowerSet.mem_top
 
 @[simp]
 theorem top_toLowerSet : (⊤ : Ideal P).toLowerSet = ⊤ :=
@@ -234,9 +233,9 @@ theorem IsMaximal.isCoatom (_ : IsMaximal I) : IsCoatom I :=
   ⟨IsMaximal.toIsProper.ne_top, fun _ h ↦ ext <| IsMaximal.maximal_proper h⟩
 #align order.ideal.is_maximal.is_coatom Order.Ideal.IsMaximal.isCoatom
 
-theorem IsMaximal.is_coatom' [IsMaximal I] : IsCoatom I :=
+theorem IsMaximal.isCoatom' [IsMaximal I] : IsCoatom I :=
   IsMaximal.isCoatom ‹_›
-#align order.ideal.is_maximal.is_coatom' Order.Ideal.IsMaximal.is_coatom'
+#align order.ideal.is_maximal.is_coatom' Order.Ideal.IsMaximal.isCoatom'
 
 theorem IsCoatom.isMaximal (hI : IsCoatom I) : IsMaximal I :=
   { IsCoatom.isProper hI with maximal_proper := fun _ hJ ↦ by simp [hI.2 _ hJ] }
@@ -582,8 +581,7 @@ theorem sequenceOfCofinals.encode_mem (i : ι) :
   - intersects every set in `𝒟`, according to `cofinal_meets_idealOfCofinals p 𝒟`.
 
   This proves the Rasiowa–Sikorski lemma. -/
-def idealOfCofinals : Ideal P
-    where
+def idealOfCofinals : Ideal P where
   carrier := { x : P | ∃ n, x ≤ sequenceOfCofinals p 𝒟 n }
   lower' := fun _ _ hxy ⟨n, hn⟩ ↦ ⟨n, le_trans hxy hn⟩
   nonempty' := ⟨p, 0, le_rfl⟩

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