order.prime_ideal ⟷ Mathlib.Order.PrimeIdeal

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Noam Atar
 -/
 import Order.Ideal
-import Order.Pfilter
+import Order.PFilter
 
 #align_import order.prime_ideal from "leanprover-community/mathlib"@"23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6"
 

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

@@ -75,7 +75,7 @@ theorem compl_F_eq_I : (IF.f : Set P)ᶜ = IF.i :=
 theorem I_isProper : IsProper IF.i := by
   cases IF.F.nonempty
   apply is_proper_of_not_mem (_ : w ∉ IF.I)
-  rwa [← IF.compl_I_eq_F] at h 
+  rwa [← IF.compl_I_eq_F] at h
 #align order.ideal.prime_pair.I_is_proper Order.Ideal.PrimePair.I_isProper
 -/
 
@@ -183,7 +183,7 @@ instance (priority := 100) IsMaximal.isPrime [IsMaximal I] : IsPrime I :=
   have hJuniv : (J : Set P) = Set.univ :=
     is_maximal.maximal_proper (lt_sup_principal_of_not_mem ‹_›)
   have hyJ : y ∈ ↑J := set.eq_univ_iff_forall.mp hJuniv y
-  rw [coe_sup_eq] at hyJ 
+  rw [coe_sup_eq] at hyJ
   rcases hyJ with ⟨a, ha, b, hb, hy⟩
   rw [hy]
   refine' sup_mem ha (I.lower (le_inf hb _) hxy)
