order.pfilter | Mathlib porting status

Changes since the initial port

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

Changes in mathlib3

740acc0e

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

23aa88e3

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2020 Mathieu Guay-Paquet. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mathieu Guay-Paquet
 -/
-import Mathbin.Order.Ideal
+import Order.Ideal
 
 #align_import order.pfilter from "leanprover-community/mathlib"@"23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6"

23aa88e3

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2020 Mathieu Guay-Paquet. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mathieu Guay-Paquet
-
-! This file was ported from Lean 3 source module order.pfilter
-! 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
 
+#align_import order.pfilter from "leanprover-community/mathlib"@"23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6"
+
 /-!
 # Order filters

23aa88e3

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -136,10 +136,12 @@ theorem ext (h : (s : Set P) = t) : s = t := by cases s; cases t; exact congr_ar
 instance : PartialOrder (PFilter P) :=
   PartialOrder.lift coe ext
 
+#print Order.PFilter.mem_of_mem_of_le /-
 @[trans]
 theorem mem_of_mem_of_le {F G : PFilter P} : x ∈ F → F ≤ G → x ∈ G :=
   Ideal.mem_of_mem_of_le
 #align order.pfilter.mem_of_mem_of_le Order.PFilter.mem_of_mem_of_le
+-/
 
 #print Order.PFilter.principal /-
 /-- The smallest filter containing a given element. -/
@@ -155,10 +157,12 @@ theorem mem_mk (x : P) (I : Ideal Pᵒᵈ) : x ∈ (⟨I⟩ : PFilter P) ↔ Ord
 #align order.pfilter.mem_def Order.PFilter.mem_mk
 -/
 
+#print Order.PFilter.principal_le_iff /-
 @[simp]
 theorem principal_le_iff {F : PFilter P} : principal x ≤ F ↔ x ∈ F :=
   Ideal.principal_le_iff
 #align order.pfilter.principal_le_iff Order.PFilter.principal_le_iff
+-/
 
 #print Order.PFilter.mem_principal /-
 @[simp]
@@ -167,12 +171,16 @@ theorem mem_principal : x ∈ principal y ↔ y ≤ x :=
 #align order.pfilter.mem_principal Order.PFilter.mem_principal
 -/
 
+#print Order.PFilter.antitone_principal /-
 -- defeq abuse
 theorem antitone_principal : Antitone (principal : P → PFilter P) := by delta Antitone <;> simp
 #align order.pfilter.antitone_principal Order.PFilter.antitone_principal
+-/
 
+#print Order.PFilter.principal_le_principal_iff /-
 theorem principal_le_principal_iff {p q : P} : principal q ≤ principal p ↔ p ≤ q := by simp
 #align order.pfilter.principal_le_principal_iff Order.PFilter.principal_le_principal_iff
+-/
 
 end Preorder
 
@@ -180,11 +188,13 @@ section OrderTop
 
 variable [Preorder P] [OrderTop P] {F : PFilter P}
 
+#print Order.PFilter.top_mem /-
 /-- A specific witness of `pfilter.nonempty` when `P` has a top element. -/
 @[simp]
 theorem top_mem : ⊤ ∈ F :=
   Ideal.bot_mem _
 #align order.pfilter.top_mem Order.PFilter.top_mem
+-/
 
 /-- There is a bottom filter when `P` has a top element. -/
 instance : OrderBot (PFilter P) where
@@ -203,15 +213,19 @@ section SemilatticeInf
 
 variable [SemilatticeInf P] {x y : P} {F : PFilter P}
 
+#print Order.PFilter.inf_mem /-
 /-- A specific witness of `pfilter.directed` when `P` has meets. -/
 theorem inf_mem (hx : x ∈ F) (hy : y ∈ F) : x ⊓ y ∈ F :=
   Ideal.sup_mem hx hy
 #align order.pfilter.inf_mem Order.PFilter.inf_mem
+-/
 
+#print Order.PFilter.inf_mem_iff /-
 @[simp]
 theorem inf_mem_iff : x ⊓ y ∈ F ↔ x ∈ F ∧ y ∈ F :=
   Ideal.sup_mem_iff
 #align order.pfilter.inf_mem_iff Order.PFilter.inf_mem_iff
+-/
 
 end SemilatticeInf
 
@@ -219,12 +233,15 @@ section CompleteSemilatticeInf
 
 variable [CompleteSemilatticeInf P] {F : PFilter P}
 
+#print Order.PFilter.sInf_gc /-
 theorem sInf_gc :
     GaloisConnection (fun x => OrderDual.toDual (principal x)) fun F =>
       sInf (OrderDual.ofDual F : PFilter P) :=
   fun x F => by simp; rfl
 #align order.pfilter.Inf_gc Order.PFilter.sInf_gc
+-/
 
+#print Order.PFilter.infGi /-
 /-- If a poset `P` admits arbitrary `Inf`s, then `principal` and `Inf` form a Galois coinsertion. -/
 def infGi :
     GaloisCoinsertion (fun x => OrderDual.toDual (principal x)) fun F =>
@@ -235,6 +252,7 @@ def infGi :
   u_l_le s := sInf_le <| mem_principal.2 <| le_refl s
   choice_eq _ _ := rfl
 #align order.pfilter.Inf_gi Order.PFilter.infGi
+-/
 
 end CompleteSemilatticeInf

23aa88e3

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -64,11 +64,13 @@ def IsPFilter [Preorder P] (F : Set P) : Prop :=
 #align order.is_pfilter Order.IsPFilter
 -/
 
+#print Order.IsPFilter.of_def /-
 theorem IsPFilter.of_def [Preorder P] {F : Set P} (nonempty : F.Nonempty)
     (directed : DirectedOn (· ≥ ·) F) (mem_of_le : ∀ {x y : P}, x ≤ y → x ∈ F → y ∈ F) :
     IsPFilter F :=
   ⟨fun _ _ _ _ => mem_of_le ‹_› ‹_›, Nonempty, Directed⟩
 #align order.is_pfilter.of_def Order.IsPFilter.of_def
+-/
 
 #print Order.IsPFilter.toPFilter /-
 /-- Create an element of type `order.pfilter` from a set satisfying the predicate
@@ -100,25 +102,35 @@ theorem SetLike.mem_coe : x ∈ (F : Set P) ↔ x ∈ F :=
   iff_of_eq rfl
 #align order.pfilter.mem_coe SetLike.mem_coeₓ
 
+#print Order.PFilter.isPFilter /-
 theorem isPFilter : IsPFilter (F : Set P) :=
   F.dual.IsIdeal
 #align order.pfilter.is_pfilter Order.PFilter.isPFilter
+-/
 
+#print Order.PFilter.nonempty /-
 theorem nonempty : (F : Set P).Nonempty :=
   F.dual.Nonempty
 #align order.pfilter.nonempty Order.PFilter.nonempty
+-/
 
+#print Order.PFilter.directed /-
 theorem directed : DirectedOn (· ≥ ·) (F : Set P) :=
   F.dual.Directed
 #align order.pfilter.directed Order.PFilter.directed
+-/
 
+#print Order.PFilter.mem_of_le /-
 theorem mem_of_le {F : PFilter P} : x ≤ y → x ∈ F → y ∈ F := fun h => F.dual.lower h
 #align order.pfilter.mem_of_le Order.PFilter.mem_of_le
+-/
 
+#print Order.PFilter.ext /-
 /-- Two filters are equal when their underlying sets are equal. -/
 @[ext]
 theorem ext (h : (s : Set P) = t) : s = t := by cases s; cases t; exact congr_arg _ (Ideal.ext h)
 #align order.pfilter.ext Order.PFilter.ext
+-/
 
 /-- The partial ordering by subset inclusion, inherited from `set P`. -/
 instance : PartialOrder (PFilter P) :=
@@ -136,20 +148,24 @@ def principal (p : P) : PFilter P :=
 #align order.pfilter.principal Order.PFilter.principal
 -/
 
+#print Order.PFilter.mem_mk /-
 @[simp]
 theorem mem_mk (x : P) (I : Ideal Pᵒᵈ) : x ∈ (⟨I⟩ : PFilter P) ↔ OrderDual.toDual x ∈ I :=
   Iff.rfl
 #align order.pfilter.mem_def Order.PFilter.mem_mk
+-/
 
 @[simp]
 theorem principal_le_iff {F : PFilter P} : principal x ≤ F ↔ x ∈ F :=
   Ideal.principal_le_iff
 #align order.pfilter.principal_le_iff Order.PFilter.principal_le_iff
 
