order.rel_iso.set | 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

ee0c179c

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

448144f7

bump to nightly-2024-02-07-08

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

8a1bf67e

Diff

@@ -34,7 +34,7 @@ variable {F : Type _}
 theorem map_inf [SemilatticeInf α] [LinearOrder β]
     [RelHomClass F ((· < ·) : β → β → Prop) ((· < ·) : α → α → Prop)] (a : F) (m n : β) :
     a (m ⊓ n) = a m ⊓ a n :=
-  (StrictMono.monotone fun x y => map_rel a).map_inf m n
+  (StrictMono.monotone fun x y => mapRel a).map_inf m n
 #align rel_hom_class.map_inf RelHomClass.map_inf
 -/

448144f7

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2017 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro
 -/
-import Mathbin.Order.RelIso.Basic
-import Mathbin.Logic.Embedding.Set
+import Order.RelIso.Basic
+import Logic.Embedding.Set
 
 #align_import order.rel_iso.set from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"

448144f7

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2017 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro
-
-! This file was ported from Lean 3 source module order.rel_iso.set
-! leanprover-community/mathlib commit 448144f7ae193a8990cb7473c9e9a01990f64ac7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.RelIso.Basic
 import Mathbin.Logic.Embedding.Set
 
+#align_import order.rel_iso.set from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"
+
 /-!
 # Interactions between relation homomorphisms and sets

448144f7

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -33,26 +33,32 @@ namespace RelHomClass
 
 variable {F : Type _}
 
+#print RelHomClass.map_inf /-
 theorem map_inf [SemilatticeInf α] [LinearOrder β]
     [RelHomClass F ((· < ·) : β → β → Prop) ((· < ·) : α → α → Prop)] (a : F) (m n : β) :
     a (m ⊓ n) = a m ⊓ a n :=
   (StrictMono.monotone fun x y => map_rel a).map_inf m n
 #align rel_hom_class.map_inf RelHomClass.map_inf
+-/
 
+#print RelHomClass.map_sup /-
 theorem map_sup [SemilatticeSup α] [LinearOrder β]
     [RelHomClass F ((· > ·) : β → β → Prop) ((· > ·) : α → α → Prop)] (a : F) (m n : β) :
     a (m ⊔ n) = a m ⊔ a n :=
   @map_inf αᵒᵈ βᵒᵈ _ _ _ _ _ _ _
 #align rel_hom_class.map_sup RelHomClass.map_sup
+-/
 
 end RelHomClass
 
 namespace RelIso
 
+#print RelIso.range_eq /-
 @[simp]
 theorem range_eq (e : r ≃r s) : Set.range e = Set.univ :=
   e.Surjective.range_eq
 #align rel_iso.range_eq RelIso.range_eq
+-/
 
 end RelIso
 
@@ -79,10 +85,12 @@ protected def relEmbedding (r : α → α → Prop) (p : Set α) : Subrel r p 
 #align subrel.rel_embedding Subrel.relEmbedding
 -/
 
+#print Subrel.relEmbedding_apply /-
 @[simp]
 theorem relEmbedding_apply (r : α → α → Prop) (p a) : Subrel.relEmbedding r p a = a.1 :=
   rfl
 #align subrel.rel_embedding_apply Subrel.relEmbedding_apply
+-/
 
 instance (r : α → α → Prop) [IsWellOrder α r] (p : Set α) : IsWellOrder p (Subrel r p) :=
   RelEmbedding.isWellOrder (Subrel.relEmbedding r p)
@@ -101,14 +109,18 @@ instance (r : α → α → Prop) [IsIrrefl α r] (p : Set α) : IsIrrefl p (Sub
 
 end Subrel
 
+#print RelEmbedding.codRestrict /-
 /-- Restrict the codomain of a relation embedding. -/
 def RelEmbedding.codRestrict (p : Set β) (f : r ↪r s) (H : ∀ a, f a ∈ p) : r ↪r Subrel s p :=
   ⟨f.toEmbedding.codRestrict p H, fun _ _ => f.map_rel_iff'⟩
 #align rel_embedding.cod_restrict RelEmbedding.codRestrict
+-/
 
+#print RelEmbedding.codRestrict_apply /-
 @[simp]
 theorem RelEmbedding.codRestrict_apply (p) (f : r ↪r s) (H a) :
     RelEmbedding.codRestrict p f H a = ⟨f a, H a⟩ :=
   rfl
 #align rel_embedding.cod_restrict_apply RelEmbedding.codRestrict_apply
+-/

448144f7

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -33,24 +33,12 @@ namespace RelHomClass
 
 variable {F : Type _}
 
-/- warning: rel_hom_class.map_inf -> RelHomClass.map_inf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {F : Type.{u3}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))))] (a : F) (m : β) (n : β), Eq.{succ u1} α (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a (Inf.inf.{u2} β (SemilatticeInf.toHasInf.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2))) m n)) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a m) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a n))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {F : Type.{u1}} [_inst_1 : SemilatticeInf.{u3} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (x._@.Mathlib.Order.RelIso.Set._hyg.133 : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) x._@.Mathlib.Order.RelIso.Set._hyg.133 x._@.Mathlib.Order.RelIso.Set._hyg.135)] (a : F) (m : β) (n : β), Eq.{succ u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) (Inf.inf.{u2} β (Lattice.toInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2))) m n)) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.135) _inst_3) a (Inf.inf.{u2} β (Lattice.toInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2))) m n)) (Inf.inf.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) m) (SemilatticeInf.toInf.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) m) _inst_1) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.135) _inst_3) a m) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.135) _inst_3) a n))
-Case conversion may be inaccurate. Consider using '#align rel_hom_class.map_inf RelHomClass.map_infₓ'. -/
 theorem map_inf [SemilatticeInf α] [LinearOrder β]
     [RelHomClass F ((· < ·) : β → β → Prop) ((· < ·) : α → α → Prop)] (a : F) (m n : β) :
     a (m ⊓ n) = a m ⊓ a n :=
   (StrictMono.monotone fun x y => map_rel a).map_inf m n
 #align rel_hom_class.map_inf RelHomClass.map_inf
 
-/- warning: rel_hom_class.map_sup -> RelHomClass.map_sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {F : Type.{u3}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))))] (a : F) (m : β) (n : β), Eq.{succ u1} α (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a (Sup.sup.{u2} β (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (LinearOrder.toLattice.{u2} β _inst_2))) m n)) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a m) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a n))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {F : Type.{u1}} [_inst_1 : SemilatticeSup.{u3} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (x._@.Mathlib.Order.RelIso.Set._hyg.250 : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) x._@.Mathlib.Order.RelIso.Set._hyg.250 x._@.Mathlib.Order.RelIso.Set._hyg.252)] (a : F) (m : β) (n : β), Eq.{succ u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) (Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))) m n)) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.252) _inst_3) a (Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))) m n)) (Sup.sup.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) m) (SemilatticeSup.toSup.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) m) _inst_1) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.252) _inst_3) a m) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.252) _inst_3) a n))
-Case conversion may be inaccurate. Consider using '#align rel_hom_class.map_sup RelHomClass.map_supₓ'. -/
 theorem map_sup [SemilatticeSup α] [LinearOrder β]
     [RelHomClass F ((· > ·) : β → β → Prop) ((· > ·) : α → α → Prop)] (a : F) (m n : β) :
     a (m ⊔ n) = a m ⊔ a n :=
@@ -61,12 +49,6 @@ end RelHomClass
 
 namespace RelIso
 