@@ -220,7 +220,7 @@ theorem isPrime_of_mem_or_compl_mem [IsProper I] (h : ∀ {x : P}, x ∈ I ∨ x
   intro x y hxy hxI
   have hxcI : xᶜ ∈ I := h.resolve_left hxI
   have ass : x ⊓ y ⊔ y ⊓ xᶜ ∈ I := sup_mem hxy (I.lower inf_le_right hxcI)
-  rwa [inf_comm, sup_inf_inf_compl] at ass 
+  rwa [inf_comm, sup_inf_inf_compl] at ass
 #align order.ideal.is_prime_of_mem_or_compl_mem Order.Ideal.isPrime_of_mem_or_compl_mem
 -/
 
@@ -237,7 +237,7 @@ instance (priority := 100) IsPrime.isMaximal [IsPrime I] : IsMaximal I :=
   intro J hIJ x
   rcases Set.exists_of_ssubset hIJ with ⟨y, hyJ, hyI⟩
   suffices ass : x ⊓ y ⊔ x ⊓ yᶜ ∈ J
-  · rwa [sup_inf_inf_compl] at ass 
+  · rwa [sup_inf_inf_compl] at ass
   exact
     sup_mem (J.lower inf_le_right hyJ)
       (hIJ.le <| I.lower inf_le_right <| is_prime.mem_compl_of_not_mem ‹_› hyI)

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

@@ -216,7 +216,7 @@ theorem IsPrime.mem_compl_of_not_mem (hI : IsPrime I) (hxnI : x ∉ I) : xᶜ 
 #print Order.Ideal.isPrime_of_mem_or_compl_mem /-
 theorem isPrime_of_mem_or_compl_mem [IsProper I] (h : ∀ {x : P}, x ∈ I ∨ xᶜ ∈ I) : IsPrime I :=
   by
-  simp only [is_prime_iff_mem_or_mem, or_iff_not_imp_left]
+  simp only [is_prime_iff_mem_or_mem, Classical.or_iff_not_imp_left]
   intro x y hxy hxI
   have hxcI : xᶜ ∈ I := h.resolve_left hxI
   have ass : x ⊓ y ⊔ y ⊓ xᶜ ∈ I := sup_mem hxy (I.lower inf_le_right hxcI)

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

@@ -3,8 +3,8 @@ Copyright (c) 2021 Noam Atar. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Noam Atar
 -/
-import Mathbin.Order.Ideal
-import Mathbin.Order.Pfilter
+import Order.Ideal
+import Order.Pfilter
 
 #align_import order.prime_ideal from "leanprover-community/mathlib"@"23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/63721b2c3eba6c325ecf8ae8cca27155a4f6306f

@@ -148,7 +148,7 @@ theorem IsPrime.mem_or_mem (hI : IsPrime I) {x y : P} : x ⊓ y ∈ I → x ∈
 theorem IsPrime.of_mem_or_mem [IsProper I] (hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I) :
     IsPrime I := by
   rw [is_prime_iff]
-  use ‹_›
+  use‹_›
   apply is_pfilter.of_def
   · exact Set.nonempty_compl.2 (I.is_proper_iff.1 ‹_›)
   · intro x _ y _

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

@@ -2,15 +2,12 @@
 Copyright (c) 2021 Noam Atar. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Noam Atar
-
-! This file was ported from Lean 3 source module order.prime_ideal
-! leanprover-community/mathlib commit 23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.Ideal
 import Mathbin.Order.Pfilter
 
+#align_import order.prime_ideal from "leanprover-community/mathlib"@"23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6"
+
 /-!
 # Prime ideals
 

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

@@ -62,13 +62,17 @@ namespace PrimePair
 
 variable [Preorder P] (IF : PrimePair P)
 
+#print Order.Ideal.PrimePair.compl_I_eq_F /-
 theorem compl_I_eq_F : (IF.i : Set P)ᶜ = IF.f :=
   IF.isCompl_i_f.compl_eq
 #align order.ideal.prime_pair.compl_I_eq_F Order.Ideal.PrimePair.compl_I_eq_F
+-/
 
+#print Order.Ideal.PrimePair.compl_F_eq_I /-
 theorem compl_F_eq_I : (IF.f : Set P)ᶜ = IF.i :=
   IF.isCompl_i_f.eq_compl.symm
 #align order.ideal.prime_pair.compl_F_eq_I Order.Ideal.PrimePair.compl_F_eq_I
+-/
 
 #print Order.Ideal.PrimePair.I_isProper /-
 theorem I_isProper : IsProper IF.i := by
@@ -78,17 +82,23 @@ theorem I_isProper : IsProper IF.i := by
 #align order.ideal.prime_pair.I_is_proper Order.Ideal.PrimePair.I_isProper
 -/
 
+#print Order.Ideal.PrimePair.disjoint /-
 theorem disjoint : Disjoint (IF.i : Set P) IF.f :=
   IF.isCompl_i_f.Disjoint
 #align order.ideal.prime_pair.disjoint Order.Ideal.PrimePair.disjoint
+-/
 
+#print Order.Ideal.PrimePair.I_union_F /-
 theorem I_union_F : (IF.i : Set P) ∪ IF.f = Set.univ :=
   IF.isCompl_i_f.sup_eq_top
 #align order.ideal.prime_pair.I_union_F Order.Ideal.PrimePair.I_union_F
+-/
 
+#print Order.Ideal.PrimePair.F_union_I /-
 theorem F_union_I : (IF.f : Set P) ∪ IF.i = Set.univ :=
   IF.isCompl_i_f.symm.sup_eq_top
 #align order.ideal.prime_pair.F_union_I Order.Ideal.PrimePair.F_union_I
+-/
 
 end PrimePair
 
@@ -127,6 +137,7 @@ section SemilatticeInf
 
 variable [SemilatticeInf P] {x y : P} {I : Ideal P}
 
+#print Order.Ideal.IsPrime.mem_or_mem /-
 theorem IsPrime.mem_or_mem (hI : IsPrime I) {x y : P} : x ⊓ y ∈ I → x ∈ I ∨ y ∈ I :=
   by
   contrapose!
@@ -134,7 +145,9 @@ theorem IsPrime.mem_or_mem (hI : IsPrime I) {x y : P} : x ⊓ y ∈ I → x ∈
   show x ∈ F ∧ y ∈ F → x ⊓ y ∈ F
   exact fun h => inf_mem h.1 h.2
 #align order.ideal.is_prime.mem_or_mem Order.Ideal.IsPrime.mem_or_mem
+-/
 
+#print Order.Ideal.IsPrime.of_mem_or_mem /-
 theorem IsPrime.of_mem_or_mem [IsProper I] (hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I) :
     IsPrime I := by
   rw [is_prime_iff]
@@ -147,10 +160,13 @@ theorem IsPrime.of_mem_or_mem [IsProper I] (hI : ∀ {x y : P}, x ⊓ y ∈ I 
     tauto
   · exact @mem_compl_of_ge _ _ _
 #align order.ideal.is_prime.of_mem_or_mem Order.Ideal.IsPrime.of_mem_or_mem
+-/
 
+#print Order.Ideal.isPrime_iff_mem_or_mem /-
 theorem isPrime_iff_mem_or_mem [IsProper I] : IsPrime I ↔ ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I :=
   ⟨IsPrime.mem_or_mem, IsPrime.of_mem_or_mem⟩
 #align order.ideal.is_prime_iff_mem_or_mem Order.Ideal.isPrime_iff_mem_or_mem
+-/
 
 end SemilatticeInf
 

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

@@ -74,7 +74,7 @@ theorem compl_F_eq_I : (IF.f : Set P)ᶜ = IF.i :=
 theorem I_isProper : IsProper IF.i := by
   cases IF.F.nonempty
   apply is_proper_of_not_mem (_ : w ∉ IF.I)
-  rwa [← IF.compl_I_eq_F] at h
+  rwa [← IF.compl_I_eq_F] at h 
 #align order.ideal.prime_pair.I_is_proper Order.Ideal.PrimePair.I_isProper
 -/
 
@@ -170,7 +170,7 @@ instance (priority := 100) IsMaximal.isPrime [IsMaximal I] : IsPrime I :=
   have hJuniv : (J : Set P) = Set.univ :=
     is_maximal.maximal_proper (lt_sup_principal_of_not_mem ‹_›)
   have hyJ : y ∈ ↑J := set.eq_univ_iff_forall.mp hJuniv y
-  rw [coe_sup_eq] at hyJ
+  rw [coe_sup_eq] at hyJ 
   rcases hyJ with ⟨a, ha, b, hb, hy⟩
   rw [hy]
   refine' sup_mem ha (I.lower (le_inf hb _) hxy)
@@ -207,7 +207,7 @@ theorem isPrime_of_mem_or_compl_mem [IsProper I] (h : ∀ {x : P}, x ∈ I ∨ x
   intro x y hxy hxI
   have hxcI : xᶜ ∈ I := h.resolve_left hxI
   have ass : x ⊓ y ⊔ y ⊓ xᶜ ∈ I := sup_mem hxy (I.lower inf_le_right hxcI)
-  rwa [inf_comm, sup_inf_inf_compl] at ass
+  rwa [inf_comm, sup_inf_inf_compl] at ass 
 #align order.ideal.is_prime_of_mem_or_compl_mem Order.Ideal.isPrime_of_mem_or_compl_mem
 -/
 
@@ -224,7 +224,7 @@ instance (priority := 100) IsPrime.isMaximal [IsPrime I] : IsMaximal I :=
   intro J hIJ x
   rcases Set.exists_of_ssubset hIJ with ⟨y, hyJ, hyI⟩
   suffices ass : x ⊓ y ⊔ x ⊓ yᶜ ∈ J
-  · rwa [sup_inf_inf_compl] at ass
+  · rwa [sup_inf_inf_compl] at ass 
   exact
     sup_mem (J.lower inf_le_right hyJ)
       (hIJ.le <| I.lower inf_le_right <| is_prime.mem_compl_of_not_mem ‹_› hyI)

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

@@ -70,11 +70,13 @@ theorem compl_F_eq_I : (IF.f : Set P)ᶜ = IF.i :=
   IF.isCompl_i_f.eq_compl.symm
 #align order.ideal.prime_pair.compl_F_eq_I Order.Ideal.PrimePair.compl_F_eq_I
 
+#print Order.Ideal.PrimePair.I_isProper /-
 theorem I_isProper : IsProper IF.i := by
   cases IF.F.nonempty
   apply is_proper_of_not_mem (_ : w ∉ IF.I)
   rwa [← IF.compl_I_eq_F] at h
 #align order.ideal.prime_pair.I_is_proper Order.Ideal.PrimePair.I_isProper
+-/
 
 theorem disjoint : Disjoint (IF.i : Set P) IF.f :=
   IF.isCompl_i_f.Disjoint
@@ -90,17 +92,20 @@ theorem F_union_I : (IF.f : Set P) ∪ IF.i = Set.univ :=
 
 end PrimePair
 
+#print Order.Ideal.IsPrime /-
 /-- An ideal `I` is prime if its complement is a filter.
 -/
 @[mk_iff]
 class IsPrime [Preorder P] (I : Ideal P) extends IsProper I : Prop where
   compl_filter : IsPFilter ((I : Set P)ᶜ)
 #align order.ideal.is_prime Order.Ideal.IsPrime
+-/
 
 section Preorder
 
 variable [Preorder P]
 
+#print Order.Ideal.IsPrime.toPrimePair /-
 /-- Create an element of type `order.ideal.prime_pair` from an ideal satisfying the predicate
 `order.ideal.is_prime`. -/
 def IsPrime.toPrimePair {I : Ideal P} (h : IsPrime I) : PrimePair P :=
@@ -108,10 +113,13 @@ def IsPrime.toPrimePair {I : Ideal P} (h : IsPrime I) : PrimePair P :=
     f := h.compl_filter.toPFilter
     isCompl_i_f := isCompl_compl }
 #align order.ideal.is_prime.to_prime_pair Order.Ideal.IsPrime.toPrimePair
+-/
 
+#print Order.Ideal.PrimePair.I_isPrime /-
 theorem PrimePair.I_isPrime (IF : PrimePair P) : IsPrime IF.i :=
   { IF.I_isProper with compl_filter := by rw [IF.compl_I_eq_F]; exact IF.F.is_pfilter }
 #align order.ideal.prime_pair.I_is_prime Order.Ideal.PrimePair.I_isPrime
+-/
 
 end Preorder
 
@@ -150,6 +158,7 @@ section DistribLattice
 
 variable [DistribLattice P] {I : Ideal P}
 
+#print Order.Ideal.IsMaximal.isPrime /-
 instance (priority := 100) IsMaximal.isPrime [IsMaximal I] : IsPrime I :=
   by
   rw [is_prime_iff_mem_or_mem]
@@ -168,6 +177,7 @@ instance (priority := 100) IsMaximal.isPrime [IsMaximal I] : IsPrime I :=
   rw [hy]
   exact le_sup_right
 #align order.ideal.is_maximal.is_prime Order.Ideal.IsMaximal.isPrime
+-/
 
 end DistribLattice
 
@@ -175,17 +185,22 @@ section BooleanAlgebra
 
 variable [BooleanAlgebra P] {x : P} {I : Ideal P}
 
+#print Order.Ideal.IsPrime.mem_or_compl_mem /-
 theorem IsPrime.mem_or_compl_mem (hI : IsPrime I) : x ∈ I ∨ xᶜ ∈ I :=
   by
   apply hI.mem_or_mem
   rw [inf_compl_eq_bot]
   exact I.bot_mem
 #align order.ideal.is_prime.mem_or_compl_mem Order.Ideal.IsPrime.mem_or_compl_mem
+-/
 
+#print Order.Ideal.IsPrime.mem_compl_of_not_mem /-
 theorem IsPrime.mem_compl_of_not_mem (hI : IsPrime I) (hxnI : x ∉ I) : xᶜ ∈ I :=
   hI.mem_or_compl_mem.resolve_left hxnI
 #align order.ideal.is_prime.mem_compl_of_not_mem Order.Ideal.IsPrime.mem_compl_of_not_mem
+-/
 
+#print Order.Ideal.isPrime_of_mem_or_compl_mem /-
 theorem isPrime_of_mem_or_compl_mem [IsProper I] (h : ∀ {x : P}, x ∈ I ∨ xᶜ ∈ I) : IsPrime I :=
   by
   simp only [is_prime_iff_mem_or_mem, or_iff_not_imp_left]
@@ -194,11 +209,15 @@ theorem isPrime_of_mem_or_compl_mem [IsProper I] (h : ∀ {x : P}, x ∈ I ∨ x
   have ass : x ⊓ y ⊔ y ⊓ xᶜ ∈ I := sup_mem hxy (I.lower inf_le_right hxcI)
   rwa [inf_comm, sup_inf_inf_compl] at ass
 #align order.ideal.is_prime_of_mem_or_compl_mem Order.Ideal.isPrime_of_mem_or_compl_mem
+-/
 
+#print Order.Ideal.isPrime_iff_mem_or_compl_mem /-
 theorem isPrime_iff_mem_or_compl_mem [IsProper I] : IsPrime I ↔ ∀ {x : P}, x ∈ I ∨ xᶜ ∈ I :=
   ⟨fun h _ => h.mem_or_compl_mem, isPrime_of_mem_or_compl_mem⟩
 #align order.ideal.is_prime_iff_mem_or_compl_mem Order.Ideal.isPrime_iff_mem_or_compl_mem
+-/
 
+#print Order.Ideal.IsPrime.isMaximal /-
 instance (priority := 100) IsPrime.isMaximal [IsPrime I] : IsMaximal I :=
   by
   simp only [is_maximal_iff, Set.eq_univ_iff_forall, is_prime.to_is_proper, true_and_iff]
@@ -210,6 +229,7 @@ instance (priority := 100) IsPrime.isMaximal [IsPrime I] : IsMaximal I :=
     sup_mem (J.lower inf_le_right hyJ)
       (hIJ.le <| I.lower inf_le_right <| is_prime.mem_compl_of_not_mem ‹_› hyI)
 #align order.ideal.is_prime.is_maximal Order.Ideal.IsPrime.isMaximal
+-/
 
 end BooleanAlgebra
 

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

@@ -62,76 +62,34 @@ namespace PrimePair
 
 variable [Preorder P] (IF : PrimePair P)
 
-/- warning: order.ideal.prime_pair.compl_I_eq_F -> Order.Ideal.PrimePair.compl_I_eq_F is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (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 (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P _inst_1))))) (Order.Ideal.PrimePair.i.{u1} P _inst_1 IF))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P _inst_1)))) (Order.Ideal.PrimePair.f.{u1} P _inst_1 IF))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (HasCompl.compl.{u1} (Set.{u1} P) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} P) (Set.instBooleanAlgebraSet.{u1} P)) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.PrimePair.I.{u1} P _inst_1 IF))) (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) (Order.Ideal.PrimePair.F.{u1} P _inst_1 IF))
-Case conversion may be inaccurate. Consider using '#align order.ideal.prime_pair.compl_I_eq_F Order.Ideal.PrimePair.compl_I_eq_Fₓ'. -/
 theorem compl_I_eq_F : (IF.i : Set P)ᶜ = IF.f :=
   IF.isCompl_i_f.compl_eq
 #align order.ideal.prime_pair.compl_I_eq_F Order.Ideal.PrimePair.compl_I_eq_F
 