+#print Order.PFilter.mem_principal /-
 @[simp]
 theorem mem_principal : x ∈ principal y ↔ y ≤ x :=
   Ideal.mem_principal
 #align order.pfilter.mem_principal Order.PFilter.mem_principal
+-/
 
 -- defeq abuse
 theorem antitone_principal : Antitone (principal : P → PFilter P) := by delta Antitone <;> simp

23aa88e3

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -64,12 +64,6 @@ def IsPFilter [Preorder P] (F : Set P) : Prop :=
 #align order.is_pfilter Order.IsPFilter
 -/
 
-/- warning: order.is_pfilter.of_def -> Order.IsPFilter.of_def is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {F : Set.{u1} P}, (Set.Nonempty.{u1} P F) -> (DirectedOn.{u1} P (GE.ge.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) F) -> (forall {x : P} {y : P}, (LE.le.{u1} P (Preorder.toHasLe.{u1} P _inst_1) x y) -> (Membership.Mem.{u1, u1} P (Set.{u1} P) (Set.hasMem.{u1} P) x F) -> (Membership.Mem.{u1, u1} P (Set.{u1} P) (Set.hasMem.{u1} P) y F)) -> (Order.IsPFilter.{u1} P _inst_1 F)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {F : Set.{u1} P}, (Set.Nonempty.{u1} P F) -> (DirectedOn.{u1} P (fun (x._@.Mathlib.Order.PFilter._hyg.66 : P) (x._@.Mathlib.Order.PFilter._hyg.68 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P _inst_1) x._@.Mathlib.Order.PFilter._hyg.66 x._@.Mathlib.Order.PFilter._hyg.68) F) -> (forall {x : P} {y : P}, (LE.le.{u1} P (Preorder.toLE.{u1} P _inst_1) x y) -> (Membership.mem.{u1, u1} P (Set.{u1} P) (Set.instMembershipSet.{u1} P) x F) -> (Membership.mem.{u1, u1} P (Set.{u1} P) (Set.instMembershipSet.{u1} P) y F)) -> (Order.IsPFilter.{u1} P _inst_1 F)
-Case conversion may be inaccurate. Consider using '#align order.is_pfilter.of_def Order.IsPFilter.of_defₓ'. -/
 theorem IsPFilter.of_def [Preorder P] {F : Set P} (nonempty : F.Nonempty)
     (directed : DirectedOn (· ≥ ·) F) (mem_of_le : ∀ {x y : P}, x ≤ y → x ∈ F → y ∈ F) :
     IsPFilter F :=
@@ -106,51 +100,21 @@ theorem SetLike.mem_coe : x ∈ (F : Set P) ↔ x ∈ F :=
   iff_of_eq rfl
 #align order.pfilter.mem_coe SetLike.mem_coeₓ
 
-/- warning: order.pfilter.is_pfilter -> Order.PFilter.isPFilter is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (F : Order.PFilter.{u1} P _inst_1), Order.IsPFilter.{u1} P _inst_1 ((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)))) F)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (F : Order.PFilter.{u1} P _inst_1), Order.IsPFilter.{u1} P _inst_1 (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) F)
-Case conversion may be inaccurate. Consider using '#align order.pfilter.is_pfilter Order.PFilter.isPFilterₓ'. -/
 theorem isPFilter : IsPFilter (F : Set P) :=
   F.dual.IsIdeal
 #align order.pfilter.is_pfilter Order.PFilter.isPFilter
 
-/- warning: order.pfilter.nonempty -> Order.PFilter.nonempty is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (F : Order.PFilter.{u1} P _inst_1), Set.Nonempty.{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)))) F)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (F : Order.PFilter.{u1} P _inst_1), Set.Nonempty.{u1} P (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) F)
-Case conversion may be inaccurate. Consider using '#align order.pfilter.nonempty Order.PFilter.nonemptyₓ'. -/
 theorem nonempty : (F : Set P).Nonempty :=
   F.dual.Nonempty
 #align order.pfilter.nonempty Order.PFilter.nonempty
 
-/- warning: order.pfilter.directed -> Order.PFilter.directed is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (F : Order.PFilter.{u1} P _inst_1), DirectedOn.{u1} P (GE.ge.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) ((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)))) F)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (F : Order.PFilter.{u1} P _inst_1), DirectedOn.{u1} P (fun (x._@.Mathlib.Order.PFilter._hyg.344 : P) (x._@.Mathlib.Order.PFilter._hyg.346 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P _inst_1) x._@.Mathlib.Order.PFilter._hyg.344 x._@.Mathlib.Order.PFilter._hyg.346) (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) F)
-Case conversion may be inaccurate. Consider using '#align order.pfilter.directed Order.PFilter.directedₓ'. -/
 theorem directed : DirectedOn (· ≥ ·) (F : Set P) :=
   F.dual.Directed
 #align order.pfilter.directed Order.PFilter.directed
 
-/- warning: order.pfilter.mem_of_le -> Order.PFilter.mem_of_le is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {y : P} {F : Order.PFilter.{u1} P _inst_1}, (LE.le.{u1} P (Preorder.toHasLe.{u1} P _inst_1) x y) -> (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) x F) -> (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) y F)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {y : P} {F : Order.PFilter.{u1} P _inst_1}, (LE.le.{u1} P (Preorder.toLE.{u1} P _inst_1) x y) -> (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)) x F) -> (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)) y F)
-Case conversion may be inaccurate. Consider using '#align order.pfilter.mem_of_le Order.PFilter.mem_of_leₓ'. -/
 theorem mem_of_le {F : PFilter P} : x ≤ y → x ∈ F → y ∈ F := fun h => F.dual.lower h
 #align order.pfilter.mem_of_le Order.PFilter.mem_of_le
 
-/- warning: order.pfilter.ext -> Order.PFilter.ext is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (s : Order.PFilter.{u1} P _inst_1) (t : Order.PFilter.{u1} P _inst_1), (Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.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)))) s) ((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)))) t)) -> (Eq.{succ u1} (Order.PFilter.{u1} P _inst_1) s t)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (s : Order.PFilter.{u1} P _inst_1) (t : Order.PFilter.{u1} P _inst_1), (Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) s) (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) t)) -> (Eq.{succ u1} (Order.PFilter.{u1} P _inst_1) s t)
-Case conversion may be inaccurate. Consider using '#align order.pfilter.ext Order.PFilter.extₓ'. -/
 /-- Two filters are equal when their underlying sets are equal. -/
 @[ext]
 theorem ext (h : (s : Set P) = t) : s = t := by cases s; cases t; exact congr_arg _ (Ideal.ext h)
@@ -160,12 +124,6 @@ theorem ext (h : (s : Set P) = t) : s = t := by cases s; cases t; exact congr_ar
 instance : PartialOrder (PFilter P) :=
   PartialOrder.lift coe ext
 
-/- warning: order.pfilter.mem_of_mem_of_le -> Order.PFilter.mem_of_mem_of_le is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {F : Order.PFilter.{u1} P _inst_1} {G : Order.PFilter.{u1} P _inst_1}, (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) x F) -> (LE.le.{u1} (Order.PFilter.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.PFilter.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P _inst_1) (Order.PFilter.partialOrder.{u1} P _inst_1))) F G) -> (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) x G)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {F : Order.PFilter.{u1} P _inst_1} {G : Order.PFilter.{u1} P _inst_1}, (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)) x F) -> (LE.le.{u1} (Order.PFilter.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.PFilter.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P _inst_1) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)))) F G) -> (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)) x G)
-Case conversion may be inaccurate. Consider using '#align order.pfilter.mem_of_mem_of_le Order.PFilter.mem_of_mem_of_leₓ'. -/
 @[trans]
 theorem mem_of_mem_of_le {F G : PFilter P} : x ∈ F → F ≤ G → x ∈ G :=
   Ideal.mem_of_mem_of_le
@@ -178,55 +136,25 @@ def principal (p : P) : PFilter P :=
 #align order.pfilter.principal Order.PFilter.principal
 -/
 