-/- warning: rel_iso.range_eq -> RelIso.range_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {r : α -> α -> Prop} {s : β -> β -> Prop} (e : RelIso.{u1, u2} α β r s), Eq.{succ u2} (Set.{u2} β) (Set.range.{u2, succ u1} β α (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RelIso.{u1, u2} α β r s) (fun (_x : RelIso.{u1, u2} α β r s) => α -> β) (RelIso.hasCoeToFun.{u1, u2} α β r s) e)) (Set.univ.{u2} β)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {r : α -> α -> Prop} {s : β -> β -> Prop} (e : RelIso.{u2, u1} α β r s), Eq.{succ u1} (Set.{u1} β) (Set.range.{u1, succ u2} β α (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} α β r s) α (fun (_x : α) => β) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} α β r s) α β r s (RelIso.instRelHomClassRelIso.{u2, u1} α β r s)) e)) (Set.univ.{u1} β)
-Case conversion may be inaccurate. Consider using '#align rel_iso.range_eq RelIso.range_eqₓ'. -/
 @[simp]
 theorem range_eq (e : r ≃r s) : Set.range e = Set.univ :=
   e.Surjective.range_eq
@@ -97,12 +79,6 @@ protected def relEmbedding (r : α → α → Prop) (p : Set α) : Subrel r p 
 #align subrel.rel_embedding Subrel.relEmbedding
 -/
 
-/- warning: subrel.rel_embedding_apply -> Subrel.relEmbedding_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (r : α -> α -> Prop) (p : Set.{u1} α) (a : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) p), Eq.{succ u1} α (coeFn.{succ u1, succ u1} (RelEmbedding.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) p) α (Subrel.{u1} α r p) r) (fun (_x : RelEmbedding.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) p) α (Subrel.{u1} α r p) r) => (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) p) -> α) (RelEmbedding.hasCoeToFun.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) p) α (Subrel.{u1} α r p) r) (Subrel.relEmbedding.{u1} α r p) a) (Subtype.val.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x p) a)
-but is expected to have type
-  forall {α : Type.{u1}} (r : α -> α -> Prop) (p : Set.{u1} α) (a : Set.Elem.{u1} α p), Eq.{succ u1} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : Set.Elem.{u1} α p) => α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (RelEmbedding.{u1, u1} (Set.Elem.{u1} α p) α (Subrel.{u1} α r p) r) (Set.Elem.{u1} α p) (fun (_x : Set.Elem.{u1} α p) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : Set.Elem.{u1} α p) => α) _x) (RelHomClass.toFunLike.{u1, u1, u1} (RelEmbedding.{u1, u1} (Set.Elem.{u1} α p) α (Subrel.{u1} α r p) r) (Set.Elem.{u1} α p) α (Subrel.{u1} α r p) r (RelEmbedding.instRelHomClassRelEmbedding.{u1, u1} (Set.Elem.{u1} α p) α (Subrel.{u1} α r p) r)) (Subrel.relEmbedding.{u1} α r p) a) (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x p) a)
-Case conversion may be inaccurate. Consider using '#align subrel.rel_embedding_apply Subrel.relEmbedding_applyₓ'. -/
 @[simp]
 theorem relEmbedding_apply (r : α → α → Prop) (p a) : Subrel.relEmbedding r p a = a.1 :=
   rfl
@@ -125,23 +101,11 @@ instance (r : α → α → Prop) [IsIrrefl α r] (p : Set α) : IsIrrefl p (Sub
 
 end Subrel
 
-/- warning: rel_embedding.cod_restrict -> RelEmbedding.codRestrict is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {r : α -> α -> Prop} {s : β -> β -> Prop} (p : Set.{u2} β) (f : RelEmbedding.{u1, u2} α β r s), (forall (a : α), Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RelEmbedding.{u1, u2} α β r s) (fun (_x : RelEmbedding.{u1, u2} α β r s) => α -> β) (RelEmbedding.hasCoeToFun.{u1, u2} α β r s) f a) p) -> (RelEmbedding.{u1, u2} α (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) p) r (Subrel.{u2} β s p))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {r : α -> α -> Prop} {s : β -> β -> Prop} (p : Set.{u2} β) (f : RelEmbedding.{u1, u2} α β r s), (forall (a : α), Membership.mem.{u2, u2} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : α) => β) a) (Set.{u2} β) (Set.instMembershipSet.{u2} β) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelEmbedding.{u1, u2} α β r s) α (fun (_x : α) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : α) => β) _x) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelEmbedding.{u1, u2} α β r s) α β r s (RelEmbedding.instRelHomClassRelEmbedding.{u1, u2} α β r s)) f a) p) -> (RelEmbedding.{u1, u2} α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p))
-Case conversion may be inaccurate. Consider using '#align rel_embedding.cod_restrict RelEmbedding.codRestrictₓ'. -/
 /-- Restrict the codomain of a relation embedding. -/
 def RelEmbedding.codRestrict (p : Set β) (f : r ↪r s) (H : ∀ a, f a ∈ p) : r ↪r Subrel s p :=
   ⟨f.toEmbedding.codRestrict p H, fun _ _ => f.map_rel_iff'⟩
 #align rel_embedding.cod_restrict RelEmbedding.codRestrict
 
-/- warning: rel_embedding.cod_restrict_apply -> RelEmbedding.codRestrict_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {r : α -> α -> Prop} {s : β -> β -> Prop} (p : Set.{u2} β) (f : RelEmbedding.{u1, u2} α β r s) (H : forall (a : α), Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RelEmbedding.{u1, u2} α β r s) (fun (_x : RelEmbedding.{u1, u2} α β r s) => α -> β) (RelEmbedding.hasCoeToFun.{u1, u2} α β r s) f a) p) (a : α), Eq.{succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) p) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RelEmbedding.{u1, u2} α (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) p) r (Subrel.{u2} β s p)) (fun (_x : RelEmbedding.{u1, u2} α (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) p) r (Subrel.{u2} β s p)) => α -> (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) p)) (RelEmbedding.hasCoeToFun.{u1, u2} α (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) p) r (Subrel.{u2} β s p)) (RelEmbedding.codRestrict.{u1, u2} α β r s p f H) a) (Subtype.mk.{succ u2} β (fun (x : β) => Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x p) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RelEmbedding.{u1, u2} α β r s) (fun (_x : RelEmbedding.{u1, u2} α β r s) => α -> β) (RelEmbedding.hasCoeToFun.{u1, u2} α β r s) f a) (H a))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {r : α -> α -> Prop} {s : β -> β -> Prop} (p : Set.{u2} β) (f : RelEmbedding.{u1, u2} α β r s) (H : forall (a : α), Membership.mem.{u2, u2} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : α) => β) a) (Set.{u2} β) (Set.instMembershipSet.{u2} β) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelEmbedding.{u1, u2} α β r s) α (fun (_x : α) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : α) => β) _x) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelEmbedding.{u1, u2} α β r s) α β r s (RelEmbedding.instRelHomClassRelEmbedding.{u1, u2} α β r s)) f a) p) (a : α), Eq.{succ u2} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : α) => Set.Elem.{u2} β p) a) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelEmbedding.{u1, u2} α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p)) α (fun (_x : α) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : α) => Set.Elem.{u2} β p) _x) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelEmbedding.{u1, u2} α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p)) α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p) (RelEmbedding.instRelHomClassRelEmbedding.{u1, u2} α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p))) (RelEmbedding.codRestrict.{u1, u2} α β r s p f H) a) (Subtype.mk.{succ u2} β (fun (x : β) => Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x p) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelEmbedding.{u1, u2} α β r s) α (fun (_x : α) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : α) => β) _x) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelEmbedding.{u1, u2} α β r s) α β r s (RelEmbedding.instRelHomClassRelEmbedding.{u1, u2} α β r s)) f a) (H a))
-Case conversion may be inaccurate. Consider using '#align rel_embedding.cod_restrict_apply RelEmbedding.codRestrict_applyₓ'. -/
 @[simp]
 theorem RelEmbedding.codRestrict_apply (p) (f : r ↪r s) (H a) :
     RelEmbedding.codRestrict p f H a = ⟨f a, H a⟩ :=