-/- warning: order.ideal.prime_pair.compl_F_eq_I -> Order.Ideal.PrimePair.compl_F_eq_I is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (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.PFilter.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P _inst_1)))) (Order.Ideal.PrimePair.f.{u1} P _inst_1 IF))) ((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 _inst_1)) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P _inst_1))))) (Order.Ideal.PrimePair.i.{u1} P _inst_1 IF))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (HasCompl.compl.{u1} (Set.{u1} P) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} P) (Set.instBooleanAlgebraSet.{u1} P)) (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) (Order.Ideal.PrimePair.F.{u1} P _inst_1 IF))) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.PrimePair.I.{u1} P _inst_1 IF))
-Case conversion may be inaccurate. Consider using '#align order.ideal.prime_pair.compl_F_eq_I Order.Ideal.PrimePair.compl_F_eq_Iₓ'. -/
 theorem compl_F_eq_I : (IF.f : Set P)ᶜ = IF.i :=
   IF.isCompl_i_f.eq_compl.symm
 #align order.ideal.prime_pair.compl_F_eq_I Order.Ideal.PrimePair.compl_F_eq_I
 
-/- warning: order.ideal.prime_pair.I_is_proper -> Order.Ideal.PrimePair.I_isProper is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Order.Ideal.IsProper.{u1} P (Preorder.toHasLe.{u1} P _inst_1) (Order.Ideal.PrimePair.i.{u1} P _inst_1 IF)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Order.Ideal.IsProper.{u1} P (Preorder.toLE.{u1} P _inst_1) (Order.Ideal.PrimePair.I.{u1} P _inst_1 IF)
-Case conversion may be inaccurate. Consider using '#align order.ideal.prime_pair.I_is_proper Order.Ideal.PrimePair.I_isProperₓ'. -/
 theorem I_isProper : IsProper IF.i := by
   cases IF.F.nonempty
   apply is_proper_of_not_mem (_ : w ∉ IF.I)
   rwa [← IF.compl_I_eq_F] at h
 #align order.ideal.prime_pair.I_is_proper Order.Ideal.PrimePair.I_isProper
 
-/- warning: order.ideal.prime_pair.disjoint -> Order.Ideal.PrimePair.disjoint is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Disjoint.{u1} (Set.{u1} P) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} P) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} P) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} P) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} P) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} P) (Set.completeBooleanAlgebra.{u1} P)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} P) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{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 (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P _inst_1))))) (Order.Ideal.PrimePair.i.{u1} P _inst_1 IF)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P _inst_1)))) (Order.Ideal.PrimePair.f.{u1} P _inst_1 IF))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Disjoint.{u1} (Set.{u1} P) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} P) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} P) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} P) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} P) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} P) (Set.instCompleteBooleanAlgebraSet.{u1} P)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} P) (Preorder.toLE.{u1} (Set.{u1} P) (PartialOrder.toPreorder.{u1} (Set.{u1} P) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} P) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} P) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} P) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} P) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} P) (Set.instCompleteBooleanAlgebraSet.{u1} P)))))))) (CompleteLattice.toBoundedOrder.{u1} (Set.{u1} P) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} P) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} P) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} P) (Set.instCompleteBooleanAlgebraSet.{u1} P)))))) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.PrimePair.I.{u1} P _inst_1 IF)) (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) (Order.Ideal.PrimePair.F.{u1} P _inst_1 IF))
-Case conversion may be inaccurate. Consider using '#align order.ideal.prime_pair.disjoint Order.Ideal.PrimePair.disjointₓ'. -/
 theorem disjoint : Disjoint (IF.i : Set P) IF.f :=
   IF.isCompl_i_f.Disjoint
 #align order.ideal.prime_pair.disjoint Order.Ideal.PrimePair.disjoint
 
-/- warning: order.ideal.prime_pair.I_union_F -> Order.Ideal.PrimePair.I_union_F is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (Union.union.{u1} (Set.{u1} P) (Set.hasUnion.{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 _inst_1)) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P _inst_1))))) (Order.Ideal.PrimePair.i.{u1} P _inst_1 IF)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P _inst_1)))) (Order.Ideal.PrimePair.f.{u1} P _inst_1 IF))) (Set.univ.{u1} P)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (Union.union.{u1} (Set.{u1} P) (Set.instUnionSet.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.PrimePair.I.{u1} P _inst_1 IF)) (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) (Order.Ideal.PrimePair.F.{u1} P _inst_1 IF))) (Set.univ.{u1} P)
-Case conversion may be inaccurate. Consider using '#align order.ideal.prime_pair.I_union_F Order.Ideal.PrimePair.I_union_Fₓ'. -/
 theorem I_union_F : (IF.i : Set P) ∪ IF.f = Set.univ :=
   IF.isCompl_i_f.sup_eq_top
 #align order.ideal.prime_pair.I_union_F Order.Ideal.PrimePair.I_union_F
 
-/- warning: order.ideal.prime_pair.F_union_I -> Order.Ideal.PrimePair.F_union_I is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (Union.union.{u1} (Set.{u1} P) (Set.hasUnion.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P _inst_1)))) (Order.Ideal.PrimePair.f.{u1} P _inst_1 IF)) ((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 _inst_1)) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P _inst_1))))) (Order.Ideal.PrimePair.i.{u1} P _inst_1 IF))) (Set.univ.{u1} P)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (Union.union.{u1} (Set.{u1} P) (Set.instUnionSet.{u1} P) (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) (Order.Ideal.PrimePair.F.{u1} P _inst_1 IF)) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.PrimePair.I.{u1} P _inst_1 IF))) (Set.univ.{u1} P)
-Case conversion may be inaccurate. Consider using '#align order.ideal.prime_pair.F_union_I Order.Ideal.PrimePair.F_union_Iₓ'. -/
 theorem F_union_I : (IF.f : Set P) ∪ IF.i = Set.univ :=
   IF.isCompl_i_f.symm.sup_eq_top
 #align order.ideal.prime_pair.F_union_I Order.Ideal.PrimePair.F_union_I
 
 end PrimePair
 
-/- warning: order.ideal.is_prime -> Order.Ideal.IsPrime is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P], (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) -> Prop
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P], (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) -> Prop
-Case conversion may be inaccurate. Consider using '#align order.ideal.is_prime Order.Ideal.IsPrimeₓ'. -/
 /-- An ideal `I` is prime if its complement is a filter.
 -/
 @[mk_iff]
@@ -143,12 +101,6 @@ section Preorder
 
 variable [Preorder P]
 
-/- warning: order.ideal.is_prime.to_prime_pair -> Order.Ideal.IsPrime.toPrimePair 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)}, (Order.Ideal.IsPrime.{u1} P _inst_1 I) -> (Order.Ideal.PrimePair.{u1} P _inst_1)
-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)}, (Order.Ideal.IsPrime.{u1} P _inst_1 I) -> (Order.Ideal.PrimePair.{u1} P _inst_1)
-Case conversion may be inaccurate. Consider using '#align order.ideal.is_prime.to_prime_pair Order.Ideal.IsPrime.toPrimePairₓ'. -/
 /-- Create an element of type `order.ideal.prime_pair` from an ideal satisfying the predicate
 `order.ideal.is_prime`. -/
 def IsPrime.toPrimePair {I : Ideal P} (h : IsPrime I) : PrimePair P :=
@@ -157,12 +109,6 @@ def IsPrime.toPrimePair {I : Ideal P} (h : IsPrime I) : PrimePair P :=
     isCompl_i_f := isCompl_compl }
 #align order.ideal.is_prime.to_prime_pair Order.Ideal.IsPrime.toPrimePair
 
-/- warning: order.ideal.prime_pair.I_is_prime -> Order.Ideal.PrimePair.I_isPrime is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Order.Ideal.IsPrime.{u1} P _inst_1 (Order.Ideal.PrimePair.i.{u1} P _inst_1 IF)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Order.Ideal.IsPrime.{u1} P _inst_1 (Order.Ideal.PrimePair.I.{u1} P _inst_1 IF)
-Case conversion may be inaccurate. Consider using '#align order.ideal.prime_pair.I_is_prime Order.Ideal.PrimePair.I_isPrimeₓ'. -/
 theorem PrimePair.I_isPrime (IF : PrimePair P) : IsPrime IF.i :=
   { IF.I_isProper with compl_filter := by rw [IF.compl_I_eq_F]; exact IF.F.is_pfilter }
 #align order.ideal.prime_pair.I_is_prime Order.Ideal.PrimePair.I_isPrime