-/- warning: order.pfilter.mem_def -> Order.PFilter.mem_mk is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (x : P) (I : Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.hasLe.{u1} P (Preorder.toHasLe.{u1} P _inst_1))), Iff (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) x (Order.PFilter.mk.{u1} P _inst_1 I)) (Membership.Mem.{u1, u1} (OrderDual.{u1} P) (Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.hasLe.{u1} P (Preorder.toHasLe.{u1} P _inst_1))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.hasLe.{u1} P (Preorder.toHasLe.{u1} P _inst_1))) (OrderDual.{u1} P) (Order.Ideal.setLike.{u1} (OrderDual.{u1} P) (OrderDual.hasLe.{u1} P (Preorder.toHasLe.{u1} P _inst_1)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} P (OrderDual.{u1} P)) (fun (_x : Equiv.{succ u1, succ u1} P (OrderDual.{u1} P)) => P -> (OrderDual.{u1} P)) (Equiv.hasCoeToFun.{succ u1, succ u1} P (OrderDual.{u1} P)) (OrderDual.toDual.{u1} P) x) I)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (x : P) (I : Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.instLEOrderDual.{u1} P (Preorder.toLE.{u1} P _inst_1))), Iff (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)) x (Order.PFilter.mk.{u1} P _inst_1 I)) (Membership.mem.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => OrderDual.{u1} P) x) (Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.instLEOrderDual.{u1} P (Preorder.toLE.{u1} P _inst_1))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.instLEOrderDual.{u1} P (Preorder.toLE.{u1} P _inst_1))) (OrderDual.{u1} P) (Order.Ideal.instSetLikeIdeal.{u1} (OrderDual.{u1} P) (OrderDual.instLEOrderDual.{u1} P (Preorder.toLE.{u1} P _inst_1)))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} P (OrderDual.{u1} P)) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => OrderDual.{u1} P) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} P (OrderDual.{u1} P)) (OrderDual.toDual.{u1} P) x) I)
-Case conversion may be inaccurate. Consider using '#align order.pfilter.mem_def Order.PFilter.mem_mkₓ'. -/
 @[simp]
 theorem mem_mk (x : P) (I : Ideal Pᵒᵈ) : x ∈ (⟨I⟩ : PFilter P) ↔ OrderDual.toDual x ∈ I :=
   Iff.rfl
 #align order.pfilter.mem_def Order.PFilter.mem_mk
 
-/- warning: order.pfilter.principal_le_iff -> Order.PFilter.principal_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {F : Order.PFilter.{u1} P _inst_1}, Iff (LE.le.{u1} (Order.PFilter.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.PFilter.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P _inst_1) (Order.PFilter.partialOrder.{u1} P _inst_1))) (Order.PFilter.principal.{u1} P _inst_1 x) F) (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) x F)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {F : Order.PFilter.{u1} P _inst_1}, Iff (LE.le.{u1} (Order.PFilter.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.PFilter.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P _inst_1) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P _inst_1 x) F) (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)) x F)
-Case conversion may be inaccurate. Consider using '#align order.pfilter.principal_le_iff Order.PFilter.principal_le_iffₓ'. -/
 @[simp]
 theorem principal_le_iff {F : PFilter P} : principal x ≤ F ↔ x ∈ F :=
   Ideal.principal_le_iff
 #align order.pfilter.principal_le_iff Order.PFilter.principal_le_iff
 
-/- warning: order.pfilter.mem_principal -> Order.PFilter.mem_principal is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {y : P}, Iff (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) x (Order.PFilter.principal.{u1} P _inst_1 y)) (LE.le.{u1} P (Preorder.toHasLe.{u1} P _inst_1) y x)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {y : P}, Iff (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)) x (Order.PFilter.principal.{u1} P _inst_1 y)) (LE.le.{u1} P (Preorder.toLE.{u1} P _inst_1) y x)
-Case conversion may be inaccurate. Consider using '#align order.pfilter.mem_principal Order.PFilter.mem_principalₓ'. -/
 @[simp]
 theorem mem_principal : x ∈ principal y ↔ y ≤ x :=
   Ideal.mem_principal
 #align order.pfilter.mem_principal Order.PFilter.mem_principal
 
-/- warning: order.pfilter.antitone_principal -> Order.PFilter.antitone_principal is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P], Antitone.{u1, u1} P (Order.PFilter.{u1} P _inst_1) _inst_1 (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P _inst_1) (Order.PFilter.partialOrder.{u1} P _inst_1)) (Order.PFilter.principal.{u1} P _inst_1)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P], Antitone.{u1, u1} P (Order.PFilter.{u1} P _inst_1) _inst_1 (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P _inst_1) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1))) (Order.PFilter.principal.{u1} P _inst_1)
-Case conversion may be inaccurate. Consider using '#align order.pfilter.antitone_principal Order.PFilter.antitone_principalₓ'. -/
 -- defeq abuse
 theorem antitone_principal : Antitone (principal : P → PFilter P) := by delta Antitone <;> simp
 #align order.pfilter.antitone_principal Order.PFilter.antitone_principal
 
-/- warning: order.pfilter.principal_le_principal_iff -> Order.PFilter.principal_le_principal_iff is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {p : P} {q : P}, Iff (LE.le.{u1} (Order.PFilter.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.PFilter.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P _inst_1) (Order.PFilter.partialOrder.{u1} P _inst_1))) (Order.PFilter.principal.{u1} P _inst_1 q) (Order.PFilter.principal.{u1} P _inst_1 p)) (LE.le.{u1} P (Preorder.toHasLe.{u1} P _inst_1) p q)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {p : P} {q : P}, Iff (LE.le.{u1} (Order.PFilter.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.PFilter.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P _inst_1) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P _inst_1 q) (Order.PFilter.principal.{u1} P _inst_1 p)) (LE.le.{u1} P (Preorder.toLE.{u1} P _inst_1) p q)
-Case conversion may be inaccurate. Consider using '#align order.pfilter.principal_le_principal_iff Order.PFilter.principal_le_principal_iffₓ'. -/
 theorem principal_le_principal_iff {p q : P} : principal q ≤ principal p ↔ p ≤ q := by simp
 #align order.pfilter.principal_le_principal_iff Order.PFilter.principal_le_principal_iff
 
@@ -236,12 +164,6 @@ section OrderTop
 
 variable [Preorder P] [OrderTop P] {F : PFilter P}
 
-/- warning: order.pfilter.top_mem -> Order.PFilter.top_mem is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] [_inst_2 : OrderTop.{u1} P (Preorder.toHasLe.{u1} P _inst_1)] {F : Order.PFilter.{u1} P _inst_1}, Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) (Top.top.{u1} P (OrderTop.toHasTop.{u1} P (Preorder.toHasLe.{u1} P _inst_1) _inst_2)) F
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] [_inst_2 : OrderTop.{u1} P (Preorder.toLE.{u1} P _inst_1)] {F : Order.PFilter.{u1} P _inst_1}, Membership.mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)) (Top.top.{u1} P (OrderTop.toTop.{u1} P (Preorder.toLE.{u1} P _inst_1) _inst_2)) F
-Case conversion may be inaccurate. Consider using '#align order.pfilter.top_mem Order.PFilter.top_memₓ'. -/
 /-- A specific witness of `pfilter.nonempty` when `P` has a top element. -/
 @[simp]
 theorem top_mem : ⊤ ∈ F :=
@@ -265,23 +187,11 @@ section SemilatticeInf
 
 variable [SemilatticeInf P] {x y : P} {F : PFilter P}
 
-/- warning: order.pfilter.inf_mem -> Order.PFilter.inf_mem is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {x : P} {y : P} {F : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))}, (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.hasMem.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) x F) -> (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.hasMem.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) y F) -> (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.hasMem.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Inf.inf.{u1} P (SemilatticeInf.toHasInf.{u1} P _inst_1) x y) F)
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {x : P} {y : P} {F : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))}, (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) x F) -> (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) y F) -> (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Inf.inf.{u1} P (SemilatticeInf.toInf.{u1} P _inst_1) x y) F)
-Case conversion may be inaccurate. Consider using '#align order.pfilter.inf_mem Order.PFilter.inf_memₓ'. -/
 /-- A specific witness of `pfilter.directed` when `P` has meets. -/
 theorem inf_mem (hx : x ∈ F) (hy : y ∈ F) : x ⊓ y ∈ F :=
   Ideal.sup_mem hx hy
 #align order.pfilter.inf_mem Order.PFilter.inf_mem
 
-/- warning: order.pfilter.inf_mem_iff -> Order.PFilter.inf_mem_iff is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {x : P} {y : P} {F : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))}, Iff (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.hasMem.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Inf.inf.{u1} P (SemilatticeInf.toHasInf.{u1} P _inst_1) x y) F) (And (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.hasMem.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) x F) (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.hasMem.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) y F))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {x : P} {y : P} {F : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))}, Iff (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Inf.inf.{u1} P (SemilatticeInf.toInf.{u1} P _inst_1) x y) F) (And (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) x F) (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) y F))
-Case conversion may be inaccurate. Consider using '#align order.pfilter.inf_mem_iff Order.PFilter.inf_mem_iffₓ'. -/
 @[simp]
 theorem inf_mem_iff : x ⊓ y ∈ F ↔ x ∈ F ∧ y ∈ F :=
   Ideal.sup_mem_iff