448144f7

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -37,7 +37,7 @@ variable {F : Type _}
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {F : Type.{u3}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))))] (a : F) (m : β) (n : β), Eq.{succ u1} α (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a (Inf.inf.{u2} β (SemilatticeInf.toHasInf.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2))) m n)) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a m) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a n))
 but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {F : Type.{u1}} [_inst_1 : SemilatticeInf.{u3} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (x._@.Mathlib.Order.RelIso.Set._hyg.133 : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) x._@.Mathlib.Order.RelIso.Set._hyg.133 x._@.Mathlib.Order.RelIso.Set._hyg.135)] (a : F) (m : β) (n : β), Eq.{succ u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) (Inf.inf.{u2} β (Lattice.toInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2))) m n)) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.135) _inst_3) a (Inf.inf.{u2} β (Lattice.toInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2))) m n)) (Inf.inf.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) (SemilatticeInf.toInf.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) _inst_1) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.135) _inst_3) a m) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.135) _inst_3) a n))
+  forall {α : Type.{u3}} {β : Type.{u2}} {F : Type.{u1}} [_inst_1 : SemilatticeInf.{u3} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (x._@.Mathlib.Order.RelIso.Set._hyg.133 : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) x._@.Mathlib.Order.RelIso.Set._hyg.133 x._@.Mathlib.Order.RelIso.Set._hyg.135)] (a : F) (m : β) (n : β), Eq.{succ u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) (Inf.inf.{u2} β (Lattice.toInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2))) m n)) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.135) _inst_3) a (Inf.inf.{u2} β (Lattice.toInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2))) m n)) (Inf.inf.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) m) (SemilatticeInf.toInf.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) m) _inst_1) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.135) _inst_3) a m) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.135) _inst_3) a n))
 Case conversion may be inaccurate. Consider using '#align rel_hom_class.map_inf RelHomClass.map_infₓ'. -/
 theorem map_inf [SemilatticeInf α] [LinearOrder β]
     [RelHomClass F ((· < ·) : β → β → Prop) ((· < ·) : α → α → Prop)] (a : F) (m n : β) :
@@ -49,7 +49,7 @@ theorem map_inf [SemilatticeInf α] [LinearOrder β]
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {F : Type.{u3}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))))] (a : F) (m : β) (n : β), Eq.{succ u1} α (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a (Sup.sup.{u2} β (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (LinearOrder.toLattice.{u2} β _inst_2))) m n)) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a m) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a n))
 but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {F : Type.{u1}} [_inst_1 : SemilatticeSup.{u3} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (x._@.Mathlib.Order.RelIso.Set._hyg.250 : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) x._@.Mathlib.Order.RelIso.Set._hyg.250 x._@.Mathlib.Order.RelIso.Set._hyg.252)] (a : F) (m : β) (n : β), Eq.{succ u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) (Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))) m n)) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.252) _inst_3) a (Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))) m n)) (Sup.sup.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) (SemilatticeSup.toSup.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) _inst_1) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.252) _inst_3) a m) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.252) _inst_3) a n))
+  forall {α : Type.{u3}} {β : Type.{u2}} {F : Type.{u1}} [_inst_1 : SemilatticeSup.{u3} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (x._@.Mathlib.Order.RelIso.Set._hyg.250 : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) x._@.Mathlib.Order.RelIso.Set._hyg.250 x._@.Mathlib.Order.RelIso.Set._hyg.252)] (a : F) (m : β) (n : β), Eq.{succ u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) (Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))) m n)) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.252) _inst_3) a (Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))) m n)) (Sup.sup.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) m) (SemilatticeSup.toSup.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) m) _inst_1) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.252) _inst_3) a m) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.252) _inst_3) a n))
 Case conversion may be inaccurate. Consider using '#align rel_hom_class.map_sup RelHomClass.map_supₓ'. -/
 theorem map_sup [SemilatticeSup α] [LinearOrder β]
     [RelHomClass F ((· > ·) : β → β → Prop) ((· > ·) : α → α → Prop)] (a : F) (m n : β) :
@@ -101,7 +101,7 @@ protected def relEmbedding (r : α → α → Prop) (p : Set α) : Subrel r p 
 lean 3 declaration is
   forall {α : Type.{u1}} (r : α -> α -> Prop) (p : Set.{u1} α) (a : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) p), Eq.{succ u1} α (coeFn.{succ u1, succ u1} (RelEmbedding.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) p) α (Subrel.{u1} α r p) r) (fun (_x : RelEmbedding.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) p) α (Subrel.{u1} α r p) r) => (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) p) -> α) (RelEmbedding.hasCoeToFun.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) p) α (Subrel.{u1} α r p) r) (Subrel.relEmbedding.{u1} α r p) a) (Subtype.val.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x p) a)
 but is expected to have type
-  forall {α : Type.{u1}} (r : α -> α -> Prop) (p : Set.{u1} α) (a : Set.Elem.{u1} α p), Eq.{succ u1} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : Set.Elem.{u1} α p) => α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (RelEmbedding.{u1, u1} (Set.Elem.{u1} α p) α (Subrel.{u1} α r p) r) (Set.Elem.{u1} α p) (fun (_x : Set.Elem.{u1} α p) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : Set.Elem.{u1} α p) => α) _x) (RelHomClass.toFunLike.{u1, u1, u1} (RelEmbedding.{u1, u1} (Set.Elem.{u1} α p) α (Subrel.{u1} α r p) r) (Set.Elem.{u1} α p) α (Subrel.{u1} α r p) r (RelEmbedding.instRelHomClassRelEmbedding.{u1, u1} (Set.Elem.{u1} α p) α (Subrel.{u1} α r p) r)) (Subrel.relEmbedding.{u1} α r p) a) (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x p) a)
+  forall {α : Type.{u1}} (r : α -> α -> Prop) (p : Set.{u1} α) (a : Set.Elem.{u1} α p), Eq.{succ u1} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : Set.Elem.{u1} α p) => α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (RelEmbedding.{u1, u1} (Set.Elem.{u1} α p) α (Subrel.{u1} α r p) r) (Set.Elem.{u1} α p) (fun (_x : Set.Elem.{u1} α p) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : Set.Elem.{u1} α p) => α) _x) (RelHomClass.toFunLike.{u1, u1, u1} (RelEmbedding.{u1, u1} (Set.Elem.{u1} α p) α (Subrel.{u1} α r p) r) (Set.Elem.{u1} α p) α (Subrel.{u1} α r p) r (RelEmbedding.instRelHomClassRelEmbedding.{u1, u1} (Set.Elem.{u1} α p) α (Subrel.{u1} α r p) r)) (Subrel.relEmbedding.{u1} α r p) a) (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x p) a)
 Case conversion may be inaccurate. Consider using '#align subrel.rel_embedding_apply Subrel.relEmbedding_applyₓ'. -/
 @[simp]
 theorem relEmbedding_apply (r : α → α → Prop) (p a) : Subrel.relEmbedding r p a = a.1 :=