@@ -173,12 +119,6 @@ section SemilatticeInf
 
 variable [SemilatticeInf P] {x y : P} {I : Ideal P}
 
-/- warning: order.ideal.is_prime.mem_or_mem -> Order.Ideal.IsPrime.mem_or_mem is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))}, (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I) -> (forall {x : P} {y : P}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toHasInf.{u1} P _inst_1) x y) I) -> (Or (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I)))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))}, (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I) -> (forall {x : P} {y : P}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toInf.{u1} P _inst_1) x y) I) -> (Or (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I)))
-Case conversion may be inaccurate. Consider using '#align order.ideal.is_prime.mem_or_mem Order.Ideal.IsPrime.mem_or_memₓ'. -/
 theorem IsPrime.mem_or_mem (hI : IsPrime I) {x y : P} : x ⊓ y ∈ I → x ∈ I ∨ y ∈ I :=
   by
   contrapose!
@@ -187,12 +127,6 @@ theorem IsPrime.mem_or_mem (hI : IsPrime I) {x y : P} : x ⊓ y ∈ I → x ∈
   exact fun h => inf_mem h.1 h.2
 #align order.ideal.is_prime.mem_or_mem Order.Ideal.IsPrime.mem_or_mem
 
-/- warning: order.ideal.is_prime.of_mem_or_mem -> Order.Ideal.IsPrime.of_mem_or_mem is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))} [_inst_2 : Order.Ideal.IsProper.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) I], (forall {x : P} {y : P}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toHasInf.{u1} P _inst_1) x y) I) -> (Or (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I))) -> (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))} [_inst_2 : Order.Ideal.IsProper.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) I], (forall {x : P} {y : P}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toInf.{u1} P _inst_1) x y) I) -> (Or (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I))) -> (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I)
-Case conversion may be inaccurate. Consider using '#align order.ideal.is_prime.of_mem_or_mem Order.Ideal.IsPrime.of_mem_or_memₓ'. -/
 theorem IsPrime.of_mem_or_mem [IsProper I] (hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I) :
     IsPrime I := by
   rw [is_prime_iff]
@@ -206,12 +140,6 @@ theorem IsPrime.of_mem_or_mem [IsProper I] (hI : ∀ {x y : P}, x ⊓ y ∈ I 
   · exact @mem_compl_of_ge _ _ _
 #align order.ideal.is_prime.of_mem_or_mem Order.Ideal.IsPrime.of_mem_or_mem
 
-/- warning: order.ideal.is_prime_iff_mem_or_mem -> Order.Ideal.isPrime_iff_mem_or_mem is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))} [_inst_2 : Order.Ideal.IsProper.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) I], Iff (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I) (forall {x : P} {y : P}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toHasInf.{u1} P _inst_1) x y) I) -> (Or (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I)))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))} [_inst_2 : Order.Ideal.IsProper.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) I], Iff (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I) (forall {x : P} {y : P}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toInf.{u1} P _inst_1) x y) I) -> (Or (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I)))
-Case conversion may be inaccurate. Consider using '#align order.ideal.is_prime_iff_mem_or_mem Order.Ideal.isPrime_iff_mem_or_memₓ'. -/
 theorem isPrime_iff_mem_or_mem [IsProper I] : IsPrime I ↔ ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I :=
   ⟨IsPrime.mem_or_mem, IsPrime.of_mem_or_mem⟩
 #align order.ideal.is_prime_iff_mem_or_mem Order.Ideal.isPrime_iff_mem_or_mem
@@ -222,12 +150,6 @@ section DistribLattice
 
 variable [DistribLattice P] {I : Ideal P}
 
-/- warning: order.ideal.is_maximal.is_prime -> Order.Ideal.IsMaximal.isPrime 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)))))} [_inst_2 : Order.Ideal.IsMaximal.{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], Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))) I
-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)))))} [_inst_2 : Order.Ideal.IsMaximal.{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], Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))) I
-Case conversion may be inaccurate. Consider using '#align order.ideal.is_maximal.is_prime Order.Ideal.IsMaximal.isPrimeₓ'. -/
 instance (priority := 100) IsMaximal.isPrime [IsMaximal I] : IsPrime I :=
   by
   rw [is_prime_iff_mem_or_mem]
@@ -253,12 +175,6 @@ section BooleanAlgebra
 
 variable [BooleanAlgebra P] {x : P} {I : Ideal P}
 
-/- warning: order.ideal.is_prime.mem_or_compl_mem -> Order.Ideal.IsPrime.mem_or_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.IsPrime.{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 (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) (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.IsPrime.{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 (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) (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_prime.mem_or_compl_mem Order.Ideal.IsPrime.mem_or_compl_memₓ'. -/
 theorem IsPrime.mem_or_compl_mem (hI : IsPrime I) : x ∈ I ∨ xᶜ ∈ I :=
   by
   apply hI.mem_or_mem
@@ -266,22 +182,10 @@ theorem IsPrime.mem_or_compl_mem (hI : IsPrime I) : x ∈ I ∨ xᶜ ∈ I :=
   exact I.bot_mem
 #align order.ideal.is_prime.mem_or_compl_mem Order.Ideal.IsPrime.mem_or_compl_mem
 
-/- warning: order.ideal.is_prime.mem_compl_of_not_mem -> Order.Ideal.IsPrime.mem_compl_of_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.IsPrime.{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) -> (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)) -> (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.IsPrime.{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) -> (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)) -> (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_prime.mem_compl_of_not_mem Order.Ideal.IsPrime.mem_compl_of_not_memₓ'. -/
 theorem IsPrime.mem_compl_of_not_mem (hI : IsPrime I) (hxnI : x ∉ I) : xᶜ ∈ I :=
   hI.mem_or_compl_mem.resolve_left hxnI
 #align order.ideal.is_prime.mem_compl_of_not_mem Order.Ideal.IsPrime.mem_compl_of_not_mem
 
-/- warning: order.ideal.is_prime_of_mem_or_compl_mem -> Order.Ideal.isPrime_of_mem_or_compl_mem is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} 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)))))))} [_inst_2 : 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], (forall {x : P}, Or (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) (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)) -> (Order.Ideal.IsPrime.{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)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} 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))))))))} [_inst_2 : 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], (forall {x : P}, Or (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) (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)) -> (Order.Ideal.IsPrime.{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)
-Case conversion may be inaccurate. Consider using '#align order.ideal.is_prime_of_mem_or_compl_mem Order.Ideal.isPrime_of_mem_or_compl_memₓ'. -/
 theorem isPrime_of_mem_or_compl_mem [IsProper I] (h : ∀ {x : P}, x ∈ I ∨ xᶜ ∈ I) : IsPrime I :=
   by
   simp only [is_prime_iff_mem_or_mem, or_iff_not_imp_left]
@@ -291,22 +195,10 @@ theorem isPrime_of_mem_or_compl_mem [IsProper I] (h : ∀ {x : P}, x ∈ I ∨ x
   rwa [inf_comm, sup_inf_inf_compl] at ass
 #align order.ideal.is_prime_of_mem_or_compl_mem Order.Ideal.isPrime_of_mem_or_compl_mem
 
-/- warning: order.ideal.is_prime_iff_mem_or_compl_mem -> Order.Ideal.isPrime_iff_mem_or_compl_mem is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} 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)))))))} [_inst_2 : 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], Iff (Order.Ideal.IsPrime.{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) (forall {x : P}, Or (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) (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] {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))))))))} [_inst_2 : 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], Iff (Order.Ideal.IsPrime.{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) (forall {x : P}, Or (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) (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_prime_iff_mem_or_compl_mem Order.Ideal.isPrime_iff_mem_or_compl_memₓ'. -/
 theorem isPrime_iff_mem_or_compl_mem [IsProper I] : IsPrime I ↔ ∀ {x : P}, x ∈ I ∨ xᶜ ∈ I :=
   ⟨fun h _ => h.mem_or_compl_mem, isPrime_of_mem_or_compl_mem⟩
 #align order.ideal.is_prime_iff_mem_or_compl_mem Order.Ideal.isPrime_iff_mem_or_compl_mem
 
-/- warning: order.ideal.is_prime.is_maximal -> Order.Ideal.IsPrime.isMaximal is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} 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)))))))} [_inst_2 : Order.Ideal.IsPrime.{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], Order.Ideal.IsMaximal.{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
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} 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))))))))} [_inst_2 : Order.Ideal.IsPrime.{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], Order.Ideal.IsMaximal.{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
-Case conversion may be inaccurate. Consider using '#align order.ideal.is_prime.is_maximal Order.Ideal.IsPrime.isMaximalₓ'. -/
 instance (priority := 100) IsPrime.isMaximal [IsPrime I] : IsMaximal I :=
   by
   simp only [is_maximal_iff, Set.eq_univ_iff_forall, is_prime.to_is_proper, true_and_iff]

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

@@ -164,10 +164,7 @@ but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Order.Ideal.IsPrime.{u1} P _inst_1 (Order.Ideal.PrimePair.I.{u1} P _inst_1 IF)
 Case conversion may be inaccurate. Consider using '#align order.ideal.prime_pair.I_is_prime Order.Ideal.PrimePair.I_isPrimeₓ'. -/
 theorem PrimePair.I_isPrime (IF : PrimePair P) : IsPrime IF.i :=
-  { IF.I_isProper with
-    compl_filter := by
-      rw [IF.compl_I_eq_F]
-      exact IF.F.is_pfilter }
+  { IF.I_isProper with compl_filter := by rw [IF.compl_I_eq_F]; exact IF.F.is_pfilter }
 #align order.ideal.prime_pair.I_is_prime Order.Ideal.PrimePair.I_isPrime
 
 end Preorder
@@ -351,10 +348,7 @@ def IsPrime.toPrimePair {F : PFilter P} (h : IsPrime F) : Ideal.PrimePair P :=
 
 #print Order.Ideal.PrimePair.F_isPrime /-
 theorem Order.Ideal.PrimePair.F_isPrime (IF : Ideal.PrimePair P) : IsPrime IF.f :=
-  {
-    compl_ideal := by
-      rw [IF.compl_F_eq_I]
-      exact IF.I.is_ideal }
+  { compl_ideal := by rw [IF.compl_F_eq_I]; exact IF.I.is_ideal }
 #align order.ideal.prime_pair.F_is_prime Order.Ideal.PrimePair.F_isPrime
 -/
 

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

@@ -64,7 +64,7 @@ variable [Preorder P] (IF : PrimePair P)
 
 /- warning: order.ideal.prime_pair.compl_I_eq_F -> Order.Ideal.PrimePair.compl_I_eq_F is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (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 (Preorder.toLE.{u1} P _inst_1)) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P _inst_1))))) (Order.Ideal.PrimePair.i.{u1} P _inst_1 IF))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P _inst_1)))) (Order.Ideal.PrimePair.f.{u1} P _inst_1 IF))
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (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 (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P _inst_1))))) (Order.Ideal.PrimePair.i.{u1} P _inst_1 IF))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P _inst_1)))) (Order.Ideal.PrimePair.f.{u1} P _inst_1 IF))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (HasCompl.compl.{u1} (Set.{u1} P) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} P) (Set.instBooleanAlgebraSet.{u1} P)) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.PrimePair.I.{u1} P _inst_1 IF))) (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) (Order.Ideal.PrimePair.F.{u1} P _inst_1 IF))
 Case conversion may be inaccurate. Consider using '#align order.ideal.prime_pair.compl_I_eq_F Order.Ideal.PrimePair.compl_I_eq_Fₓ'. -/