@@ -293,24 +203,12 @@ section CompleteSemilatticeInf
 
 variable [CompleteSemilatticeInf P] {F : PFilter P}
 
-/- warning: order.pfilter.Inf_gc -> Order.PFilter.sInf_gc is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisConnection.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.partialOrder.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (x : P) => coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (_x : Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) => (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) -> (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.sInf.{u1} P (CompleteSemilatticeInf.toHasInf.{u1} P _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) -> (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisConnection.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (fun (x : P) => FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (fun (_x : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.sInf.{u1} P (CompleteSemilatticeInf.toInfSet.{u1} P _inst_1) (SetLike.coe.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) F) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
-Case conversion may be inaccurate. Consider using '#align order.pfilter.Inf_gc Order.PFilter.sInf_gcₓ'. -/
 theorem sInf_gc :
     GaloisConnection (fun x => OrderDual.toDual (principal x)) fun F =>
       sInf (OrderDual.ofDual F : PFilter P) :=
   fun x F => by simp; rfl
 #align order.pfilter.Inf_gc Order.PFilter.sInf_gc
 
-/- warning: order.pfilter.Inf_gi -> Order.PFilter.infGi is a dubious translation:
-lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisCoinsertion.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.partialOrder.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (x : P) => coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (_x : Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) => (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) -> (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.sInf.{u1} P (CompleteSemilatticeInf.toHasInf.{u1} P _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) -> (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
-but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisCoinsertion.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (fun (x : P) => FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (fun (_x : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.sInf.{u1} P (CompleteSemilatticeInf.toInfSet.{u1} P _inst_1) (SetLike.coe.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) F) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
-Case conversion may be inaccurate. Consider using '#align order.pfilter.Inf_gi Order.PFilter.infGiₓ'. -/
 /-- If a poset `P` admits arbitrary `Inf`s, then `principal` and `Inf` form a Galois coinsertion. -/
 def infGi :
     GaloisCoinsertion (fun x => OrderDual.toDual (principal x)) fun F =>

23aa88e3

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -153,10 +153,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align order.pfilter.ext Order.PFilter.extₓ'. -/
 /-- Two filters are equal when their underlying sets are equal. -/
 @[ext]
-theorem ext (h : (s : Set P) = t) : s = t := by
-  cases s
-  cases t
-  exact congr_arg _ (Ideal.ext h)
+theorem ext (h : (s : Set P) = t) : s = t := by cases s; cases t; exact congr_arg _ (Ideal.ext h)
 #align order.pfilter.ext Order.PFilter.ext
 
 /-- The partial ordering by subset inclusion, inherited from `set P`. -/
@@ -305,9 +302,7 @@ Case conversion may be inaccurate. Consider using '#align order.pfilter.Inf_gc O
 theorem sInf_gc :
     GaloisConnection (fun x => OrderDual.toDual (principal x)) fun F =>
       sInf (OrderDual.ofDual F : PFilter P) :=
-  fun x F => by
-  simp
-  rfl
+  fun x F => by simp; rfl
 #align order.pfilter.Inf_gc Order.PFilter.sInf_gc
 
 /- warning: order.pfilter.Inf_gi -> Order.PFilter.infGi is a dubious translation:

23aa88e3

bump to nightly-2023-05-19-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/95a87616d63b3cb49d3fe678d416fbe9c4217bf4

a31df521

Diff

@@ -185,7 +185,7 @@ def principal (p : P) : PFilter P :=
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (x : P) (I : Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.hasLe.{u1} P (Preorder.toHasLe.{u1} P _inst_1))), Iff (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) x (Order.PFilter.mk.{u1} P _inst_1 I)) (Membership.Mem.{u1, u1} (OrderDual.{u1} P) (Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.hasLe.{u1} P (Preorder.toHasLe.{u1} P _inst_1))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.hasLe.{u1} P (Preorder.toHasLe.{u1} P _inst_1))) (OrderDual.{u1} P) (Order.Ideal.setLike.{u1} (OrderDual.{u1} P) (OrderDual.hasLe.{u1} P (Preorder.toHasLe.{u1} P _inst_1)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} P (OrderDual.{u1} P)) (fun (_x : Equiv.{succ u1, succ u1} P (OrderDual.{u1} P)) => P -> (OrderDual.{u1} P)) (Equiv.hasCoeToFun.{succ u1, succ u1} P (OrderDual.{u1} P)) (OrderDual.toDual.{u1} P) x) I)
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (x : P) (I : Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.instLEOrderDual.{u1} P (Preorder.toLE.{u1} P _inst_1))), Iff (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)) x (Order.PFilter.mk.{u1} P _inst_1 I)) (Membership.mem.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => OrderDual.{u1} P) x) (Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.instLEOrderDual.{u1} P (Preorder.toLE.{u1} P _inst_1))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.instLEOrderDual.{u1} P (Preorder.toLE.{u1} P _inst_1))) (OrderDual.{u1} P) (Order.Ideal.instSetLikeIdeal.{u1} (OrderDual.{u1} P) (OrderDual.instLEOrderDual.{u1} P (Preorder.toLE.{u1} P _inst_1)))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} P (OrderDual.{u1} P)) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => OrderDual.{u1} P) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} P (OrderDual.{u1} P)) (OrderDual.toDual.{u1} P) x) I)
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (x : P) (I : Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.instLEOrderDual.{u1} P (Preorder.toLE.{u1} P _inst_1))), Iff (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)) x (Order.PFilter.mk.{u1} P _inst_1 I)) (Membership.mem.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => OrderDual.{u1} P) x) (Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.instLEOrderDual.{u1} P (Preorder.toLE.{u1} P _inst_1))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.instLEOrderDual.{u1} P (Preorder.toLE.{u1} P _inst_1))) (OrderDual.{u1} P) (Order.Ideal.instSetLikeIdeal.{u1} (OrderDual.{u1} P) (OrderDual.instLEOrderDual.{u1} P (Preorder.toLE.{u1} P _inst_1)))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} P (OrderDual.{u1} P)) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => OrderDual.{u1} P) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} P (OrderDual.{u1} P)) (OrderDual.toDual.{u1} P) x) I)
 Case conversion may be inaccurate. Consider using '#align order.pfilter.mem_def Order.PFilter.mem_mkₓ'. -/
 @[simp]
 theorem mem_mk (x : P) (I : Ideal Pᵒᵈ) : x ∈ (⟨I⟩ : PFilter P) ↔ OrderDual.toDual x ∈ I :=