@@ -129,7 +129,7 @@ end Subrel
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {r : α -> α -> Prop} {s : β -> β -> Prop} (p : Set.{u2} β) (f : RelEmbedding.{u1, u2} α β r s), (forall (a : α), Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RelEmbedding.{u1, u2} α β r s) (fun (_x : RelEmbedding.{u1, u2} α β r s) => α -> β) (RelEmbedding.hasCoeToFun.{u1, u2} α β r s) f a) p) -> (RelEmbedding.{u1, u2} α (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) p) r (Subrel.{u2} β s p))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {r : α -> α -> Prop} {s : β -> β -> Prop} (p : Set.{u2} β) (f : RelEmbedding.{u1, u2} α β r s), (forall (a : α), Membership.mem.{u2, u2} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : α) => β) a) (Set.{u2} β) (Set.instMembershipSet.{u2} β) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelEmbedding.{u1, u2} α β r s) α (fun (_x : α) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : α) => β) _x) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelEmbedding.{u1, u2} α β r s) α β r s (RelEmbedding.instRelHomClassRelEmbedding.{u1, u2} α β r s)) f a) p) -> (RelEmbedding.{u1, u2} α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p))
+  forall {α : Type.{u1}} {β : Type.{u2}} {r : α -> α -> Prop} {s : β -> β -> Prop} (p : Set.{u2} β) (f : RelEmbedding.{u1, u2} α β r s), (forall (a : α), Membership.mem.{u2, u2} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : α) => β) a) (Set.{u2} β) (Set.instMembershipSet.{u2} β) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelEmbedding.{u1, u2} α β r s) α (fun (_x : α) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : α) => β) _x) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelEmbedding.{u1, u2} α β r s) α β r s (RelEmbedding.instRelHomClassRelEmbedding.{u1, u2} α β r s)) f a) p) -> (RelEmbedding.{u1, u2} α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p))
 Case conversion may be inaccurate. Consider using '#align rel_embedding.cod_restrict RelEmbedding.codRestrictₓ'. -/
 /-- Restrict the codomain of a relation embedding. -/
 def RelEmbedding.codRestrict (p : Set β) (f : r ↪r s) (H : ∀ a, f a ∈ p) : r ↪r Subrel s p :=
@@ -140,7 +140,7 @@ def RelEmbedding.codRestrict (p : Set β) (f : r ↪r s) (H : ∀ a, f a ∈ p)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {r : α -> α -> Prop} {s : β -> β -> Prop} (p : Set.{u2} β) (f : RelEmbedding.{u1, u2} α β r s) (H : forall (a : α), Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RelEmbedding.{u1, u2} α β r s) (fun (_x : RelEmbedding.{u1, u2} α β r s) => α -> β) (RelEmbedding.hasCoeToFun.{u1, u2} α β r s) f a) p) (a : α), Eq.{succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) p) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RelEmbedding.{u1, u2} α (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) p) r (Subrel.{u2} β s p)) (fun (_x : RelEmbedding.{u1, u2} α (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) p) r (Subrel.{u2} β s p)) => α -> (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) p)) (RelEmbedding.hasCoeToFun.{u1, u2} α (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) p) r (Subrel.{u2} β s p)) (RelEmbedding.codRestrict.{u1, u2} α β r s p f H) a) (Subtype.mk.{succ u2} β (fun (x : β) => Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x p) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RelEmbedding.{u1, u2} α β r s) (fun (_x : RelEmbedding.{u1, u2} α β r s) => α -> β) (RelEmbedding.hasCoeToFun.{u1, u2} α β r s) f a) (H a))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {r : α -> α -> Prop} {s : β -> β -> Prop} (p : Set.{u2} β) (f : RelEmbedding.{u1, u2} α β r s) (H : forall (a : α), Membership.mem.{u2, u2} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : α) => β) a) (Set.{u2} β) (Set.instMembershipSet.{u2} β) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelEmbedding.{u1, u2} α β r s) α (fun (_x : α) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : α) => β) _x) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelEmbedding.{u1, u2} α β r s) α β r s (RelEmbedding.instRelHomClassRelEmbedding.{u1, u2} α β r s)) f a) p) (a : α), Eq.{succ u2} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : α) => Set.Elem.{u2} β p) a) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelEmbedding.{u1, u2} α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p)) α (fun (_x : α) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : α) => Set.Elem.{u2} β p) _x) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelEmbedding.{u1, u2} α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p)) α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p) (RelEmbedding.instRelHomClassRelEmbedding.{u1, u2} α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p))) (RelEmbedding.codRestrict.{u1, u2} α β r s p f H) a) (Subtype.mk.{succ u2} β (fun (x : β) => Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x p) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelEmbedding.{u1, u2} α β r s) α (fun (_x : α) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : α) => β) _x) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelEmbedding.{u1, u2} α β r s) α β r s (RelEmbedding.instRelHomClassRelEmbedding.{u1, u2} α β r s)) f a) (H a))
+  forall {α : Type.{u1}} {β : Type.{u2}} {r : α -> α -> Prop} {s : β -> β -> Prop} (p : Set.{u2} β) (f : RelEmbedding.{u1, u2} α β r s) (H : forall (a : α), Membership.mem.{u2, u2} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : α) => β) a) (Set.{u2} β) (Set.instMembershipSet.{u2} β) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelEmbedding.{u1, u2} α β r s) α (fun (_x : α) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : α) => β) _x) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelEmbedding.{u1, u2} α β r s) α β r s (RelEmbedding.instRelHomClassRelEmbedding.{u1, u2} α β r s)) f a) p) (a : α), Eq.{succ u2} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : α) => Set.Elem.{u2} β p) a) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelEmbedding.{u1, u2} α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p)) α (fun (_x : α) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : α) => Set.Elem.{u2} β p) _x) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelEmbedding.{u1, u2} α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p)) α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p) (RelEmbedding.instRelHomClassRelEmbedding.{u1, u2} α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p))) (RelEmbedding.codRestrict.{u1, u2} α β r s p f H) a) (Subtype.mk.{succ u2} β (fun (x : β) => Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x p) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelEmbedding.{u1, u2} α β r s) α (fun (_x : α) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : α) => β) _x) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelEmbedding.{u1, u2} α β r s) α β r s (RelEmbedding.instRelHomClassRelEmbedding.{u1, u2} α β r s)) f a) (H a))
 Case conversion may be inaccurate. Consider using '#align rel_embedding.cod_restrict_apply RelEmbedding.codRestrict_applyₓ'. -/
 @[simp]
 theorem RelEmbedding.codRestrict_apply (p) (f : r ↪r s) (H a) :

448144f7

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -35,7 +35,7 @@ variable {F : Type _}
 
 /- warning: rel_hom_class.map_inf -> RelHomClass.map_inf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {F : Type.{u3}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))))] (a : F) (m : β) (n : β), Eq.{succ u1} α (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a (Inf.inf.{u2} β (SemilatticeInf.toHasInf.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2))) m n)) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a m) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a n))
+  forall {α : Type.{u1}} {β : Type.{u2}} {F : Type.{u3}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))))] (a : F) (m : β) (n : β), Eq.{succ u1} α (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a (Inf.inf.{u2} β (SemilatticeInf.toHasInf.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2))) m n)) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a m) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a n))
 but is expected to have type
   forall {α : Type.{u3}} {β : Type.{u2}} {F : Type.{u1}} [_inst_1 : SemilatticeInf.{u3} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (x._@.Mathlib.Order.RelIso.Set._hyg.133 : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) x._@.Mathlib.Order.RelIso.Set._hyg.133 x._@.Mathlib.Order.RelIso.Set._hyg.135)] (a : F) (m : β) (n : β), Eq.{succ u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) (Inf.inf.{u2} β (Lattice.toInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2))) m n)) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.135) _inst_3) a (Inf.inf.{u2} β (Lattice.toInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2))) m n)) (Inf.inf.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) (SemilatticeInf.toInf.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) _inst_1) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.135) _inst_3) a m) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.135) _inst_3) a n))
 Case conversion may be inaccurate. Consider using '#align rel_hom_class.map_inf RelHomClass.map_infₓ'. -/
@@ -47,7 +47,7 @@ theorem map_inf [SemilatticeInf α] [LinearOrder β]
 
 /- warning: rel_hom_class.map_sup -> RelHomClass.map_sup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {F : Type.{u3}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))))] (a : F) (m : β) (n : β), Eq.{succ u1} α (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a (Sup.sup.{u2} β (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (LinearOrder.toLattice.{u2} β _inst_2))) m n)) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a m) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a n))