@@ -74,7 +74,7 @@ theorem compl_I_eq_F : (IF.i : Set P)ᶜ = IF.f :=
 
 /- warning: order.ideal.prime_pair.compl_F_eq_I -> Order.Ideal.PrimePair.compl_F_eq_I is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (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.PFilter.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P _inst_1)))) (Order.Ideal.PrimePair.f.{u1} P _inst_1 IF))) ((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 _inst_1)) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P _inst_1))))) (Order.Ideal.PrimePair.i.{u1} P _inst_1 IF))
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (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.PFilter.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P _inst_1)))) (Order.Ideal.PrimePair.f.{u1} P _inst_1 IF))) ((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 _inst_1)) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P _inst_1))))) (Order.Ideal.PrimePair.i.{u1} P _inst_1 IF))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (HasCompl.compl.{u1} (Set.{u1} P) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} P) (Set.instBooleanAlgebraSet.{u1} P)) (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) (Order.Ideal.PrimePair.F.{u1} P _inst_1 IF))) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.PrimePair.I.{u1} P _inst_1 IF))
 Case conversion may be inaccurate. Consider using '#align order.ideal.prime_pair.compl_F_eq_I Order.Ideal.PrimePair.compl_F_eq_Iₓ'. -/
@@ -82,17 +82,21 @@ theorem compl_F_eq_I : (IF.f : Set P)ᶜ = IF.i :=
   IF.isCompl_i_f.eq_compl.symm
 #align order.ideal.prime_pair.compl_F_eq_I Order.Ideal.PrimePair.compl_F_eq_I
 
-#print Order.Ideal.PrimePair.I_isProper /-
+/- warning: order.ideal.prime_pair.I_is_proper -> Order.Ideal.PrimePair.I_isProper is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Order.Ideal.IsProper.{u1} P (Preorder.toHasLe.{u1} P _inst_1) (Order.Ideal.PrimePair.i.{u1} P _inst_1 IF)
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Order.Ideal.IsProper.{u1} P (Preorder.toLE.{u1} P _inst_1) (Order.Ideal.PrimePair.I.{u1} P _inst_1 IF)
+Case conversion may be inaccurate. Consider using '#align order.ideal.prime_pair.I_is_proper Order.Ideal.PrimePair.I_isProperₓ'. -/
 theorem I_isProper : IsProper IF.i := by
   cases IF.F.nonempty
   apply is_proper_of_not_mem (_ : w ∉ IF.I)
   rwa [← IF.compl_I_eq_F] at h
 #align order.ideal.prime_pair.I_is_proper Order.Ideal.PrimePair.I_isProper
--/
 
 /- warning: order.ideal.prime_pair.disjoint -> Order.Ideal.PrimePair.disjoint is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Disjoint.{u1} (Set.{u1} P) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} P) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} P) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} P) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} P) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} P) (Set.completeBooleanAlgebra.{u1} P)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} P) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{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 (Preorder.toLE.{u1} P _inst_1)) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P _inst_1))))) (Order.Ideal.PrimePair.i.{u1} P _inst_1 IF)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P _inst_1)))) (Order.Ideal.PrimePair.f.{u1} P _inst_1 IF))
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Disjoint.{u1} (Set.{u1} P) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} P) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} P) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} P) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} P) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} P) (Set.completeBooleanAlgebra.{u1} P)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} P) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{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 (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P _inst_1))))) (Order.Ideal.PrimePair.i.{u1} P _inst_1 IF)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P _inst_1)))) (Order.Ideal.PrimePair.f.{u1} P _inst_1 IF))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Disjoint.{u1} (Set.{u1} P) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} P) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} P) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} P) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} P) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} P) (Set.instCompleteBooleanAlgebraSet.{u1} P)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} P) (Preorder.toLE.{u1} (Set.{u1} P) (PartialOrder.toPreorder.{u1} (Set.{u1} P) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} P) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} P) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} P) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} P) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} P) (Set.instCompleteBooleanAlgebraSet.{u1} P)))))))) (CompleteLattice.toBoundedOrder.{u1} (Set.{u1} P) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} P) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} P) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} P) (Set.instCompleteBooleanAlgebraSet.{u1} P)))))) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.PrimePair.I.{u1} P _inst_1 IF)) (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) (Order.Ideal.PrimePair.F.{u1} P _inst_1 IF))
 Case conversion may be inaccurate. Consider using '#align order.ideal.prime_pair.disjoint Order.Ideal.PrimePair.disjointₓ'. -/
@@ -102,7 +106,7 @@ theorem disjoint : Disjoint (IF.i : Set P) IF.f :=
 
 /- warning: order.ideal.prime_pair.I_union_F -> Order.Ideal.PrimePair.I_union_F is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (Union.union.{u1} (Set.{u1} P) (Set.hasUnion.{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 _inst_1)) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P _inst_1))))) (Order.Ideal.PrimePair.i.{u1} P _inst_1 IF)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P _inst_1)))) (Order.Ideal.PrimePair.f.{u1} P _inst_1 IF))) (Set.univ.{u1} P)
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (Union.union.{u1} (Set.{u1} P) (Set.hasUnion.{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 _inst_1)) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P _inst_1))))) (Order.Ideal.PrimePair.i.{u1} P _inst_1 IF)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P _inst_1)))) (Order.Ideal.PrimePair.f.{u1} P _inst_1 IF))) (Set.univ.{u1} P)
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (Union.union.{u1} (Set.{u1} P) (Set.instUnionSet.{u1} P) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.PrimePair.I.{u1} P _inst_1 IF)) (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) (Order.Ideal.PrimePair.F.{u1} P _inst_1 IF))) (Set.univ.{u1} P)
 Case conversion may be inaccurate. Consider using '#align order.ideal.prime_pair.I_union_F Order.Ideal.PrimePair.I_union_Fₓ'. -/
@@ -112,7 +116,7 @@ theorem I_union_F : (IF.i : Set P) ∪ IF.f = Set.univ :=
 
 /- warning: order.ideal.prime_pair.F_union_I -> Order.Ideal.PrimePair.F_union_I is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (Union.union.{u1} (Set.{u1} P) (Set.hasUnion.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P _inst_1)))) (Order.Ideal.PrimePair.f.{u1} P _inst_1 IF)) ((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 _inst_1)) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P _inst_1))))) (Order.Ideal.PrimePair.i.{u1} P _inst_1 IF))) (Set.univ.{u1} P)
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (Union.union.{u1} (Set.{u1} P) (Set.hasUnion.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P _inst_1) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P _inst_1)))) (Order.Ideal.PrimePair.f.{u1} P _inst_1 IF)) ((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 _inst_1)) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) (Set.{u1} P) (SetLike.Set.hasCoeT.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P _inst_1))))) (Order.Ideal.PrimePair.i.{u1} P _inst_1 IF))) (Set.univ.{u1} P)
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Eq.{succ u1} (Set.{u1} P) (Union.union.{u1} (Set.{u1} P) (Set.instUnionSet.{u1} P) (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) (Order.Ideal.PrimePair.F.{u1} P _inst_1 IF)) (SetLike.coe.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P _inst_1)) (Order.Ideal.PrimePair.I.{u1} P _inst_1 IF))) (Set.univ.{u1} P)
 Case conversion may be inaccurate. Consider using '#align order.ideal.prime_pair.F_union_I Order.Ideal.PrimePair.F_union_Iₓ'. -/