@@ -300,7 +300,7 @@ variable [CompleteSemilatticeInf P] {F : PFilter P}
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisConnection.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.partialOrder.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (x : P) => coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (_x : Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) => (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) -> (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.sInf.{u1} P (CompleteSemilatticeInf.toHasInf.{u1} P _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) -> (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisConnection.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (fun (x : P) => FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (fun (_x : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.sInf.{u1} P (CompleteSemilatticeInf.toInfSet.{u1} P _inst_1) (SetLike.coe.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) F) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
+  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisConnection.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (fun (x : P) => FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (fun (_x : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.sInf.{u1} P (CompleteSemilatticeInf.toInfSet.{u1} P _inst_1) (SetLike.coe.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) F) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
 Case conversion may be inaccurate. Consider using '#align order.pfilter.Inf_gc Order.PFilter.sInf_gcₓ'. -/
 theorem sInf_gc :
     GaloisConnection (fun x => OrderDual.toDual (principal x)) fun F =>
@@ -314,7 +314,7 @@ theorem sInf_gc :
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisCoinsertion.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.partialOrder.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (x : P) => coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (_x : Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) => (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) -> (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.sInf.{u1} P (CompleteSemilatticeInf.toHasInf.{u1} P _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) -> (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisCoinsertion.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (fun (x : P) => FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (fun (_x : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.sInf.{u1} P (CompleteSemilatticeInf.toInfSet.{u1} P _inst_1) (SetLike.coe.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) F) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
+  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisCoinsertion.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (fun (x : P) => FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (fun (_x : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.sInf.{u1} P (CompleteSemilatticeInf.toInfSet.{u1} P _inst_1) (SetLike.coe.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) F) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
 Case conversion may be inaccurate. Consider using '#align order.pfilter.Inf_gi Order.PFilter.infGiₓ'. -/
 /-- If a poset `P` admits arbitrary `Inf`s, then `principal` and `Inf` form a Galois coinsertion. -/
 def infGi :

23aa88e3

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -64,13 +64,17 @@ def IsPFilter [Preorder P] (F : Set P) : Prop :=
 #align order.is_pfilter Order.IsPFilter
 -/
 
-#print Order.IsPFilter.of_def /-
+/- warning: order.is_pfilter.of_def -> Order.IsPFilter.of_def is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {F : Set.{u1} P}, (Set.Nonempty.{u1} P F) -> (DirectedOn.{u1} P (GE.ge.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) F) -> (forall {x : P} {y : P}, (LE.le.{u1} P (Preorder.toHasLe.{u1} P _inst_1) x y) -> (Membership.Mem.{u1, u1} P (Set.{u1} P) (Set.hasMem.{u1} P) x F) -> (Membership.Mem.{u1, u1} P (Set.{u1} P) (Set.hasMem.{u1} P) y F)) -> (Order.IsPFilter.{u1} P _inst_1 F)
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {F : Set.{u1} P}, (Set.Nonempty.{u1} P F) -> (DirectedOn.{u1} P (fun (x._@.Mathlib.Order.PFilter._hyg.66 : P) (x._@.Mathlib.Order.PFilter._hyg.68 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P _inst_1) x._@.Mathlib.Order.PFilter._hyg.66 x._@.Mathlib.Order.PFilter._hyg.68) F) -> (forall {x : P} {y : P}, (LE.le.{u1} P (Preorder.toLE.{u1} P _inst_1) x y) -> (Membership.mem.{u1, u1} P (Set.{u1} P) (Set.instMembershipSet.{u1} P) x F) -> (Membership.mem.{u1, u1} P (Set.{u1} P) (Set.instMembershipSet.{u1} P) y F)) -> (Order.IsPFilter.{u1} P _inst_1 F)
+Case conversion may be inaccurate. Consider using '#align order.is_pfilter.of_def Order.IsPFilter.of_defₓ'. -/
 theorem IsPFilter.of_def [Preorder P] {F : Set P} (nonempty : F.Nonempty)
     (directed : DirectedOn (· ≥ ·) F) (mem_of_le : ∀ {x y : P}, x ≤ y → x ∈ F → y ∈ F) :
     IsPFilter F :=
   ⟨fun _ _ _ _ => mem_of_le ‹_› ‹_›, Nonempty, Directed⟩
 #align order.is_pfilter.of_def Order.IsPFilter.of_def
--/
 
 #print Order.IsPFilter.toPFilter /-
 /-- Create an element of type `order.pfilter` from a set satisfying the predicate
@@ -102,30 +106,51 @@ theorem SetLike.mem_coe : x ∈ (F : Set P) ↔ x ∈ F :=
   iff_of_eq rfl
 #align order.pfilter.mem_coe SetLike.mem_coeₓ
 
-#print Order.PFilter.isPFilter /-
+/- warning: order.pfilter.is_pfilter -> Order.PFilter.isPFilter is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (F : Order.PFilter.{u1} P _inst_1), Order.IsPFilter.{u1} P _inst_1 ((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)))) F)
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (F : Order.PFilter.{u1} P _inst_1), Order.IsPFilter.{u1} P _inst_1 (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) F)
+Case conversion may be inaccurate. Consider using '#align order.pfilter.is_pfilter Order.PFilter.isPFilterₓ'. -/
 theorem isPFilter : IsPFilter (F : Set P) :=
   F.dual.IsIdeal
 #align order.pfilter.is_pfilter Order.PFilter.isPFilter
--/
 
-#print Order.PFilter.nonempty /-
+/- warning: order.pfilter.nonempty -> Order.PFilter.nonempty is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (F : Order.PFilter.{u1} P _inst_1), Set.Nonempty.{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)))) F)
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (F : Order.PFilter.{u1} P _inst_1), Set.Nonempty.{u1} P (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) F)
+Case conversion may be inaccurate. Consider using '#align order.pfilter.nonempty Order.PFilter.nonemptyₓ'. -/
 theorem nonempty : (F : Set P).Nonempty :=
   F.dual.Nonempty
 #align order.pfilter.nonempty Order.PFilter.nonempty
--/
 
-#print Order.PFilter.directed /-
+/- warning: order.pfilter.directed -> Order.PFilter.directed is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (F : Order.PFilter.{u1} P _inst_1), DirectedOn.{u1} P (GE.ge.{u1} P (Preorder.toHasLe.{u1} P _inst_1)) ((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)))) F)
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (F : Order.PFilter.{u1} P _inst_1), DirectedOn.{u1} P (fun (x._@.Mathlib.Order.PFilter._hyg.344 : P) (x._@.Mathlib.Order.PFilter._hyg.346 : P) => GE.ge.{u1} P (Preorder.toLE.{u1} P _inst_1) x._@.Mathlib.Order.PFilter._hyg.344 x._@.Mathlib.Order.PFilter._hyg.346) (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) F)
+Case conversion may be inaccurate. Consider using '#align order.pfilter.directed Order.PFilter.directedₓ'. -/
 theorem directed : DirectedOn (· ≥ ·) (F : Set P) :=
   F.dual.Directed
 #align order.pfilter.directed Order.PFilter.directed
--/
 
-#print Order.PFilter.mem_of_le /-
+/- warning: order.pfilter.mem_of_le -> Order.PFilter.mem_of_le is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {y : P} {F : Order.PFilter.{u1} P _inst_1}, (LE.le.{u1} P (Preorder.toHasLe.{u1} P _inst_1) x y) -> (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) x F) -> (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) y F)
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {y : P} {F : Order.PFilter.{u1} P _inst_1}, (LE.le.{u1} P (Preorder.toLE.{u1} P _inst_1) x y) -> (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)) x F) -> (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)) y F)
+Case conversion may be inaccurate. Consider using '#align order.pfilter.mem_of_le Order.PFilter.mem_of_leₓ'. -/
 theorem mem_of_le {F : PFilter P} : x ≤ y → x ∈ F → y ∈ F := fun h => F.dual.lower h
 #align order.pfilter.mem_of_le Order.PFilter.mem_of_le
--/
 
-#print Order.PFilter.ext /-
+/- warning: order.pfilter.ext -> Order.PFilter.ext is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (s : Order.PFilter.{u1} P _inst_1) (t : Order.PFilter.{u1} P _inst_1), (Eq.{succ u1} (Set.{u1} P) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.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)))) s) ((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)))) t)) -> (Eq.{succ u1} (Order.PFilter.{u1} P _inst_1) s t)
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (s : Order.PFilter.{u1} P _inst_1) (t : Order.PFilter.{u1} P _inst_1), (Eq.{succ u1} (Set.{u1} P) (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) s) (SetLike.coe.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1) t)) -> (Eq.{succ u1} (Order.PFilter.{u1} P _inst_1) s t)
+Case conversion may be inaccurate. Consider using '#align order.pfilter.ext Order.PFilter.extₓ'. -/
 /-- Two filters are equal when their underlying sets are equal. -/
 @[ext]
 theorem ext (h : (s : Set P) = t) : s = t := by
@@ -133,7 +158,6 @@ theorem ext (h : (s : Set P) = t) : s = t := by
   cases t
   exact congr_arg _ (Ideal.ext h)
 #align order.pfilter.ext Order.PFilter.ext
--/
 
 /-- The partial ordering by subset inclusion, inherited from `set P`. -/
 instance : PartialOrder (PFilter P) :=
@@ -141,7 +165,7 @@ instance : PartialOrder (PFilter P) :=
 
 /- warning: order.pfilter.mem_of_mem_of_le -> Order.PFilter.mem_of_mem_of_le is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {F : Order.PFilter.{u1} P _inst_1} {G : Order.PFilter.{u1} P _inst_1}, (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) x F) -> (LE.le.{u1} (Order.PFilter.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.PFilter.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P _inst_1) (Order.PFilter.partialOrder.{u1} P _inst_1))) F G) -> (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) x G)
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {F : Order.PFilter.{u1} P _inst_1} {G : Order.PFilter.{u1} P _inst_1}, (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) x F) -> (LE.le.{u1} (Order.PFilter.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.PFilter.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P _inst_1) (Order.PFilter.partialOrder.{u1} P _inst_1))) F G) -> (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) x G)
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {F : Order.PFilter.{u1} P _inst_1} {G : Order.PFilter.{u1} P _inst_1}, (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)) x F) -> (LE.le.{u1} (Order.PFilter.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.PFilter.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P _inst_1) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)))) F G) -> (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)) x G)
 Case conversion may be inaccurate. Consider using '#align order.pfilter.mem_of_mem_of_le Order.PFilter.mem_of_mem_of_leₓ'. -/