+  forall {α : Type.{u1}} {β : Type.{u2}} {F : Type.{u3}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))))] (a : F) (m : β) (n : β), Eq.{succ u1} α (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a (Sup.sup.{u2} β (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (LinearOrder.toLattice.{u2} β _inst_2))) m n)) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a m) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a n))
 but is expected to have type
   forall {α : Type.{u3}} {β : Type.{u2}} {F : Type.{u1}} [_inst_1 : SemilatticeSup.{u3} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (x._@.Mathlib.Order.RelIso.Set._hyg.250 : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) x._@.Mathlib.Order.RelIso.Set._hyg.250 x._@.Mathlib.Order.RelIso.Set._hyg.252)] (a : F) (m : β) (n : β), Eq.{succ u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) (Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))) m n)) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.252) _inst_3) a (Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))) m n)) (Sup.sup.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) (SemilatticeSup.toSup.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) _inst_1) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.252) _inst_3) a m) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.252) _inst_3) a n))
 Case conversion may be inaccurate. Consider using '#align rel_hom_class.map_sup RelHomClass.map_supₓ'. -/

448144f7

bump to nightly-2023-04-20-10

mathlib commit https://github.com/leanprover-community/mathlib/commit/730c6d4cab72b9d84fcfb9e95e8796e9cd8f40ba

fbfe5c3e

Diff

@@ -65,7 +65,7 @@ namespace RelIso
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {r : α -> α -> Prop} {s : β -> β -> Prop} (e : RelIso.{u1, u2} α β r s), Eq.{succ u2} (Set.{u2} β) (Set.range.{u2, succ u1} β α (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RelIso.{u1, u2} α β r s) (fun (_x : RelIso.{u1, u2} α β r s) => α -> β) (RelIso.hasCoeToFun.{u1, u2} α β r s) e)) (Set.univ.{u2} β)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {r : α -> α -> Prop} {s : β -> β -> Prop} (e : RelIso.{u2, u1} α β r s), Eq.{succ u1} (Set.{u1} β) (Set.range.{u1, succ u2} β α (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Function.Embedding.{succ u2, succ u1} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : α) => β) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (Function.Embedding.{succ u2, succ u1} α β) α β (Function.instEmbeddingLikeEmbedding.{succ u2, succ u1} α β)) (RelEmbedding.toEmbedding.{u2, u1} α β r s (RelIso.toRelEmbedding.{u2, u1} α β r s e)))) (Set.univ.{u1} β)
+  forall {α : Type.{u2}} {β : Type.{u1}} {r : α -> α -> Prop} {s : β -> β -> Prop} (e : RelIso.{u2, u1} α β r s), Eq.{succ u1} (Set.{u1} β) (Set.range.{u1, succ u2} β α (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (RelIso.{u2, u1} α β r s) α (fun (_x : α) => β) (RelHomClass.toFunLike.{max u2 u1, u2, u1} (RelIso.{u2, u1} α β r s) α β r s (RelIso.instRelHomClassRelIso.{u2, u1} α β r s)) e)) (Set.univ.{u1} β)
 Case conversion may be inaccurate. Consider using '#align rel_iso.range_eq RelIso.range_eqₓ'. -/
 @[simp]
 theorem range_eq (e : r ≃r s) : Set.range e = Set.univ :=
@@ -101,7 +101,7 @@ protected def relEmbedding (r : α → α → Prop) (p : Set α) : Subrel r p 
 lean 3 declaration is
   forall {α : Type.{u1}} (r : α -> α -> Prop) (p : Set.{u1} α) (a : coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) p), Eq.{succ u1} α (coeFn.{succ u1, succ u1} (RelEmbedding.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) p) α (Subrel.{u1} α r p) r) (fun (_x : RelEmbedding.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) p) α (Subrel.{u1} α r p) r) => (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) p) -> α) (RelEmbedding.hasCoeToFun.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) p) α (Subrel.{u1} α r p) r) (Subrel.relEmbedding.{u1} α r p) a) (Subtype.val.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x p) a)
 but is expected to have type
-  forall {α : Type.{u1}} (r : α -> α -> Prop) (p : Set.{u1} α) (a : Set.Elem.{u1} α p), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Set.Elem.{u1} α p) => α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (Set.Elem.{u1} α p) α) (Set.Elem.{u1} α p) (fun (_x : Set.Elem.{u1} α p) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Set.Elem.{u1} α p) => α) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (Set.Elem.{u1} α p) α) (Set.Elem.{u1} α p) α (Function.instEmbeddingLikeEmbedding.{succ u1, succ u1} (Set.Elem.{u1} α p) α)) (RelEmbedding.toEmbedding.{u1, u1} (Set.Elem.{u1} α p) α (Subrel.{u1} α r p) r (Subrel.relEmbedding.{u1} α r p)) a) (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x p) a)
+  forall {α : Type.{u1}} (r : α -> α -> Prop) (p : Set.{u1} α) (a : Set.Elem.{u1} α p), Eq.{succ u1} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : Set.Elem.{u1} α p) => α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (RelEmbedding.{u1, u1} (Set.Elem.{u1} α p) α (Subrel.{u1} α r p) r) (Set.Elem.{u1} α p) (fun (_x : Set.Elem.{u1} α p) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : Set.Elem.{u1} α p) => α) _x) (RelHomClass.toFunLike.{u1, u1, u1} (RelEmbedding.{u1, u1} (Set.Elem.{u1} α p) α (Subrel.{u1} α r p) r) (Set.Elem.{u1} α p) α (Subrel.{u1} α r p) r (RelEmbedding.instRelHomClassRelEmbedding.{u1, u1} (Set.Elem.{u1} α p) α (Subrel.{u1} α r p) r)) (Subrel.relEmbedding.{u1} α r p) a) (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x p) a)
 Case conversion may be inaccurate. Consider using '#align subrel.rel_embedding_apply Subrel.relEmbedding_applyₓ'. -/
 @[simp]
 theorem relEmbedding_apply (r : α → α → Prop) (p a) : Subrel.relEmbedding r p a = a.1 :=
@@ -129,7 +129,7 @@ end Subrel
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {r : α -> α -> Prop} {s : β -> β -> Prop} (p : Set.{u2} β) (f : RelEmbedding.{u1, u2} α β r s), (forall (a : α), Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RelEmbedding.{u1, u2} α β r s) (fun (_x : RelEmbedding.{u1, u2} α β r s) => α -> β) (RelEmbedding.hasCoeToFun.{u1, u2} α β r s) f a) p) -> (RelEmbedding.{u1, u2} α (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) p) r (Subrel.{u2} β s p))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {r : α -> α -> Prop} {s : β -> β -> Prop} (p : Set.{u2} β) (f : RelEmbedding.{u1, u2} α β r s), (forall (a : α), Membership.mem.{u2, u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : α) => β) a) (Set.{u2} β) (Set.instMembershipSet.{u2} β) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Function.Embedding.{succ u1, succ u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : α) => β) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (Function.Embedding.{succ u1, succ u2} α β) α β (Function.instEmbeddingLikeEmbedding.{succ u1, succ u2} α β)) (RelEmbedding.toEmbedding.{u1, u2} α β r s f) a) p) -> (RelEmbedding.{u1, u2} α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p))
+  forall {α : Type.{u1}} {β : Type.{u2}} {r : α -> α -> Prop} {s : β -> β -> Prop} (p : Set.{u2} β) (f : RelEmbedding.{u1, u2} α β r s), (forall (a : α), Membership.mem.{u2, u2} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : α) => β) a) (Set.{u2} β) (Set.instMembershipSet.{u2} β) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelEmbedding.{u1, u2} α β r s) α (fun (_x : α) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : α) => β) _x) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelEmbedding.{u1, u2} α β r s) α β r s (RelEmbedding.instRelHomClassRelEmbedding.{u1, u2} α β r s)) f a) p) -> (RelEmbedding.{u1, u2} α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p))
 Case conversion may be inaccurate. Consider using '#align rel_embedding.cod_restrict RelEmbedding.codRestrictₓ'. -/
 /-- Restrict the codomain of a relation embedding. -/
 def RelEmbedding.codRestrict (p : Set β) (f : r ↪r s) (H : ∀ a, f a ∈ p) : r ↪r Subrel s p :=