@@ -122,20 +126,29 @@ theorem F_union_I : (IF.f : Set P) ∪ IF.i = Set.univ :=
 
 end PrimePair
 
-#print Order.Ideal.IsPrime /-
+/- warning: order.ideal.is_prime -> Order.Ideal.IsPrime is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P], (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) -> Prop
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P], (Order.Ideal.{u1} P (Preorder.toLE.{u1} P _inst_1)) -> Prop
+Case conversion may be inaccurate. Consider using '#align order.ideal.is_prime Order.Ideal.IsPrimeₓ'. -/
 /-- An ideal `I` is prime if its complement is a filter.
 -/
 @[mk_iff]
 class IsPrime [Preorder P] (I : Ideal P) extends IsProper I : Prop where
   compl_filter : IsPFilter ((I : Set P)ᶜ)
 #align order.ideal.is_prime Order.Ideal.IsPrime
--/
 
 section Preorder
 
 variable [Preorder P]
 
-#print Order.Ideal.IsPrime.toPrimePair /-
+/- warning: order.ideal.is_prime.to_prime_pair -> Order.Ideal.IsPrime.toPrimePair 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)}, (Order.Ideal.IsPrime.{u1} P _inst_1 I) -> (Order.Ideal.PrimePair.{u1} P _inst_1)
+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)}, (Order.Ideal.IsPrime.{u1} P _inst_1 I) -> (Order.Ideal.PrimePair.{u1} P _inst_1)
+Case conversion may be inaccurate. Consider using '#align order.ideal.is_prime.to_prime_pair Order.Ideal.IsPrime.toPrimePairₓ'. -/
 /-- Create an element of type `order.ideal.prime_pair` from an ideal satisfying the predicate
 `order.ideal.is_prime`. -/
 def IsPrime.toPrimePair {I : Ideal P} (h : IsPrime I) : PrimePair P :=
@@ -143,16 +156,19 @@ def IsPrime.toPrimePair {I : Ideal P} (h : IsPrime I) : PrimePair P :=
     f := h.compl_filter.toPFilter
     isCompl_i_f := isCompl_compl }
 #align order.ideal.is_prime.to_prime_pair Order.Ideal.IsPrime.toPrimePair
--/
 
-#print Order.Ideal.PrimePair.I_isPrime /-
+/- warning: order.ideal.prime_pair.I_is_prime -> Order.Ideal.PrimePair.I_isPrime is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Order.Ideal.IsPrime.{u1} P _inst_1 (Order.Ideal.PrimePair.i.{u1} P _inst_1 IF)
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (IF : Order.Ideal.PrimePair.{u1} P _inst_1), Order.Ideal.IsPrime.{u1} P _inst_1 (Order.Ideal.PrimePair.I.{u1} P _inst_1 IF)
+Case conversion may be inaccurate. Consider using '#align order.ideal.prime_pair.I_is_prime Order.Ideal.PrimePair.I_isPrimeₓ'. -/
 theorem PrimePair.I_isPrime (IF : PrimePair P) : IsPrime IF.i :=
   { IF.I_isProper with
     compl_filter := by
       rw [IF.compl_I_eq_F]
       exact IF.F.is_pfilter }
 #align order.ideal.prime_pair.I_is_prime Order.Ideal.PrimePair.I_isPrime
--/
 
 end Preorder
 
@@ -162,7 +178,7 @@ variable [SemilatticeInf P] {x y : P} {I : Ideal P}
 
 /- warning: order.ideal.is_prime.mem_or_mem -> Order.Ideal.IsPrime.mem_or_mem is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))}, (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I) -> (forall {x : P} {y : P}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toHasInf.{u1} P _inst_1) x y) I) -> (Or (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I)))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))}, (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I) -> (forall {x : P} {y : P}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toHasInf.{u1} P _inst_1) x y) I) -> (Or (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I)))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))}, (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I) -> (forall {x : P} {y : P}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toInf.{u1} P _inst_1) x y) I) -> (Or (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I)))
 Case conversion may be inaccurate. Consider using '#align order.ideal.is_prime.mem_or_mem Order.Ideal.IsPrime.mem_or_memₓ'. -/
@@ -176,7 +192,7 @@ theorem IsPrime.mem_or_mem (hI : IsPrime I) {x y : P} : x ⊓ y ∈ I → x ∈
 
 /- warning: order.ideal.is_prime.of_mem_or_mem -> Order.Ideal.IsPrime.of_mem_or_mem is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))} [_inst_2 : Order.Ideal.IsProper.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) I], (forall {x : P} {y : P}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toHasInf.{u1} P _inst_1) x y) I) -> (Or (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I))) -> (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I)
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))} [_inst_2 : Order.Ideal.IsProper.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) I], (forall {x : P} {y : P}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toHasInf.{u1} P _inst_1) x y) I) -> (Or (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I))) -> (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I)
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))} [_inst_2 : Order.Ideal.IsProper.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) I], (forall {x : P} {y : P}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toInf.{u1} P _inst_1) x y) I) -> (Or (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I))) -> (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I)
 Case conversion may be inaccurate. Consider using '#align order.ideal.is_prime.of_mem_or_mem Order.Ideal.IsPrime.of_mem_or_memₓ'. -/
@@ -195,7 +211,7 @@ theorem IsPrime.of_mem_or_mem [IsProper I] (hI : ∀ {x y : P}, x ⊓ y ∈ I 
 
 /- warning: order.ideal.is_prime_iff_mem_or_mem -> Order.Ideal.isPrime_iff_mem_or_mem is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))} [_inst_2 : Order.Ideal.IsProper.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) I], Iff (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I) (forall {x : P} {y : P}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toHasInf.{u1} P _inst_1) x y) I) -> (Or (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I)))
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))} [_inst_2 : Order.Ideal.IsProper.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) I], Iff (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I) (forall {x : P} {y : P}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toHasInf.{u1} P _inst_1) x y) I) -> (Or (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toHasLe.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I)))
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))} [_inst_2 : Order.Ideal.IsProper.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) I], Iff (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I) (forall {x : P} {y : P}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toInf.{u1} P _inst_1) x y) I) -> (Or (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I)))
 Case conversion may be inaccurate. Consider using '#align order.ideal.is_prime_iff_mem_or_mem Order.Ideal.isPrime_iff_mem_or_memₓ'. -/
@@ -209,7 +225,12 @@ section DistribLattice
 
 variable [DistribLattice P] {I : Ideal P}
 
-#print Order.Ideal.IsMaximal.isPrime /-
+/- warning: order.ideal.is_maximal.is_prime -> Order.Ideal.IsMaximal.isPrime 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)))))} [_inst_2 : Order.Ideal.IsMaximal.{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], Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))) I
+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)))))} [_inst_2 : Order.Ideal.IsMaximal.{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], Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P (Lattice.toSemilatticeInf.{u1} P (DistribLattice.toLattice.{u1} P _inst_1)))) I
+Case conversion may be inaccurate. Consider using '#align order.ideal.is_maximal.is_prime Order.Ideal.IsMaximal.isPrimeₓ'. -/
 instance (priority := 100) IsMaximal.isPrime [IsMaximal I] : IsPrime I :=
   by
   rw [is_prime_iff_mem_or_mem]
@@ -228,7 +249,6 @@ instance (priority := 100) IsMaximal.isPrime [IsMaximal I] : IsPrime I :=
   rw [hy]
   exact le_sup_right
 #align order.ideal.is_maximal.is_prime Order.Ideal.IsMaximal.isPrime
--/
 
 end DistribLattice
 
@@ -236,22 +256,35 @@ section BooleanAlgebra
 
 variable [BooleanAlgebra P] {x : P} {I : Ideal P}
 