@@ -157,16 +181,20 @@ def principal (p : P) : PFilter P :=
 #align order.pfilter.principal Order.PFilter.principal
 -/
 
-#print Order.PFilter.mem_mk /-
+/- warning: order.pfilter.mem_def -> Order.PFilter.mem_mk is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (x : P) (I : Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.hasLe.{u1} P (Preorder.toHasLe.{u1} P _inst_1))), Iff (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) x (Order.PFilter.mk.{u1} P _inst_1 I)) (Membership.Mem.{u1, u1} (OrderDual.{u1} P) (Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.hasLe.{u1} P (Preorder.toHasLe.{u1} P _inst_1))) (SetLike.hasMem.{u1, u1} (Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.hasLe.{u1} P (Preorder.toHasLe.{u1} P _inst_1))) (OrderDual.{u1} P) (Order.Ideal.setLike.{u1} (OrderDual.{u1} P) (OrderDual.hasLe.{u1} P (Preorder.toHasLe.{u1} P _inst_1)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} P (OrderDual.{u1} P)) (fun (_x : Equiv.{succ u1, succ u1} P (OrderDual.{u1} P)) => P -> (OrderDual.{u1} P)) (Equiv.hasCoeToFun.{succ u1, succ u1} P (OrderDual.{u1} P)) (OrderDual.toDual.{u1} P) x) I)
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] (x : P) (I : Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.instLEOrderDual.{u1} P (Preorder.toLE.{u1} P _inst_1))), Iff (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)) x (Order.PFilter.mk.{u1} P _inst_1 I)) (Membership.mem.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => OrderDual.{u1} P) x) (Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.instLEOrderDual.{u1} P (Preorder.toLE.{u1} P _inst_1))) (SetLike.instMembership.{u1, u1} (Order.Ideal.{u1} (OrderDual.{u1} P) (OrderDual.instLEOrderDual.{u1} P (Preorder.toLE.{u1} P _inst_1))) (OrderDual.{u1} P) (Order.Ideal.instSetLikeIdeal.{u1} (OrderDual.{u1} P) (OrderDual.instLEOrderDual.{u1} P (Preorder.toLE.{u1} P _inst_1)))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} P (OrderDual.{u1} P)) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => OrderDual.{u1} P) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} P (OrderDual.{u1} P)) (OrderDual.toDual.{u1} P) x) I)
+Case conversion may be inaccurate. Consider using '#align order.pfilter.mem_def Order.PFilter.mem_mkₓ'. -/
 @[simp]
 theorem mem_mk (x : P) (I : Ideal Pᵒᵈ) : x ∈ (⟨I⟩ : PFilter P) ↔ OrderDual.toDual x ∈ I :=
   Iff.rfl
 #align order.pfilter.mem_def Order.PFilter.mem_mk
--/
 
 /- warning: order.pfilter.principal_le_iff -> Order.PFilter.principal_le_iff is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {F : Order.PFilter.{u1} P _inst_1}, Iff (LE.le.{u1} (Order.PFilter.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.PFilter.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P _inst_1) (Order.PFilter.partialOrder.{u1} P _inst_1))) (Order.PFilter.principal.{u1} P _inst_1 x) F) (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) x F)
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {F : Order.PFilter.{u1} P _inst_1}, Iff (LE.le.{u1} (Order.PFilter.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.PFilter.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P _inst_1) (Order.PFilter.partialOrder.{u1} P _inst_1))) (Order.PFilter.principal.{u1} P _inst_1 x) F) (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) x F)
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {F : Order.PFilter.{u1} P _inst_1}, Iff (LE.le.{u1} (Order.PFilter.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.PFilter.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P _inst_1) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P _inst_1 x) F) (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)) x F)
 Case conversion may be inaccurate. Consider using '#align order.pfilter.principal_le_iff Order.PFilter.principal_le_iffₓ'. -/
@@ -175,12 +203,16 @@ theorem principal_le_iff {F : PFilter P} : principal x ≤ F ↔ x ∈ F :=
   Ideal.principal_le_iff
 #align order.pfilter.principal_le_iff Order.PFilter.principal_le_iff
 
-#print Order.PFilter.mem_principal /-
+/- warning: order.pfilter.mem_principal -> Order.PFilter.mem_principal is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {y : P}, Iff (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) x (Order.PFilter.principal.{u1} P _inst_1 y)) (LE.le.{u1} P (Preorder.toHasLe.{u1} P _inst_1) y x)
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {x : P} {y : P}, Iff (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)) x (Order.PFilter.principal.{u1} P _inst_1 y)) (LE.le.{u1} P (Preorder.toLE.{u1} P _inst_1) y x)
+Case conversion may be inaccurate. Consider using '#align order.pfilter.mem_principal Order.PFilter.mem_principalₓ'. -/
 @[simp]
 theorem mem_principal : x ∈ principal y ↔ y ≤ x :=
   Ideal.mem_principal
 #align order.pfilter.mem_principal Order.PFilter.mem_principal
--/
 
 /- warning: order.pfilter.antitone_principal -> Order.PFilter.antitone_principal is a dubious translation:
 lean 3 declaration is
@@ -194,7 +226,7 @@ theorem antitone_principal : Antitone (principal : P → PFilter P) := by delta
 
 /- warning: order.pfilter.principal_le_principal_iff -> Order.PFilter.principal_le_principal_iff is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {p : P} {q : P}, Iff (LE.le.{u1} (Order.PFilter.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.PFilter.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P _inst_1) (Order.PFilter.partialOrder.{u1} P _inst_1))) (Order.PFilter.principal.{u1} P _inst_1 q) (Order.PFilter.principal.{u1} P _inst_1 p)) (LE.le.{u1} P (Preorder.toLE.{u1} P _inst_1) p q)
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {p : P} {q : P}, Iff (LE.le.{u1} (Order.PFilter.{u1} P _inst_1) (Preorder.toHasLe.{u1} (Order.PFilter.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P _inst_1) (Order.PFilter.partialOrder.{u1} P _inst_1))) (Order.PFilter.principal.{u1} P _inst_1 q) (Order.PFilter.principal.{u1} P _inst_1 p)) (LE.le.{u1} P (Preorder.toHasLe.{u1} P _inst_1) p q)
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] {p : P} {q : P}, Iff (LE.le.{u1} (Order.PFilter.{u1} P _inst_1) (Preorder.toLE.{u1} (Order.PFilter.{u1} P _inst_1) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P _inst_1) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P _inst_1 q) (Order.PFilter.principal.{u1} P _inst_1 p)) (LE.le.{u1} P (Preorder.toLE.{u1} P _inst_1) p q)
 Case conversion may be inaccurate. Consider using '#align order.pfilter.principal_le_principal_iff Order.PFilter.principal_le_principal_iffₓ'. -/
@@ -209,7 +241,7 @@ variable [Preorder P] [OrderTop P] {F : PFilter P}
 
 /- warning: order.pfilter.top_mem -> Order.PFilter.top_mem is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] [_inst_2 : OrderTop.{u1} P (Preorder.toLE.{u1} P _inst_1)] {F : Order.PFilter.{u1} P _inst_1}, Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) (Top.top.{u1} P (OrderTop.toHasTop.{u1} P (Preorder.toLE.{u1} P _inst_1) _inst_2)) F
+  forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] [_inst_2 : OrderTop.{u1} P (Preorder.toHasLe.{u1} P _inst_1)] {F : Order.PFilter.{u1} P _inst_1}, Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (Order.PFilter.hasMem.{u1} P _inst_1) (Top.top.{u1} P (OrderTop.toHasTop.{u1} P (Preorder.toHasLe.{u1} P _inst_1) _inst_2)) F
 but is expected to have type
   forall {P : Type.{u1}} [_inst_1 : Preorder.{u1} P] [_inst_2 : OrderTop.{u1} P (Preorder.toLE.{u1} P _inst_1)] {F : Order.PFilter.{u1} P _inst_1}, Membership.mem.{u1, u1} P (Order.PFilter.{u1} P _inst_1) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P _inst_1) P (Order.PFilter.instSetLikePFilter.{u1} P _inst_1)) (Top.top.{u1} P (OrderTop.toTop.{u1} P (Preorder.toLE.{u1} P _inst_1) _inst_2)) F
 Case conversion may be inaccurate. Consider using '#align order.pfilter.top_mem Order.PFilter.top_memₓ'. -/