@@ -140,7 +140,7 @@ def RelEmbedding.codRestrict (p : Set β) (f : r ↪r s) (H : ∀ a, f a ∈ p)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {r : α -> α -> Prop} {s : β -> β -> Prop} (p : Set.{u2} β) (f : RelEmbedding.{u1, u2} α β r s) (H : forall (a : α), Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RelEmbedding.{u1, u2} α β r s) (fun (_x : RelEmbedding.{u1, u2} α β r s) => α -> β) (RelEmbedding.hasCoeToFun.{u1, u2} α β r s) f a) p) (a : α), Eq.{succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) p) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RelEmbedding.{u1, u2} α (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) p) r (Subrel.{u2} β s p)) (fun (_x : RelEmbedding.{u1, u2} α (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) p) r (Subrel.{u2} β s p)) => α -> (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) p)) (RelEmbedding.hasCoeToFun.{u1, u2} α (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) p) r (Subrel.{u2} β s p)) (RelEmbedding.codRestrict.{u1, u2} α β r s p f H) a) (Subtype.mk.{succ u2} β (fun (x : β) => Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x p) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (RelEmbedding.{u1, u2} α β r s) (fun (_x : RelEmbedding.{u1, u2} α β r s) => α -> β) (RelEmbedding.hasCoeToFun.{u1, u2} α β r s) f a) (H a))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {r : α -> α -> Prop} {s : β -> β -> Prop} (p : Set.{u2} β) (f : RelEmbedding.{u1, u2} α β r s) (H : forall (a : α), Membership.mem.{u2, u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : α) => β) a) (Set.{u2} β) (Set.instMembershipSet.{u2} β) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Function.Embedding.{succ u1, succ u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : α) => β) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (Function.Embedding.{succ u1, succ u2} α β) α β (Function.instEmbeddingLikeEmbedding.{succ u1, succ u2} α β)) (RelEmbedding.toEmbedding.{u1, u2} α β r s f) a) p) (a : α), Eq.{succ u2} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : α) => Set.Elem.{u2} β p) a) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Function.Embedding.{succ u1, succ u2} α (Set.Elem.{u2} β p)) α (fun (_x : α) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : α) => Set.Elem.{u2} β p) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (Function.Embedding.{succ u1, succ u2} α (Set.Elem.{u2} β p)) α (Set.Elem.{u2} β p) (Function.instEmbeddingLikeEmbedding.{succ u1, succ u2} α (Set.Elem.{u2} β p))) (RelEmbedding.toEmbedding.{u1, u2} α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p) (RelEmbedding.codRestrict.{u1, u2} α β r s p f H)) a) (Subtype.mk.{succ u2} β (fun (x : β) => Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x p) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Function.Embedding.{succ u1, succ u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : α) => β) _x) (EmbeddingLike.toFunLike.{max (succ u1) (succ u2), succ u1, succ u2} (Function.Embedding.{succ u1, succ u2} α β) α β (Function.instEmbeddingLikeEmbedding.{succ u1, succ u2} α β)) (RelEmbedding.toEmbedding.{u1, u2} α β r s f) a) (H a))
+  forall {α : Type.{u1}} {β : Type.{u2}} {r : α -> α -> Prop} {s : β -> β -> Prop} (p : Set.{u2} β) (f : RelEmbedding.{u1, u2} α β r s) (H : forall (a : α), Membership.mem.{u2, u2} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : α) => β) a) (Set.{u2} β) (Set.instMembershipSet.{u2} β) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelEmbedding.{u1, u2} α β r s) α (fun (_x : α) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : α) => β) _x) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelEmbedding.{u1, u2} α β r s) α β r s (RelEmbedding.instRelHomClassRelEmbedding.{u1, u2} α β r s)) f a) p) (a : α), Eq.{succ u2} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : α) => Set.Elem.{u2} β p) a) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelEmbedding.{u1, u2} α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p)) α (fun (_x : α) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : α) => Set.Elem.{u2} β p) _x) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelEmbedding.{u1, u2} α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p)) α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p) (RelEmbedding.instRelHomClassRelEmbedding.{u1, u2} α (Set.Elem.{u2} β p) r (Subrel.{u2} β s p))) (RelEmbedding.codRestrict.{u1, u2} α β r s p f H) a) (Subtype.mk.{succ u2} β (fun (x : β) => Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x p) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (RelEmbedding.{u1, u2} α β r s) α (fun (_x : α) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : α) => β) _x) (RelHomClass.toFunLike.{max u1 u2, u1, u2} (RelEmbedding.{u1, u2} α β r s) α β r s (RelEmbedding.instRelHomClassRelEmbedding.{u1, u2} α β r s)) f a) (H a))
 Case conversion may be inaccurate. Consider using '#align rel_embedding.cod_restrict_apply RelEmbedding.codRestrict_applyₓ'. -/
 @[simp]
 theorem RelEmbedding.codRestrict_apply (p) (f : r ↪r s) (H a) :

448144f7

bump to nightly-2023-03-11-22

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

a8ee822f

Diff

@@ -49,7 +49,7 @@ theorem map_inf [SemilatticeInf α] [LinearOrder β]
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {F : Type.{u3}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))))] (a : F) (m : β) (n : β), Eq.{succ u1} α (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a (Sup.sup.{u2} β (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (LinearOrder.toLattice.{u2} β _inst_2))) m n)) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a m) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a n))
 but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {F : Type.{u1}} [_inst_1 : SemilatticeSup.{u3} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.225 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.227 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.225 x._@.Mathlib.Order.RelIso.Set._hyg.227) (fun (x._@.Mathlib.Order.RelIso.Set._hyg.247 : α) (x._@.Mathlib.Order.RelIso.Set._hyg.249 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) x._@.Mathlib.Order.RelIso.Set._hyg.247 x._@.Mathlib.Order.RelIso.Set._hyg.249)] (a : F) (m : β) (n : β), Eq.{succ u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) (Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))) m n)) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.225 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.227 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.225 x._@.Mathlib.Order.RelIso.Set._hyg.227) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.249 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.249) _inst_3) a (Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))) m n)) (Sup.sup.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) (SemilatticeSup.toSup.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) _inst_1) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.225 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.227 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.225 x._@.Mathlib.Order.RelIso.Set._hyg.227) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.249 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.249) _inst_3) a m) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.225 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.227 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.225 x._@.Mathlib.Order.RelIso.Set._hyg.227) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.249 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.249) _inst_3) a n))
+  forall {α : Type.{u3}} {β : Type.{u2}} {F : Type.{u1}} [_inst_1 : SemilatticeSup.{u3} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (x._@.Mathlib.Order.RelIso.Set._hyg.250 : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) x._@.Mathlib.Order.RelIso.Set._hyg.250 x._@.Mathlib.Order.RelIso.Set._hyg.252)] (a : F) (m : β) (n : β), Eq.{succ u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) (Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))) m n)) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.252) _inst_3) a (Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))) m n)) (Sup.sup.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) (SemilatticeSup.toSup.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) _inst_1) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.252) _inst_3) a m) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.228 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.230 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.228 x._@.Mathlib.Order.RelIso.Set._hyg.230) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.252 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.252) _inst_3) a n))
 Case conversion may be inaccurate. Consider using '#align rel_hom_class.map_sup RelHomClass.map_supₓ'. -/
 theorem map_sup [SemilatticeSup α] [LinearOrder β]
     [RelHomClass F ((· > ·) : β → β → Prop) ((· > ·) : α → α → Prop)] (a : F) (m n : β) :

448144f7

bump to nightly-2023-02-28-04

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

2097f8af

Diff

@@ -35,9 +35,9 @@ variable {F : Type _}
 
 /- warning: rel_hom_class.map_inf -> RelHomClass.map_inf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {F : Type.{u3}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))))] (a : F) (m : β) (n : β), Eq.{succ u1} α (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a (HasInf.inf.{u2} β (SemilatticeInf.toHasInf.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2))) m n)) (HasInf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a m) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a n))