-#print Order.Ideal.IsPrime.mem_or_compl_mem /-
+/- warning: order.ideal.is_prime.mem_or_compl_mem -> Order.Ideal.IsPrime.mem_or_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.IsPrime.{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 (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) (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.IsPrime.{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 (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) (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_prime.mem_or_compl_mem Order.Ideal.IsPrime.mem_or_compl_memₓ'. -/
 theorem IsPrime.mem_or_compl_mem (hI : IsPrime I) : x ∈ I ∨ xᶜ ∈ I :=
   by
   apply hI.mem_or_mem
   rw [inf_compl_eq_bot]
   exact I.bot_mem
 #align order.ideal.is_prime.mem_or_compl_mem Order.Ideal.IsPrime.mem_or_compl_mem
--/
 
-#print Order.Ideal.IsPrime.mem_compl_of_not_mem /-
+/- warning: order.ideal.is_prime.mem_compl_of_not_mem -> Order.Ideal.IsPrime.mem_compl_of_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.IsPrime.{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) -> (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)) -> (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.IsPrime.{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) -> (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)) -> (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_prime.mem_compl_of_not_mem Order.Ideal.IsPrime.mem_compl_of_not_memₓ'. -/
 theorem IsPrime.mem_compl_of_not_mem (hI : IsPrime I) (hxnI : x ∉ I) : xᶜ ∈ I :=
   hI.mem_or_compl_mem.resolve_left hxnI
 #align order.ideal.is_prime.mem_compl_of_not_mem Order.Ideal.IsPrime.mem_compl_of_not_mem
--/
 
-#print Order.Ideal.isPrime_of_mem_or_compl_mem /-
+/- warning: order.ideal.is_prime_of_mem_or_compl_mem -> Order.Ideal.isPrime_of_mem_or_compl_mem is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} 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)))))))} [_inst_2 : 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], (forall {x : P}, Or (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) (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)) -> (Order.Ideal.IsPrime.{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)
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} 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))))))))} [_inst_2 : 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], (forall {x : P}, Or (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) (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)) -> (Order.Ideal.IsPrime.{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)
+Case conversion may be inaccurate. Consider using '#align order.ideal.is_prime_of_mem_or_compl_mem Order.Ideal.isPrime_of_mem_or_compl_memₓ'. -/
 theorem isPrime_of_mem_or_compl_mem [IsProper I] (h : ∀ {x : P}, x ∈ I ∨ xᶜ ∈ I) : IsPrime I :=
   by
   simp only [is_prime_iff_mem_or_mem, or_iff_not_imp_left]
@@ -260,15 +293,23 @@ theorem isPrime_of_mem_or_compl_mem [IsProper I] (h : ∀ {x : P}, x ∈ I ∨ x
   have ass : x ⊓ y ⊔ y ⊓ xᶜ ∈ I := sup_mem hxy (I.lower inf_le_right hxcI)
   rwa [inf_comm, sup_inf_inf_compl] at ass
 #align order.ideal.is_prime_of_mem_or_compl_mem Order.Ideal.isPrime_of_mem_or_compl_mem
--/
 
-#print Order.Ideal.isPrime_iff_mem_or_compl_mem /-
+/- warning: order.ideal.is_prime_iff_mem_or_compl_mem -> Order.Ideal.isPrime_iff_mem_or_compl_mem is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} 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)))))))} [_inst_2 : 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], Iff (Order.Ideal.IsPrime.{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) (forall {x : P}, Or (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) (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] {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))))))))} [_inst_2 : 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], Iff (Order.Ideal.IsPrime.{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) (forall {x : P}, Or (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) (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_prime_iff_mem_or_compl_mem Order.Ideal.isPrime_iff_mem_or_compl_memₓ'. -/
 theorem isPrime_iff_mem_or_compl_mem [IsProper I] : IsPrime I ↔ ∀ {x : P}, x ∈ I ∨ xᶜ ∈ I :=
   ⟨fun h _ => h.mem_or_compl_mem, isPrime_of_mem_or_compl_mem⟩
 #align order.ideal.is_prime_iff_mem_or_compl_mem Order.Ideal.isPrime_iff_mem_or_compl_mem
--/
 
-#print Order.Ideal.IsPrime.isMaximal /-
+/- warning: order.ideal.is_prime.is_maximal -> Order.Ideal.IsPrime.isMaximal is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} 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)))))))} [_inst_2 : Order.Ideal.IsPrime.{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], Order.Ideal.IsMaximal.{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
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} 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))))))))} [_inst_2 : Order.Ideal.IsPrime.{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], Order.Ideal.IsMaximal.{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
+Case conversion may be inaccurate. Consider using '#align order.ideal.is_prime.is_maximal Order.Ideal.IsPrime.isMaximalₓ'. -/
 instance (priority := 100) IsPrime.isMaximal [IsPrime I] : IsMaximal I :=
   by
   simp only [is_maximal_iff, Set.eq_univ_iff_forall, is_prime.to_is_proper, true_and_iff]
@@ -280,7 +321,6 @@ instance (priority := 100) IsPrime.isMaximal [IsPrime I] : IsMaximal I :=
     sup_mem (J.lower inf_le_right hyJ)
       (hIJ.le <| I.lower inf_le_right <| is_prime.mem_compl_of_not_mem ‹_› hyI)
 #align order.ideal.is_prime.is_maximal Order.Ideal.IsPrime.isMaximal
--/
 
 end BooleanAlgebra
 

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

@@ -160,7 +160,12 @@ section SemilatticeInf
 
 variable [SemilatticeInf P] {x y : P} {I : Ideal P}
 
-#print Order.Ideal.IsPrime.mem_or_mem /-
+/- warning: order.ideal.is_prime.mem_or_mem -> Order.Ideal.IsPrime.mem_or_mem is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))}, (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I) -> (forall {x : P} {y : P}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toHasInf.{u1} P _inst_1) x y) I) -> (Or (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I)))
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))}, (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I) -> (forall {x : P} {y : P}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toInf.{u1} P _inst_1) x y) I) -> (Or (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I)))
+Case conversion may be inaccurate. Consider using '#align order.ideal.is_prime.mem_or_mem Order.Ideal.IsPrime.mem_or_memₓ'. -/
 theorem IsPrime.mem_or_mem (hI : IsPrime I) {x y : P} : x ⊓ y ∈ I → x ∈ I ∨ y ∈ I :=
   by
   contrapose!
@@ -168,9 +173,13 @@ theorem IsPrime.mem_or_mem (hI : IsPrime I) {x y : P} : x ⊓ y ∈ I → x ∈
   show x ∈ F ∧ y ∈ F → x ⊓ y ∈ F
   exact fun h => inf_mem h.1 h.2
 #align order.ideal.is_prime.mem_or_mem Order.Ideal.IsPrime.mem_or_mem
--/
 
-#print Order.Ideal.IsPrime.of_mem_or_mem /-
+/- warning: order.ideal.is_prime.of_mem_or_mem -> Order.Ideal.IsPrime.of_mem_or_mem is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))} [_inst_2 : Order.Ideal.IsProper.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) I], (forall {x : P} {y : P}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toHasInf.{u1} P _inst_1) x y) I) -> (Or (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I))) -> (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I)
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))} [_inst_2 : Order.Ideal.IsProper.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) I], (forall {x : P} {y : P}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toInf.{u1} P _inst_1) x y) I) -> (Or (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I))) -> (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I)
+Case conversion may be inaccurate. Consider using '#align order.ideal.is_prime.of_mem_or_mem Order.Ideal.IsPrime.of_mem_or_memₓ'. -/
 theorem IsPrime.of_mem_or_mem [IsProper I] (hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I) :
     IsPrime I := by
   rw [is_prime_iff]
@@ -183,13 +192,16 @@ theorem IsPrime.of_mem_or_mem [IsProper I] (hI : ∀ {x y : P}, x ⊓ y ∈ I 
     tauto
   · exact @mem_compl_of_ge _ _ _
 #align order.ideal.is_prime.of_mem_or_mem Order.Ideal.IsPrime.of_mem_or_mem
--/
 
-#print Order.Ideal.isPrime_iff_mem_or_mem /-
+/- warning: order.ideal.is_prime_iff_mem_or_mem -> Order.Ideal.isPrime_iff_mem_or_mem is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))} [_inst_2 : Order.Ideal.IsProper.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) I], Iff (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I) (forall {x : P} {y : P}, (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toHasInf.{u1} P _inst_1) x y) I) -> (Or (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.Mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.setLike.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I)))
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {I : Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))} [_inst_2 : Order.Ideal.IsProper.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) I], Iff (Order.Ideal.IsPrime.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)) I) (forall {x : P} {y : P}, (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Inf.inf.{u1} P (SemilatticeInf.toInf.{u1} P _inst_1) x y) I) -> (Or (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) x I) (Membership.mem.{u1, u1} P (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) P (Order.Ideal.instSetLikeIdeal.{u1} P (Preorder.toLE.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))))) y I)))
+Case conversion may be inaccurate. Consider using '#align order.ideal.is_prime_iff_mem_or_mem Order.Ideal.isPrime_iff_mem_or_memₓ'. -/
 theorem isPrime_iff_mem_or_mem [IsProper I] : IsPrime I ↔ ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I :=
   ⟨IsPrime.mem_or_mem, IsPrime.of_mem_or_mem⟩
 #align order.ideal.is_prime_iff_mem_or_mem Order.Ideal.isPrime_iff_mem_or_mem
--/
 
 end SemilatticeInf
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/3ade05ac9447ae31a22d2ea5423435e054131240

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Noam Atar
 
 ! This file was ported from Lean 3 source module order.prime_ideal
-! leanprover-community/mathlib commit 14b69e9f3c16630440a2cbd46f1ddad0d561dee7
+! leanprover-community/mathlib commit 23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.Order.Pfilter
 /-!
 # Prime ideals
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 ## Main definitions
 
 Throughout this file, `P` is at least a preorder, but some sections require more

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

Reference the newly created issues #12094 and #12096, as well as the pre-existing #5171. Change all references to #10927 to #5171. Some of these changes were not labelled as "porting note"; change this for good measure.

@@ -43,7 +43,8 @@ namespace Ideal
 
 /-- A pair of an `Order.Ideal` and an `Order.PFilter` which form a partition of `P`.
 -/