23aa88e3

bump to nightly-2023-05-14-08

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

d31da313

Diff

@@ -264,34 +264,34 @@ section CompleteSemilatticeInf
 
 variable [CompleteSemilatticeInf P] {F : PFilter P}
 
-/- warning: order.pfilter.Inf_gc -> Order.PFilter.infₛ_gc is a dubious translation:
+/- warning: order.pfilter.Inf_gc -> Order.PFilter.sInf_gc is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisConnection.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.partialOrder.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (x : P) => coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (_x : Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) => (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) -> (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.infₛ.{u1} P (CompleteSemilatticeInf.toHasInf.{u1} P _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) -> (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
+  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisConnection.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.partialOrder.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (x : P) => coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (_x : Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) => (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) -> (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.sInf.{u1} P (CompleteSemilatticeInf.toHasInf.{u1} P _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) -> (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisConnection.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (fun (x : P) => FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (fun (_x : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.infₛ.{u1} P (CompleteSemilatticeInf.toInfSet.{u1} P _inst_1) (SetLike.coe.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) F) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
-Case conversion may be inaccurate. Consider using '#align order.pfilter.Inf_gc Order.PFilter.infₛ_gcₓ'. -/
-theorem infₛ_gc :
+  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisConnection.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (fun (x : P) => FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (fun (_x : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.sInf.{u1} P (CompleteSemilatticeInf.toInfSet.{u1} P _inst_1) (SetLike.coe.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) F) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
+Case conversion may be inaccurate. Consider using '#align order.pfilter.Inf_gc Order.PFilter.sInf_gcₓ'. -/
+theorem sInf_gc :
     GaloisConnection (fun x => OrderDual.toDual (principal x)) fun F =>
-      infₛ (OrderDual.ofDual F : PFilter P) :=
+      sInf (OrderDual.ofDual F : PFilter P) :=
   fun x F => by
   simp
   rfl
-#align order.pfilter.Inf_gc Order.PFilter.infₛ_gc
+#align order.pfilter.Inf_gc Order.PFilter.sInf_gc
 
 /- warning: order.pfilter.Inf_gi -> Order.PFilter.infGi is a dubious translation:
 lean 3 declaration is
-  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisCoinsertion.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.partialOrder.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (x : P) => coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (_x : Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) => (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) -> (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.infₛ.{u1} P (CompleteSemilatticeInf.toHasInf.{u1} P _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) -> (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
+  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisCoinsertion.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.partialOrder.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (x : P) => coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (_x : Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) => (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) -> (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.sInf.{u1} P (CompleteSemilatticeInf.toHasInf.{u1} P _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) -> (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisCoinsertion.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (fun (x : P) => FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (fun (_x : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.infₛ.{u1} P (CompleteSemilatticeInf.toInfSet.{u1} P _inst_1) (SetLike.coe.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) F) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
+  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisCoinsertion.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (fun (x : P) => FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (fun (_x : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.sInf.{u1} P (CompleteSemilatticeInf.toInfSet.{u1} P _inst_1) (SetLike.coe.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) F) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
 Case conversion may be inaccurate. Consider using '#align order.pfilter.Inf_gi Order.PFilter.infGiₓ'. -/
 /-- If a poset `P` admits arbitrary `Inf`s, then `principal` and `Inf` form a Galois coinsertion. -/
 def infGi :
     GaloisCoinsertion (fun x => OrderDual.toDual (principal x)) fun F =>
-      infₛ (OrderDual.ofDual F : PFilter P)
+      sInf (OrderDual.ofDual F : PFilter P)
     where
-  choice F _ := infₛ (id F : PFilter P)
-  gc := infₛ_gc
-  u_l_le s := infₛ_le <| mem_principal.2 <| le_refl s
+  choice F _ := sInf (id F : PFilter P)
+  gc := sInf_gc
+  u_l_le s := sInf_le <| mem_principal.2 <| le_refl s
   choice_eq _ _ := rfl
 #align order.pfilter.Inf_gi Order.PFilter.infGi

23aa88e3

bump to nightly-2023-03-11-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/3180fab693e2cee3bff62675571264cb8778b212

a8ee822f

Diff

@@ -268,7 +268,7 @@ variable [CompleteSemilatticeInf P] {F : PFilter P}
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisConnection.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.partialOrder.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (x : P) => coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (_x : Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) => (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) -> (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.infₛ.{u1} P (CompleteSemilatticeInf.toHasInf.{u1} P _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) -> (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisConnection.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (fun (x : P) => FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (fun (_x : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.infₛ.{u1} P (CompleteSemilatticeInf.toInfSet.{u1} P _inst_1) (SetLike.coe.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) F) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
+  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisConnection.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (fun (x : P) => FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (fun (_x : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.infₛ.{u1} P (CompleteSemilatticeInf.toInfSet.{u1} P _inst_1) (SetLike.coe.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) F) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
 Case conversion may be inaccurate. Consider using '#align order.pfilter.Inf_gc Order.PFilter.infₛ_gcₓ'. -/
 theorem infₛ_gc :
     GaloisConnection (fun x => OrderDual.toDual (principal x)) fun F =>
@@ -282,7 +282,7 @@ theorem infₛ_gc :
 lean 3 declaration is
   forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisCoinsertion.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.partialOrder.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (x : P) => coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (fun (_x : Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) => (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) -> (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.infₛ.{u1} P (CompleteSemilatticeInf.toHasInf.{u1} P _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (HasLiftT.mk.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (CoeTCₓ.coe.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (coeBase.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Set.{u1} P) (Order.PFilter.Set.hasCoe.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) -> (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
 but is expected to have type
-  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisCoinsertion.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (fun (x : P) => FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (fun (_x : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.infₛ.{u1} P (CompleteSemilatticeInf.toInfSet.{u1} P _inst_1) (SetLike.coe.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) F) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
+  forall {P : Type.{u1}} [_inst_1 : CompleteSemilatticeInf.{u1} P], GaloisCoinsertion.{u1, u1} P (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) (OrderDual.preorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (PartialOrder.toPreorder.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instPartialOrder.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))))) (fun (x : P) => FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (fun (_x : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) => OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))))) (OrderDual.toDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.principal.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)) x)) (fun (F : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => InfSet.infₛ.{u1} P (CompleteSemilatticeInf.toInfSet.{u1} P _inst_1) (SetLike.coe.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) F) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (fun (_x : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) => Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (OrderDual.ofDual.{u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (CompleteSemilatticeInf.toPartialOrder.{u1} P _inst_1)))) F)))
 Case conversion may be inaccurate. Consider using '#align order.pfilter.Inf_gi Order.PFilter.infGiₓ'. -/
 /-- If a poset `P` admits arbitrary `Inf`s, then `principal` and `Inf` form a Galois coinsertion. -/
 def infGi :

23aa88e3

bump to nightly-2023-02-28-04

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

2097f8af

Diff

@@ -236,19 +236,27 @@ section SemilatticeInf
 
 variable [SemilatticeInf P] {x y : P} {F : PFilter P}
 
-#print Order.PFilter.inf_mem /-
+/- warning: order.pfilter.inf_mem -> Order.PFilter.inf_mem is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {x : P} {y : P} {F : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))}, (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.hasMem.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) x F) -> (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.hasMem.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) y F) -> (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.hasMem.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Inf.inf.{u1} P (SemilatticeInf.toHasInf.{u1} P _inst_1) x y) F)
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {x : P} {y : P} {F : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))}, (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) x F) -> (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) y F) -> (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Inf.inf.{u1} P (SemilatticeInf.toInf.{u1} P _inst_1) x y) F)
+Case conversion may be inaccurate. Consider using '#align order.pfilter.inf_mem Order.PFilter.inf_memₓ'. -/
 /-- A specific witness of `pfilter.directed` when `P` has meets. -/
 theorem inf_mem (hx : x ∈ F) (hy : y ∈ F) : x ⊓ y ∈ F :=
   Ideal.sup_mem hx hy
 #align order.pfilter.inf_mem Order.PFilter.inf_mem
--/
 
-#print Order.PFilter.inf_mem_iff /-
+/- warning: order.pfilter.inf_mem_iff -> Order.PFilter.inf_mem_iff is a dubious translation:
+lean 3 declaration is
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {x : P} {y : P} {F : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))}, Iff (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.hasMem.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Inf.inf.{u1} P (SemilatticeInf.toHasInf.{u1} P _inst_1) x y) F) (And (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.hasMem.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) x F) (Membership.Mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (Order.PFilter.hasMem.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) y F))
+but is expected to have type
+  forall {P : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} P] {x : P} {y : P} {F : Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))}, Iff (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) (Inf.inf.{u1} P (SemilatticeInf.toInf.{u1} P _inst_1) x y) F) (And (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) x F) (Membership.mem.{u1, u1} P (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) (SetLike.instMembership.{u1, u1} (Order.PFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1))) P (Order.PFilter.instSetLikePFilter.{u1} P (PartialOrder.toPreorder.{u1} P (SemilatticeInf.toPartialOrder.{u1} P _inst_1)))) y F))
+Case conversion may be inaccurate. Consider using '#align order.pfilter.inf_mem_iff Order.PFilter.inf_mem_iffₓ'. -/
 @[simp]
 theorem inf_mem_iff : x ⊓ y ∈ F ↔ x ∈ F ∧ y ∈ F :=
   Ideal.sup_mem_iff
 #align order.pfilter.inf_mem_iff Order.PFilter.inf_mem_iff