+  forall {α : Type.{u1}} {β : Type.{u2}} {F : Type.{u3}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))))] (a : F) (m : β) (n : β), Eq.{succ u1} α (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a (Inf.inf.{u2} β (SemilatticeInf.toHasInf.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2))) m n)) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a m) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a n))
 but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {F : Type.{u1}} [_inst_1 : SemilatticeInf.{u3} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (x._@.Mathlib.Order.RelIso.Set._hyg.133 : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) x._@.Mathlib.Order.RelIso.Set._hyg.133 x._@.Mathlib.Order.RelIso.Set._hyg.135)] (a : F) (m : β) (n : β), Eq.{succ u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) (HasInf.inf.{u2} β (Lattice.toHasInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2))) m n)) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.135) _inst_3) a (HasInf.inf.{u2} β (Lattice.toHasInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2))) m n)) (HasInf.inf.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) (SemilatticeInf.toHasInf.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) _inst_1) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.135) _inst_3) a m) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.135) _inst_3) a n))
+  forall {α : Type.{u3}} {β : Type.{u2}} {F : Type.{u1}} [_inst_1 : SemilatticeInf.{u3} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (x._@.Mathlib.Order.RelIso.Set._hyg.133 : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) x._@.Mathlib.Order.RelIso.Set._hyg.133 x._@.Mathlib.Order.RelIso.Set._hyg.135)] (a : F) (m : β) (n : β), Eq.{succ u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) (Inf.inf.{u2} β (Lattice.toInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2))) m n)) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.135) _inst_3) a (Inf.inf.{u2} β (Lattice.toInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2))) m n)) (Inf.inf.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) (SemilatticeInf.toInf.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) _inst_1) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.135) _inst_3) a m) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.111 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.113 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.111 x._@.Mathlib.Order.RelIso.Set._hyg.113) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.135 : α) => LT.lt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeInf.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.135) _inst_3) a n))
 Case conversion may be inaccurate. Consider using '#align rel_hom_class.map_inf RelHomClass.map_infₓ'. -/
 theorem map_inf [SemilatticeInf α] [LinearOrder β]
     [RelHomClass F ((· < ·) : β → β → Prop) ((· < ·) : α → α → Prop)] (a : F) (m n : β) :
@@ -47,9 +47,9 @@ theorem map_inf [SemilatticeInf α] [LinearOrder β]
 
 /- warning: rel_hom_class.map_sup -> RelHomClass.map_sup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {F : Type.{u3}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))))] (a : F) (m : β) (n : β), Eq.{succ u1} α (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a (HasSup.sup.{u2} β (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (LinearOrder.toLattice.{u2} β _inst_2))) m n)) (HasSup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a m) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a n))
+  forall {α : Type.{u1}} {β : Type.{u2}} {F : Type.{u3}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))))] (a : F) (m : β) (n : β), Eq.{succ u1} α (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a (Sup.sup.{u2} β (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (LinearOrder.toLattice.{u2} β _inst_2))) m n)) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a m) (coeFn.{succ u3, max (succ u2) (succ u1)} F (fun (_x : F) => β -> α) (FunLike.hasCoeToFun.{succ u3, succ u2, succ u1} F β (fun (_x : β) => α) (RelHomClass.toFunLike.{u3, u2, u1} F β α (GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) (GT.gt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) _inst_3)) a n))
 but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {F : Type.{u1}} [_inst_1 : SemilatticeSup.{u3} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.225 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.227 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.225 x._@.Mathlib.Order.RelIso.Set._hyg.227) (fun (x._@.Mathlib.Order.RelIso.Set._hyg.247 : α) (x._@.Mathlib.Order.RelIso.Set._hyg.249 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) x._@.Mathlib.Order.RelIso.Set._hyg.247 x._@.Mathlib.Order.RelIso.Set._hyg.249)] (a : F) (m : β) (n : β), Eq.{succ u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) (HasSup.sup.{u2} β (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))) m n)) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.225 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.227 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.225 x._@.Mathlib.Order.RelIso.Set._hyg.227) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.249 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.249) _inst_3) a (HasSup.sup.{u2} β (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))) m n)) (HasSup.sup.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) (SemilatticeSup.toHasSup.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) _inst_1) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.225 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.227 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.225 x._@.Mathlib.Order.RelIso.Set._hyg.227) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.249 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.249) _inst_3) a m) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.225 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.227 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.225 x._@.Mathlib.Order.RelIso.Set._hyg.227) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.249 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.249) _inst_3) a n))
+  forall {α : Type.{u3}} {β : Type.{u2}} {F : Type.{u1}} [_inst_1 : SemilatticeSup.{u3} α] [_inst_2 : LinearOrder.{u2} β] [_inst_3 : RelHomClass.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.225 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.227 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.225 x._@.Mathlib.Order.RelIso.Set._hyg.227) (fun (x._@.Mathlib.Order.RelIso.Set._hyg.247 : α) (x._@.Mathlib.Order.RelIso.Set._hyg.249 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) x._@.Mathlib.Order.RelIso.Set._hyg.247 x._@.Mathlib.Order.RelIso.Set._hyg.249)] (a : F) (m : β) (n : β), Eq.{succ u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) (Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))) m n)) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.225 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.227 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.225 x._@.Mathlib.Order.RelIso.Set._hyg.227) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.249 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.249) _inst_3) a (Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))) m n)) (Sup.sup.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) (SemilatticeSup.toSup.{u3} ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) m) _inst_1) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.225 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.227 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.225 x._@.Mathlib.Order.RelIso.Set._hyg.227) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.249 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.249) _inst_3) a m) (FunLike.coe.{succ u1, succ u2, succ u3} F β (fun (_x : β) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.867 : β) => α) _x) (RelHomClass.toFunLike.{u1, u2, u3} F β α (fun (x._@.Mathlib.Order.RelIso.Set._hyg.225 : β) (x._@.Mathlib.Order.RelIso.Set._hyg.227 : β) => GT.gt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_2)))))) x._@.Mathlib.Order.RelIso.Set._hyg.225 x._@.Mathlib.Order.RelIso.Set._hyg.227) (fun (_x : α) (x._@.Mathlib.Order.RelIso.Set._hyg.249 : α) => GT.gt.{u3} α (Preorder.toLT.{u3} α (PartialOrder.toPreorder.{u3} α (SemilatticeSup.toPartialOrder.{u3} α _inst_1))) _x x._@.Mathlib.Order.RelIso.Set._hyg.249) _inst_3) a n))
 Case conversion may be inaccurate. Consider using '#align rel_hom_class.map_sup RelHomClass.map_supₓ'. -/
 theorem map_sup [SemilatticeSup α] [LinearOrder β]
     [RelHomClass F ((· > ·) : β → β → Prop) ((· > ·) : α → α → Prop)] (a : F) (m n : β) :

448144f7

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

ee0c179c