--- Porting note: no attr @[nolint has_nonempty_instance]
+-- Porting note(#5171): this linter isn't ported yet.
+-- @[nolint has_nonempty_instance]
 structure PrimePair (P : Type*) [Preorder P] where
   I : Ideal P
   F : PFilter P

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

• converts "--porting note" into "-- Porting note";
• converts "porting note" into "Porting note".

@@ -43,7 +43,7 @@ namespace Ideal
 
 /-- A pair of an `Order.Ideal` and an `Order.PFilter` which form a partition of `P`.
 -/
--- porting note: no attr @[nolint has_nonempty_instance]
+-- Porting note: no attr @[nolint has_nonempty_instance]
 structure PrimePair (P : Type*) [Preorder P] where
   I : Ideal P
   F : PFilter P

• @[mk_iff] class MyPred now generates myPred_iff, not MyPred_iff
• add Lean.Name.decapitalize
• fix indentation and a few typos in the docs/comments.

Partially addresses issue #9129

@@ -129,10 +129,10 @@ theorem IsPrime.mem_or_mem (hI : IsPrime I) {x y : P} : x ⊓ y ∈ I → x ∈
 
 theorem IsPrime.of_mem_or_mem [IsProper I] (hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I) :
     IsPrime I := by
-  rw [IsPrime_iff]
+  rw [isPrime_iff]
   use ‹_›
   refine .of_def ?_ ?_ ?_
-  · exact Set.nonempty_compl.2 (I.IsProper_iff.1 ‹_›)
+  · exact Set.nonempty_compl.2 (I.isProper_iff.1 ‹_›)
   · intro x hx y hy
     exact ⟨x ⊓ y, fun h => (hI h).elim hx hy, inf_le_left, inf_le_right⟩
   · exact @mem_compl_of_ge _ _ _
@@ -195,7 +195,7 @@ theorem isPrime_iff_mem_or_compl_mem [IsProper I] : IsPrime I ↔ ∀ {x : P}, x
 #align order.ideal.is_prime_iff_mem_or_compl_mem Order.Ideal.isPrime_iff_mem_or_compl_mem
 
 instance (priority := 100) IsPrime.isMaximal [IsPrime I] : IsMaximal I := by
-  simp only [IsMaximal_iff, Set.eq_univ_iff_forall, IsPrime.toIsProper, true_and]
+  simp only [isMaximal_iff, Set.eq_univ_iff_forall, IsPrime.toIsProper, true_and]
   intro J hIJ x
   rcases Set.exists_of_ssubset hIJ with ⟨y, hyJ, hyI⟩
   suffices ass : x ⊓ y ⊔ x ⊓ yᶜ ∈ J by rwa [sup_inf_inf_compl] at ass

Many proofs use the "stream of consciousness" style from Lean 3, rather than have ... := or suffices ... from/by.

This PR updates a fraction of these to the preferred Lean 4 style.

I think a good goal would be to delete the "deferred" versions of have, suffices, and let at the bottom of Mathlib.Tactic.Have

(Anyone who would like to contribute more cleanup is welcome to push directly to this branch.)

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

@@ -198,8 +198,7 @@ instance (priority := 100) IsPrime.isMaximal [IsPrime I] : IsMaximal I := by
   simp only [IsMaximal_iff, Set.eq_univ_iff_forall, IsPrime.toIsProper, true_and]
   intro J hIJ x
   rcases Set.exists_of_ssubset hIJ with ⟨y, hyJ, hyI⟩
-  suffices ass : x ⊓ y ⊔ x ⊓ yᶜ ∈ J
-  · rwa [sup_inf_inf_compl] at ass
+  suffices ass : x ⊓ y ⊔ x ⊓ yᶜ ∈ J by rwa [sup_inf_inf_compl] at ass
   exact
     sup_mem (J.lower inf_le_right hyJ)
       (hIJ.le <| I.lower inf_le_right <| IsPrime.mem_compl_of_not_mem ‹_› hyI)

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

This has nice performance benefits.

@@ -37,14 +37,14 @@ open Order.PFilter
 
 namespace Order
 
-variable {P : Type _}
+variable {P : Type*}
 
 namespace Ideal
 
 /-- A pair of an `Order.Ideal` and an `Order.PFilter` which form a partition of `P`.
 -/
 -- porting note: no attr @[nolint has_nonempty_instance]
-structure PrimePair (P : Type _) [Preorder P] where
+structure PrimePair (P : Type*) [Preorder P] where
   I : Ideal P
   F : PFilter P
   isCompl_I_F : IsCompl (I : Set P) F

• depends on: #5966

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

@@ -2,15 +2,12 @@
 Copyright (c) 2021 Noam Atar. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Noam Atar
-
-! This file was ported from Lean 3 source module order.prime_ideal
-! leanprover-community/mathlib commit 740acc0e6f9adf4423f92a485d0456fc271482da
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.Ideal
 import Mathlib.Order.PFilter
 
+#align_import order.prime_ideal from "leanprover-community/mathlib"@"740acc0e6f9adf4423f92a485d0456fc271482da"
+
 /-!
 # Prime ideals
 

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

@@ -94,7 +94,7 @@ end PrimePair
 -/
 @[mk_iff]
 class IsPrime [Preorder P] (I : Ideal P) extends IsProper I : Prop where
-  compl_filter : IsPFilter ((I : Set P)ᶜ)
+  compl_filter : IsPFilter (I : Set P)ᶜ
 #align order.ideal.is_prime Order.Ideal.IsPrime
 
 section Preorder
@@ -220,7 +220,7 @@ variable [Preorder P]
 -/
 @[mk_iff]
 class IsPrime (F : PFilter P) : Prop where
-  compl_ideal : IsIdeal ((F : Set P)ᶜ)
+  compl_ideal : IsIdeal (F : Set P)ᶜ
 #align order.pfilter.is_prime Order.PFilter.IsPrime
 
 /-- Create an element of type `Order.Ideal.PrimePair` from a filter satisfying the predicate

Part 3 of #5001

@@ -19,7 +19,7 @@ import Mathlib.Order.PFilter
 Throughout this file, `P` is at least a preorder, but some sections require more
 structure, such as a bottom element, a top element, or a join-semilattice structure.
 
-- `Order.Ideal.PrimePair`: A pair of an `Order.Ideal` and a `Order.PFilter` which form a partition
+- `Order.Ideal.PrimePair`: A pair of an `Order.Ideal` and an `Order.PFilter` which form a partition
   of `P`.  This is useful as giving the data of a prime ideal is the same as giving the data of a
   prime filter.
 - `Order.Ideal.IsPrime`: a predicate for prime ideals. Dual to the notion of a prime filter.
@@ -44,7 +44,7 @@ variable {P : Type _}
 
 namespace Ideal
 
-/-- A pair of an `Order.Ideal` and a `Order.PFilter` which form a partition of `P`.
+/-- A pair of an `Order.Ideal` and an `Order.PFilter` which form a partition of `P`.
 -/
 -- porting note: no attr @[nolint has_nonempty_instance]
 structure PrimePair (P : Type _) [Preorder P] where

• Run a non-interactive version of fix-comments.py on all files.
• Go through the diff and manually add/discard/edit chunks.

@@ -19,9 +19,9 @@ import Mathlib.Order.PFilter
 Throughout this file, `P` is at least a preorder, but some sections require more
 structure, such as a bottom element, a top element, or a join-semilattice structure.
 
-- `Order.Ideal.PrimePair`: A pair of an `ideal` and a `pfilter` which form a partition of `P`.
-  This is useful as giving the data of a prime ideal is the same as giving the data of a prime
-  filter.
+- `Order.Ideal.PrimePair`: A pair of an `Order.Ideal` and a `Order.PFilter` which form a partition
+  of `P`.  This is useful as giving the data of a prime ideal is the same as giving the data of a
+  prime filter.
 - `Order.Ideal.IsPrime`: a predicate for prime ideals. Dual to the notion of a prime filter.
 - `Order.PFilter.IsPrime`: a predicate for prime filters. Dual to the notion of a prime ideal.
 
@@ -44,7 +44,7 @@ variable {P : Type _}
 
 namespace Ideal
 
-/-- A pair of an `ideal` and a `pfilter` which form a partition of `P`.
+/-- A pair of an `Order.Ideal` and a `Order.PFilter` which form a partition of `P`.
 -/
 -- porting note: no attr @[nolint has_nonempty_instance]
 structure PrimePair (P : Type _) [Preorder P] where

These are proofs not propositions so should be lowerCamelCase.

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -75,7 +75,7 @@ set_option linter.uppercaseLean3 false in
 #align order.ideal.prime_pair.I_is_proper Order.Ideal.PrimePair.I_isProper
 
 protected theorem disjoint : Disjoint (IF.I : Set P) IF.F :=
-  IF.isCompl_I_F.Disjoint
+  IF.isCompl_I_F.disjoint
 #align order.ideal.prime_pair.disjoint Order.Ideal.PrimePair.disjoint
 
 theorem I_union_F : (IF.I : Set P) ∪ IF.F = Set.univ :=
@@ -242,4 +242,3 @@ set_option linter.uppercaseLean3 false in
 end PFilter
 
 end Order
-