--/
 
 end SemilatticeInf

23aa88e3

bump to nightly-2023-02-23-03

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

5c91f1b0

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mathieu Guay-Paquet
 
 ! This file was ported from Lean 3 source module order.pfilter
-! leanprover-community/mathlib commit 3abee0542b353a50cbce24681b321b63c02839ba
+! leanprover-community/mathlib commit 23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -13,6 +13,9 @@ import Mathbin.Order.Ideal
 /-!
 # Order filters
 
+> 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

3abee054

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

740acc0e

chore: squeeze some non-terminal simps (#11247)

This PR accompanies #11246, squeezing some non-terminal simps highlighted by the linter until I decided to stop!

1ad8c3fe

Diff

@@ -170,7 +170,7 @@ variable [CompleteSemilatticeInf P] {F : PFilter P}
 theorem sInf_gc :
     GaloisConnection (fun x => toDual (principal x)) fun F => sInf (ofDual F : PFilter P) :=
   fun x F => by
-  simp
+  simp only [le_sInf_iff, SetLike.mem_coe]
   rfl
 #align order.pfilter.Inf_gc Order.PFilter.sInf_gc

740acc0e

chore(Order/PFilter): cosmetic improvement (#9177)

16a2a52a

Diff

@@ -12,19 +12,15 @@ import Mathlib.Order.Ideal
 
 ## Main definitions
 
-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.
+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.PFilter P`: The type of nonempty, downward directed, upward closed
-               subsets of `P`. This is dual to `Order.Ideal`, so it
-               simply wraps `Order.Ideal Pᵒᵈ`.
+- `Order.PFilter P`: The type of nonempty, downward directed, upward closed subsets of `P`.
+               This is dual to `Order.Ideal`, so it simply wraps `Order.Ideal Pᵒᵈ`.
 - `Order.IsPFilter P`: a predicate for when a `Set P` is a filter.
 
-
-Note the relation between `Order/Filter` and `Order/PFilter`: for any
-type `α`, `Filter α` represents the same mathematical object as
-`PFilter (Set α)`.
+Note the relation between `Order/Filter` and `Order/PFilter`: for any type `α`,
+`Filter α` represents the same mathematical object as `PFilter (Set α)`.
 
 ## References
 
@@ -40,16 +36,16 @@ open OrderDual
 
 namespace Order
 
-variable {P : Type*}
-
 /-- A filter on a preorder `P` is a subset of `P` that is
   - nonempty
   - downward directed
   - upward closed. -/
-structure PFilter (P) [Preorder P] where
+structure PFilter (P : Type*) [Preorder P] where
   dual : Ideal Pᵒᵈ
 #align order.pfilter Order.PFilter
 
+variable {P : Type*}
+
 /-- A predicate for when a subset of `P` is a filter. -/
 def IsPFilter [Preorder P] (F : Set P) : Prop :=
   IsIdeal (OrderDual.ofDual ⁻¹' F)

740acc0e

chore: banish Type _ and Sort _ (#6499)

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

This has nice performance benefits.

32de3f67

Diff

@@ -40,7 +40,7 @@ open OrderDual
 
 namespace Order
 
-variable {P : Type _}
+variable {P : Type*}
 
 /-- A filter on a preorder `P` is a subset of `P` that is
   - nonempty

740acc0e

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2020 Mathieu Guay-Paquet. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mathieu Guay-Paquet
-
-! This file was ported from Lean 3 source module order.pfilter
-! 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
 
+#align_import order.pfilter from "leanprover-community/mathlib"@"740acc0e6f9adf4423f92a485d0456fc271482da"
+
 /-!
 # Order filters

740acc0e

chore: Rename to sSup/iSup (#3938)

As discussed on Zulip

Renames

supₛ → sSup
infₛ → sInf
supᵢ → iSup
infᵢ → iInf
bsupₛ → bsSup
binfₛ → bsInf
bsupᵢ → biSup
binfᵢ → biInf
csupₛ → csSup
cinfₛ → csInf
csupᵢ → ciSup
cinfᵢ → ciInf
unionₛ → sUnion
interₛ → sInter
unionᵢ → iUnion
interᵢ → iInter
bunionₛ → bsUnion
binterₛ → bsInter
bunionᵢ → biUnion
binterᵢ → biInter

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

d1eb6264

Diff

@@ -174,17 +174,17 @@ section CompleteSemilatticeInf
 
 variable [CompleteSemilatticeInf P] {F : PFilter P}
 
-theorem infₛ_gc :
-    GaloisConnection (fun x => toDual (principal x)) fun F => infₛ (ofDual F : PFilter P) :=
+theorem sInf_gc :
+    GaloisConnection (fun x => toDual (principal x)) fun F => sInf (ofDual F : PFilter P) :=
   fun x F => by
   simp
   rfl
-#align order.pfilter.Inf_gc Order.PFilter.infₛ_gc
+#align order.pfilter.Inf_gc Order.PFilter.sInf_gc
 
 /-- If a poset `P` admits arbitrary `Inf`s, then `principal` and `Inf` form a Galois coinsertion. -/
 def infGi :
-    GaloisCoinsertion (fun x => toDual (principal x)) fun F => infₛ (ofDual F : PFilter P) :=
-  infₛ_gc.toGaloisCoinsertion fun _ => infₛ_le <| mem_principal.2 le_rfl
+    GaloisCoinsertion (fun x => toDual (principal x)) fun F => sInf (ofDual F : PFilter P) :=
+  sInf_gc.toGaloisCoinsertion fun _ => sInf_le <| mem_principal.2 le_rfl
 #align order.pfilter.Inf_gi Order.PFilter.infGi
 
 end CompleteSemilatticeInf

740acc0e

chore: fix #align lines (#3640)

This PR fixes two things:

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

2b42dc7c

Diff

@@ -82,7 +82,6 @@ instance [Inhabited P] : Inhabited (PFilter P) := ⟨⟨default⟩⟩
 instance : SetLike (PFilter P) P where
   coe F := toDual ⁻¹' F.dual.carrier
   coe_injective' := fun ⟨_⟩ ⟨_⟩ h => congr_arg mk <| Ideal.ext h
-
 #align order.pfilter.mem_coe SetLike.mem_coeₓ
 
 theorem isPFilter : IsPFilter (F : Set P) := F.dual.isIdeal

740acc0e

chore: tidy various files (#2446)

54bf6e04

Diff

@@ -25,9 +25,9 @@ a join-semilattice structure.
 - `Order.IsPFilter P`: a predicate for when a `Set P` is a filter.
 
 
-Note the relation between `order/Filter` and `order/pfilter`: for any
+Note the relation between `Order/Filter` and `Order/PFilter`: for any
 type `α`, `Filter α` represents the same mathematical object as
-`pfilter (Set α)`.
+`PFilter (Set α)`.
 
 ## References
 
@@ -193,4 +193,3 @@ end CompleteSemilatticeInf
 end PFilter
 
 end Order
-

740acc0e

feat: port Order.Pfilter (#2351)

I replaced Coe and Membership with SetLike since the order is not reversed (as it is for Filters).

5efa544e

`order.pfilter` ⟷ `Mathlib.Order.PFilter`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Renames

Dependencies 2 + 160

order.pfilter ⟷ Mathlib.Order.PFilter

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Renames

Dependencies 2 + 160

`order.pfilter` ⟷ `Mathlib.Order.PFilter`