refactor(Data/FunLike): use unbundled inheritance from FunLike (#8386)

The FunLike hierarchy is very big and gets scanned through each time we need a coercion (via the CoeFun instance). It looks like unbundled inheritance suits Lean 4 better here. The only class that still extends FunLike is EquivLike, since that has a custom coe_injective' field that is easier to implement. All other classes should take FunLike or EquivLike as a parameter.

Zulip thread

Important changes

Previously, morphism classes would be Type-valued and extend FunLike:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  extends FunLike F A B :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

After this PR, they should be Prop-valued and take FunLike as a parameter:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  [FunLike F A B] : Prop :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

(Note that A B stay marked as outParam even though they are not purely required to be so due to the FunLike parameter already filling them in. This is required to see through type synonyms, which is important in the category theory library. Also, I think keeping them as outParam is slightly faster.)

Similarly, MyEquivClass should take EquivLike as a parameter.

As a result, every mention of [MyHomClass F A B] should become [FunLike F A B] [MyHomClass F A B].

Remaining issues

Slower (failing) search

While overall this gives some great speedups, there are some cases that are noticeably slower. In particular, a failing application of a lemma such as map_mul is more expensive. This is due to suboptimal processing of arguments. For example:

variable [FunLike F M N] [Mul M] [Mul N] (f : F) (x : M) (y : M)

theorem map_mul [MulHomClass F M N] : f (x * y) = f x * f y

example [AddHomClass F A B] : f (x * y) = f x * f y := map_mul f _ _

Before this PR, applying map_mul f gives the goals [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Since M and N are out_params, [MulHomClass F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found.

After this PR, the goals become [FunLike F ?M ?N] [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Now [FunLike F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found, before trying MulHomClass F M N which fails. Since the Mul hierarchy is very big, this can be slow to fail, especially when there is no such Mul instance.

A long-term but harder to achieve solution would be to specify the order in which instance goals get solved. For example, we'd like to change the arguments to map_mul to look like [FunLike F M N] [Mul M] [Mul N] [highPriority <| MulHomClass F M N] because MulHomClass fails or succeeds much faster than the others.

As a consequence, the simpNF linter is much slower since by design it tries and fails to apply many map_ lemmas. The same issue occurs a few times in existing calls to simp [map_mul], where map_mul is tried "too soon" and fails. Thanks to the speedup of leanprover/lean4#2478 the impact is very limited, only in files that already were close to the timeout.

`simp` not firing sometimes

This affects map_smulₛₗ and related definitions. For simp lemmas Lean apparently uses a slightly different mechanism to find instances, so that rw can find every argument to map_smulₛₗ successfully but simp can't: leanprover/lean4#3701.

Missing instances due to unification failing

Especially in the category theory library, we might sometimes have a type A which is also accessible as a synonym (Bundled A hA).1. Instance synthesis doesn't always work if we have f : A →* B but x * y : (Bundled A hA).1 or vice versa. This seems to be mostly fixed by keeping A B as outParams in MulHomClass F A B. (Presumably because Lean will do a definitional check A =?= (Bundled A hA).1 instead of using the syntax in the discrimination tree.)

Workaround for issues

The timeouts can be worked around for now by specifying which map_mul we mean, either as map_mul f for some explicit f, or as e.g. MonoidHomClass.map_mul.

map_smulₛₗ not firing as simp lemma can be worked around by going back to the pre-FunLike situation and making LinearMap.map_smulₛₗ a simp lemma instead of the generic map_smulₛₗ. Writing simp [map_smulₛₗ _] also works.

Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Scott Morrison <scott@tqft.net> Co-authored-by: Anne Baanen <Vierkantor@users.noreply.github.com>

c6a73d4f

Diff

@@ -27,16 +27,16 @@ namespace RelHomClass
 
 variable {F : Type*}
 
-theorem map_inf [SemilatticeInf α] [LinearOrder β]
-    [RelHomClass F ((· < ·) : β → β → Prop) ((· < ·) : α → α → Prop)] (a : F) (m n : β) :
+theorem map_inf [SemilatticeInf α] [LinearOrder β] [FunLike F β α]
+    [RelHomClass F (· < ·) (· < ·)] (a : F) (m n : β) :
     a (m ⊓ n) = a m ⊓ a n :=
   (StrictMono.monotone fun _ _ => map_rel a).map_inf m n
 #align rel_hom_class.map_inf RelHomClass.map_inf
 
-theorem map_sup [SemilatticeSup α] [LinearOrder β]
-    [RelHomClass F ((· > ·) : β → β → Prop) ((· > ·) : α → α → Prop)] (a : F) (m n : β) :
+theorem map_sup [SemilatticeSup α] [LinearOrder β] [FunLike F β α]
+    [RelHomClass F (· > ·) (· > ·)] (a : F) (m n : β) :
     a (m ⊔ n) = a m ⊔ a n :=
-  @map_inf αᵒᵈ βᵒᵈ _ _ _ _ _ _ _
+  map_inf (α := αᵒᵈ) (β := βᵒᵈ) _ _ _
 #align rel_hom_class.map_sup RelHomClass.map_sup
 
 end RelHomClass

ee0c179c

chore: cleanup a few porting notes and friends relating to alias (#6790)

After the new alias command we can now do protected alias
alias at some point broke dot notation by unfolding (see #1022) this was fixed in #1058 but the library was not fixed up there

45e55c3f

Diff

@@ -45,7 +45,7 @@ namespace RelIso
 
 @[simp]
 theorem range_eq (e : r ≃r s) : Set.range e = Set.univ :=
-  Function.Surjective.range_eq e.surjective
+  e.surjective.range_eq
 #align rel_iso.range_eq RelIso.range_eq
 
 end RelIso

ee0c179c

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

@@ -20,12 +20,12 @@ open Function
 
 universe u v w
 
-variable {α β γ δ : Type _} {r : α → α → Prop} {s : β → β → Prop} {t : γ → γ → Prop}
+variable {α β γ δ : Type*} {r : α → α → Prop} {s : β → β → Prop} {t : γ → γ → Prop}
   {u : δ → δ → Prop}
 
 namespace RelHomClass
 
-variable {F : Type _}
+variable {F : Type*}
 
 theorem map_inf [SemilatticeInf α] [LinearOrder β]
     [RelHomClass F ((· < ·) : β → β → Prop) ((· < ·) : α → α → Prop)] (a : F) (m n : β) :

ee0c179c

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2017 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro
-
-! This file was ported from Lean 3 source module order.rel_iso.set
-! leanprover-community/mathlib commit ee0c179cd3c8a45aa5bffbf1b41d8dbede452865
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.RelIso.Basic
 import Mathlib.Logic.Embedding.Set
 
+#align_import order.rel_iso.set from "leanprover-community/mathlib"@"ee0c179cd3c8a45aa5bffbf1b41d8dbede452865"
+
 /-!
 # Interactions between relation homomorphisms and sets

ee0c179c

chore: fix upper/lowercase in comments (#4360)

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

27d257fc

Diff

@@ -53,7 +53,7 @@ theorem range_eq (e : r ≃r s) : Set.range e = Set.univ :=
 
 end RelIso
 
-/-- `subrel r p` is the inherited relation on a subset. -/
+/-- `Subrel r p` is the inherited relation on a subset. -/
 def Subrel (r : α → α → Prop) (p : Set α) : p → p → Prop :=
   (Subtype.val : p → α) ⁻¹'o r
 #align subrel Subrel

ee0c179c

chore: add source headers to ported theory files (#1094)

The script used to do this is included. The yaml file was obtained from https://raw.githubusercontent.com/wiki/leanprover-community/mathlib/mathlib4-port-status.md

f168625e

Diff

@@ -2,6 +2,11 @@
 Copyright (c) 2017 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro
+
+! This file was ported from Lean 3 source module order.rel_iso.set
+! leanprover-community/mathlib commit ee0c179cd3c8a45aa5bffbf1b41d8dbede452865
+! Please do not edit these lines, except to modify the commit id
+! if you have ported upstream changes.
 -/
 import Mathlib.Order.RelIso.Basic
 import Mathlib.Logic.Embedding.Set

`order.rel_iso.set` ⟷ `Mathlib.Order.RelIso.Set`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Important changes

Remaining issues

Slower (failing) search

`simp` not firing sometimes

Missing instances due to unification failing

Workaround for issues

Dependencies 41

order.rel_iso.set ⟷ Mathlib.Order.RelIso.Set

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Important changes

Remaining issues

Slower (failing) search

simp not firing sometimes

Missing instances due to unification failing

Workaround for issues

Dependencies 41

`order.rel_iso.set` ⟷ `Mathlib.Order.RelIso.Set`

`simp` not firing sometimes