combinatorics.simple_graph.hasse | 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

8a38a697

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

f4758115

bump to nightly-2024-04-25-08

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

ad7a2212

Diff

@@ -56,7 +56,7 @@ theorem hasse_adj : (hasse α).Adj a b ↔ a ⋖ b ∨ b ⋖ a :=
 #print SimpleGraph.hasseDualIso /-
 /-- `αᵒᵈ` and `α` have the same Hasse diagram. -/
 def hasseDualIso : hasse αᵒᵈ ≃g hasse α :=
-  { ofDual with map_rel_iff' := fun a b => by simp [or_comm'] }
+  { ofDual with map_rel_iff' := fun a b => by simp [or_comm] }
 #align simple_graph.hasse_dual_iso SimpleGraph.hasseDualIso
 -/

f4758115

bump to nightly-2024-01-11-06

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

c7c71e9e

Diff

@@ -83,7 +83,7 @@ variable [PartialOrder α] [PartialOrder β]
 #print SimpleGraph.hasse_prod /-
 @[simp]
 theorem hasse_prod : hasse (α × β) = hasse α □ hasse β := by ext x y;
-  simp_rw [box_prod_adj, hasse_adj, Prod.covby_iff, or_and_right, @eq_comm _ y.1, @eq_comm _ y.2,
+  simp_rw [box_prod_adj, hasse_adj, Prod.covBy_iff, or_and_right, @eq_comm _ y.1, @eq_comm _ y.2,
     or_or_or_comm]
 #align simple_graph.hasse_prod SimpleGraph.hasse_prod
 -/

f4758115

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,9 +3,9 @@ Copyright (c) 2022 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
 -/
-import Mathbin.Combinatorics.SimpleGraph.Prod
-import Mathbin.Data.Fin.SuccPred
-import Mathbin.Order.SuccPred.Relation
+import Combinatorics.SimpleGraph.Prod
+import Data.Fin.SuccPred
+import Order.SuccPred.Relation
 
 #align_import combinatorics.simple_graph.hasse from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"

f4758115

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,16 +2,13 @@
 Copyright (c) 2022 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
-
-! This file was ported from Lean 3 source module combinatorics.simple_graph.hasse
-! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Combinatorics.SimpleGraph.Prod
 import Mathbin.Data.Fin.SuccPred
 import Mathbin.Order.SuccPred.Relation
 
+#align_import combinatorics.simple_graph.hasse from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"
+
 /-!
 # The Hasse diagram as a graph

f4758115

bump to nightly-2023-06-20-01

mathlib commit https://github.com/leanprover-community/mathlib/commit/2a0ce625dbb0ffbc7d1316597de0b25c1ec75303

9b351f8c

Diff

@@ -85,7 +85,7 @@ variable [PartialOrder α] [PartialOrder β]
 
 #print SimpleGraph.hasse_prod /-
 @[simp]
-theorem hasse_prod : hasse (α × β) = hasse α □ hasse β := by ext (x y);
+theorem hasse_prod : hasse (α × β) = hasse α □ hasse β := by ext x y;
   simp_rw [box_prod_adj, hasse_adj, Prod.covby_iff, or_and_right, @eq_comm _ y.1, @eq_comm _ y.2,
     or_or_or_comm]
 #align simple_graph.hasse_prod SimpleGraph.hasse_prod

f4758115

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -63,15 +63,19 @@ def hasseDualIso : hasse αᵒᵈ ≃g hasse α :=
 #align simple_graph.hasse_dual_iso SimpleGraph.hasseDualIso
 -/
 
+#print SimpleGraph.hasseDualIso_apply /-
 @[simp]
 theorem hasseDualIso_apply (a : αᵒᵈ) : hasseDualIso a = ofDual a :=
   rfl
 #align simple_graph.hasse_dual_iso_apply SimpleGraph.hasseDualIso_apply
+-/
 
+#print SimpleGraph.hasseDualIso_symm_apply /-
 @[simp]
 theorem hasseDualIso_symm_apply (a : α) : hasseDualIso.symm a = toDual a :=
   rfl
 #align simple_graph.hasse_dual_iso_symm_apply SimpleGraph.hasseDualIso_symm_apply
+-/
 
 end Preorder
 
@@ -79,11 +83,13 @@ section PartialOrder
 
 variable [PartialOrder α] [PartialOrder β]
 
+#print SimpleGraph.hasse_prod /-
 @[simp]
 theorem hasse_prod : hasse (α × β) = hasse α □ hasse β := by ext (x y);
   simp_rw [box_prod_adj, hasse_adj, Prod.covby_iff, or_and_right, @eq_comm _ y.1, @eq_comm _ y.2,
     or_or_or_comm]
 #align simple_graph.hasse_prod SimpleGraph.hasse_prod
+-/
 
 end PartialOrder

f4758115

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -49,10 +49,12 @@ def hasse : SimpleGraph α where
 
 variable {α β} {a b : α}
 
+#print SimpleGraph.hasse_adj /-
 @[simp]
 theorem hasse_adj : (hasse α).Adj a b ↔ a ⋖ b ∨ b ⋖ a :=
   Iff.rfl
 #align simple_graph.hasse_adj SimpleGraph.hasse_adj
+-/
 
 #print SimpleGraph.hasseDualIso /-
 /-- `αᵒᵈ` and `α` have the same Hasse diagram. -/

f4758115

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -49,12 +49,6 @@ def hasse : SimpleGraph α where
 
 variable {α β} {a b : α}
 
-/- warning: simple_graph.hasse_adj -> SimpleGraph.hasse_adj is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, Iff (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1) a b) (Or (Covby.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b) (Covby.{u1} α (Preorder.toHasLt.{u1} α _inst_1) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, Iff (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1) a b) (Or (Covby.{u1} α (Preorder.toLT.{u1} α _inst_1) a b) (Covby.{u1} α (Preorder.toLT.{u1} α _inst_1) b a))
-Case conversion may be inaccurate. Consider using '#align simple_graph.hasse_adj SimpleGraph.hasse_adjₓ'. -/
 @[simp]
 theorem hasse_adj : (hasse α).Adj a b ↔ a ⋖ b ∨ b ⋖ a :=
   Iff.rfl
@@ -67,23 +61,11 @@ def hasseDualIso : hasse αᵒᵈ ≃g hasse α :=
 #align simple_graph.hasse_dual_iso SimpleGraph.hasseDualIso
 -/
 
-/- warning: simple_graph.hasse_dual_iso_apply -> SimpleGraph.hasseDualIso_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : OrderDual.{u1} α), Eq.{succ u1} α (coeFn.{succ u1, succ u1} (SimpleGraph.Iso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u1} α _inst_1)) (fun (_x : RelIso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1))) => (OrderDual.{u1} α) -> α) (RelIso.hasCoeToFun.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1))) (SimpleGraph.hasseDualIso.{u1} α _inst_1) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) => (OrderDual.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : OrderDual.{u1} α), Eq.{succ u1} α (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1))) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => α) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1))) (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (RelIso.instRelHomClassRelIso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)))) (SimpleGraph.hasseDualIso.{u1} α _inst_1) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) a)
-Case conversion may be inaccurate. Consider using '#align simple_graph.hasse_dual_iso_apply SimpleGraph.hasseDualIso_applyₓ'. -/
 @[simp]
 theorem hasseDualIso_apply (a : αᵒᵈ) : hasseDualIso a = ofDual a :=
   rfl
 #align simple_graph.hasse_dual_iso_apply SimpleGraph.hasseDualIso_apply
 
-/- warning: simple_graph.hasse_dual_iso_symm_apply -> SimpleGraph.hasseDualIso_symm_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : α), Eq.{succ u1} (OrderDual.{u1} α) (coeFn.{succ u1, succ u1} (SimpleGraph.Iso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} α _inst_1) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (fun (_x : RelIso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)))) => α -> (OrderDual.{u1} α)) (RelIso.hasCoeToFun.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)))) (SimpleGraph.Iso.symm.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u1} α _inst_1) (SimpleGraph.hasseDualIso.{u1} α _inst_1)) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) => α -> (OrderDual.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : α), Eq.{succ u1} (OrderDual.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)))) α (fun (_x : α) => OrderDual.{u1} α) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)))) α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (RelIso.instRelHomClassRelIso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))))) (SimpleGraph.Iso.symm.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u1} α _inst_1) (SimpleGraph.hasseDualIso.{u1} α _inst_1)) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) a)
-Case conversion may be inaccurate. Consider using '#align simple_graph.hasse_dual_iso_symm_apply SimpleGraph.hasseDualIso_symm_applyₓ'. -/
 @[simp]
 theorem hasseDualIso_symm_apply (a : α) : hasseDualIso.symm a = toDual a :=
   rfl
@@ -95,12 +77,6 @@ section PartialOrder
 
 variable [PartialOrder α] [PartialOrder β]
 
-/- warning: simple_graph.hasse_prod -> SimpleGraph.hasse_prod is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) (β : Type.{u2}) [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PartialOrder.{u2} β], Eq.{succ (max u1 u2)} (SimpleGraph.{max u1 u2} (Prod.{u1, u2} α β)) (SimpleGraph.hasse.{max u1 u2} (Prod.{u1, u2} α β) (Prod.preorder.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2))) (SimpleGraph.boxProd.{u1, u2} α β (SimpleGraph.hasse.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)))
-but is expected to have type
-  forall (α : Type.{u2}) (β : Type.{u1}) [_inst_1 : PartialOrder.{u2} α] [_inst_2 : PartialOrder.{u1} β], Eq.{max (succ u2) (succ u1)} (SimpleGraph.{max u1 u2} (Prod.{u2, u1} α β)) (SimpleGraph.hasse.{max u1 u2} (Prod.{u2, u1} α β) (Prod.instPreorderProd.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) (PartialOrder.toPreorder.{u1} β _inst_2))) (SimpleGraph.boxProd.{u2, u1} α β (SimpleGraph.hasse.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (SimpleGraph.hasse.{u1} β (PartialOrder.toPreorder.{u1} β _inst_2)))
-Case conversion may be inaccurate. Consider using '#align simple_graph.hasse_prod SimpleGraph.hasse_prodₓ'. -/
 @[simp]
 theorem hasse_prod : hasse (α × β) = hasse α □ hasse β := by ext (x y);
   simp_rw [box_prod_adj, hasse_adj, Prod.covby_iff, or_and_right, @eq_comm _ y.1, @eq_comm _ y.2,

f4758115

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -102,9 +102,7 @@ but is expected to have type
   forall (α : Type.{u2}) (β : Type.{u1}) [_inst_1 : PartialOrder.{u2} α] [_inst_2 : PartialOrder.{u1} β], Eq.{max (succ u2) (succ u1)} (SimpleGraph.{max u1 u2} (Prod.{u2, u1} α β)) (SimpleGraph.hasse.{max u1 u2} (Prod.{u2, u1} α β) (Prod.instPreorderProd.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) (PartialOrder.toPreorder.{u1} β _inst_2))) (SimpleGraph.boxProd.{u2, u1} α β (SimpleGraph.hasse.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (SimpleGraph.hasse.{u1} β (PartialOrder.toPreorder.{u1} β _inst_2)))
 Case conversion may be inaccurate. Consider using '#align simple_graph.hasse_prod SimpleGraph.hasse_prodₓ'. -/
 @[simp]
-theorem hasse_prod : hasse (α × β) = hasse α □ hasse β :=
-  by
-  ext (x y)
+theorem hasse_prod : hasse (α × β) = hasse α □ hasse β := by ext (x y);
   simp_rw [box_prod_adj, hasse_adj, Prod.covby_iff, or_and_right, @eq_comm _ y.1, @eq_comm _ y.2,
     or_or_or_comm]
 #align simple_graph.hasse_prod SimpleGraph.hasse_prod

f4758115

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -71,7 +71,7 @@ def hasseDualIso : hasse αᵒᵈ ≃g hasse α :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : OrderDual.{u1} α), Eq.{succ u1} α (coeFn.{succ u1, succ u1} (SimpleGraph.Iso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u1} α _inst_1)) (fun (_x : RelIso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1))) => (OrderDual.{u1} α) -> α) (RelIso.hasCoeToFun.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1))) (SimpleGraph.hasseDualIso.{u1} α _inst_1) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) => (OrderDual.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : OrderDual.{u1} α), Eq.{succ u1} α (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1))) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => α) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1))) (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (RelIso.instRelHomClassRelIso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)))) (SimpleGraph.hasseDualIso.{u1} α _inst_1) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) a)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : OrderDual.{u1} α), Eq.{succ u1} α (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1))) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => α) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1))) (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (RelIso.instRelHomClassRelIso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)))) (SimpleGraph.hasseDualIso.{u1} α _inst_1) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) a)
 Case conversion may be inaccurate. Consider using '#align simple_graph.hasse_dual_iso_apply SimpleGraph.hasseDualIso_applyₓ'. -/
 @[simp]
 theorem hasseDualIso_apply (a : αᵒᵈ) : hasseDualIso a = ofDual a :=
@@ -82,7 +82,7 @@ theorem hasseDualIso_apply (a : αᵒᵈ) : hasseDualIso a = ofDual a :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : α), Eq.{succ u1} (OrderDual.{u1} α) (coeFn.{succ u1, succ u1} (SimpleGraph.Iso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} α _inst_1) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (fun (_x : RelIso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)))) => α -> (OrderDual.{u1} α)) (RelIso.hasCoeToFun.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)))) (SimpleGraph.Iso.symm.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u1} α _inst_1) (SimpleGraph.hasseDualIso.{u1} α _inst_1)) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) => α -> (OrderDual.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : α), Eq.{succ u1} (OrderDual.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)))) α (fun (_x : α) => OrderDual.{u1} α) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)))) α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (RelIso.instRelHomClassRelIso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))))) (SimpleGraph.Iso.symm.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u1} α _inst_1) (SimpleGraph.hasseDualIso.{u1} α _inst_1)) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) a)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : α), Eq.{succ u1} (OrderDual.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)))) α (fun (_x : α) => OrderDual.{u1} α) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)))) α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (RelIso.instRelHomClassRelIso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))))) (SimpleGraph.Iso.symm.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u1} α _inst_1) (SimpleGraph.hasseDualIso.{u1} α _inst_1)) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) a)
 Case conversion may be inaccurate. Consider using '#align simple_graph.hasse_dual_iso_symm_apply SimpleGraph.hasseDualIso_symm_applyₓ'. -/
 @[simp]
 theorem hasseDualIso_symm_apply (a : α) : hasseDualIso.symm a = toDual a :=

f4758115

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -49,12 +49,16 @@ def hasse : SimpleGraph α where
 
 variable {α β} {a b : α}
 
-#print SimpleGraph.hasse_adj /-
+/- warning: simple_graph.hasse_adj -> SimpleGraph.hasse_adj is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, Iff (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1) a b) (Or (Covby.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b) (Covby.{u1} α (Preorder.toHasLt.{u1} α _inst_1) b a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, Iff (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1) a b) (Or (Covby.{u1} α (Preorder.toLT.{u1} α _inst_1) a b) (Covby.{u1} α (Preorder.toLT.{u1} α _inst_1) b a))
+Case conversion may be inaccurate. Consider using '#align simple_graph.hasse_adj SimpleGraph.hasse_adjₓ'. -/
 @[simp]
 theorem hasse_adj : (hasse α).Adj a b ↔ a ⋖ b ∨ b ⋖ a :=
   Iff.rfl
 #align simple_graph.hasse_adj SimpleGraph.hasse_adj
--/
 
 #print SimpleGraph.hasseDualIso /-
 /-- `αᵒᵈ` and `α` have the same Hasse diagram. -/

f4758115

bump to nightly-2023-04-20-10

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

fbfe5c3e

Diff

@@ -67,7 +67,7 @@ def hasseDualIso : hasse αᵒᵈ ≃g hasse α :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : OrderDual.{u1} α), Eq.{succ u1} α (coeFn.{succ u1, succ u1} (SimpleGraph.Iso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u1} α _inst_1)) (fun (_x : RelIso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1))) => (OrderDual.{u1} α) -> α) (RelIso.hasCoeToFun.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1))) (SimpleGraph.hasseDualIso.{u1} α _inst_1) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) => (OrderDual.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : OrderDual.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : OrderDual.{u1} α) => α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : OrderDual.{u1} α) => α) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) α (Function.instEmbeddingLikeEmbedding.{succ u1, succ u1} (OrderDual.{u1} α) α)) (RelEmbedding.toEmbedding.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (RelIso.toRelEmbedding.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.hasseDualIso.{u1} α _inst_1))) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) a)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : OrderDual.{u1} α), Eq.{succ u1} α (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1))) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => α) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1))) (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (RelIso.instRelHomClassRelIso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)))) (SimpleGraph.hasseDualIso.{u1} α _inst_1) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) a)
 Case conversion may be inaccurate. Consider using '#align simple_graph.hasse_dual_iso_apply SimpleGraph.hasseDualIso_applyₓ'. -/
 @[simp]
 theorem hasseDualIso_apply (a : αᵒᵈ) : hasseDualIso a = ofDual a :=
@@ -78,7 +78,7 @@ theorem hasseDualIso_apply (a : αᵒᵈ) : hasseDualIso a = ofDual a :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : α), Eq.{succ u1} (OrderDual.{u1} α) (coeFn.{succ u1, succ u1} (SimpleGraph.Iso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} α _inst_1) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (fun (_x : RelIso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)))) => α -> (OrderDual.{u1} α)) (RelIso.hasCoeToFun.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)))) (SimpleGraph.Iso.symm.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u1} α _inst_1) (SimpleGraph.hasseDualIso.{u1} α _inst_1)) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) => α -> (OrderDual.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : α), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : α) => OrderDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : α) => OrderDual.{u1} α) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} α (OrderDual.{u1} α)) α (OrderDual.{u1} α) (Function.instEmbeddingLikeEmbedding.{succ u1, succ u1} α (OrderDual.{u1} α))) (RelEmbedding.toEmbedding.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (RelIso.toRelEmbedding.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Iso.symm.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u1} α _inst_1) (SimpleGraph.hasseDualIso.{u1} α _inst_1)))) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) a)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : α), Eq.{succ u1} (OrderDual.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)))) α (fun (_x : α) => OrderDual.{u1} α) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)))) α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (RelIso.instRelHomClassRelIso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))))) (SimpleGraph.Iso.symm.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u1} α _inst_1) (SimpleGraph.hasseDualIso.{u1} α _inst_1)) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) a)
 Case conversion may be inaccurate. Consider using '#align simple_graph.hasse_dual_iso_symm_apply SimpleGraph.hasseDualIso_symm_applyₓ'. -/
 @[simp]
 theorem hasseDualIso_symm_apply (a : α) : hasseDualIso.symm a = toDual a :=

f4758115

bump to nightly-2023-03-11-22

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

a8ee822f

Diff

@@ -67,7 +67,7 @@ def hasseDualIso : hasse αᵒᵈ ≃g hasse α :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : OrderDual.{u1} α), Eq.{succ u1} α (coeFn.{succ u1, succ u1} (SimpleGraph.Iso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u1} α _inst_1)) (fun (_x : RelIso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1))) => (OrderDual.{u1} α) -> α) (RelIso.hasCoeToFun.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1))) (SimpleGraph.hasseDualIso.{u1} α _inst_1) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) => (OrderDual.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : OrderDual.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : OrderDual.{u1} α) => α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : OrderDual.{u1} α) => α) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) α (Function.instEmbeddingLikeEmbedding.{succ u1, succ u1} (OrderDual.{u1} α) α)) (RelEmbedding.toEmbedding.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (RelIso.toRelEmbedding.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.hasseDualIso.{u1} α _inst_1))) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) a)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : OrderDual.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : OrderDual.{u1} α) => α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : OrderDual.{u1} α) => α) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) α (Function.instEmbeddingLikeEmbedding.{succ u1, succ u1} (OrderDual.{u1} α) α)) (RelEmbedding.toEmbedding.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (RelIso.toRelEmbedding.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.hasseDualIso.{u1} α _inst_1))) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) a)
 Case conversion may be inaccurate. Consider using '#align simple_graph.hasse_dual_iso_apply SimpleGraph.hasseDualIso_applyₓ'. -/
 @[simp]
 theorem hasseDualIso_apply (a : αᵒᵈ) : hasseDualIso a = ofDual a :=
@@ -78,7 +78,7 @@ theorem hasseDualIso_apply (a : αᵒᵈ) : hasseDualIso a = ofDual a :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : α), Eq.{succ u1} (OrderDual.{u1} α) (coeFn.{succ u1, succ u1} (SimpleGraph.Iso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} α _inst_1) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (fun (_x : RelIso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)))) => α -> (OrderDual.{u1} α)) (RelIso.hasCoeToFun.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)))) (SimpleGraph.Iso.symm.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u1} α _inst_1) (SimpleGraph.hasseDualIso.{u1} α _inst_1)) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) => α -> (OrderDual.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : α), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : α) => OrderDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : α) => OrderDual.{u1} α) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} α (OrderDual.{u1} α)) α (OrderDual.{u1} α) (Function.instEmbeddingLikeEmbedding.{succ u1, succ u1} α (OrderDual.{u1} α))) (RelEmbedding.toEmbedding.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (RelIso.toRelEmbedding.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Iso.symm.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u1} α _inst_1) (SimpleGraph.hasseDualIso.{u1} α _inst_1)))) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) a)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : α), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : α) => OrderDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : α) => OrderDual.{u1} α) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} α (OrderDual.{u1} α)) α (OrderDual.{u1} α) (Function.instEmbeddingLikeEmbedding.{succ u1, succ u1} α (OrderDual.{u1} α))) (RelEmbedding.toEmbedding.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (RelIso.toRelEmbedding.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Iso.symm.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u1} α _inst_1) (SimpleGraph.hasseDualIso.{u1} α _inst_1)))) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) a)
 Case conversion may be inaccurate. Consider using '#align simple_graph.hasse_dual_iso_symm_apply SimpleGraph.hasseDualIso_symm_applyₓ'. -/
 @[simp]
 theorem hasseDualIso_symm_apply (a : α) : hasseDualIso.symm a = toDual a :=

f4758115

bump to nightly-2023-03-09-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/21e3562c5e12d846c7def5eff8cdbc520d7d4936

061741a1

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
 
 ! This file was ported from Lean 3 source module combinatorics.simple_graph.hasse
-! leanprover-community/mathlib commit 8a38a697305292b37a61650e2c3bd3502d98c805
+! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -15,6 +15,9 @@ import Mathbin.Order.SuccPred.Relation
 /-!
 # The Hasse diagram as a graph
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 This file defines the Hasse diagram of an order (graph of `covby`, the covering relation) and the
 path graph on `n` vertices.

8a38a697

bump to nightly-2023-03-06-08

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

607fb806

Diff

@@ -35,30 +35,48 @@ section Preorder
 
 variable [Preorder α] [Preorder β]
 
+#print SimpleGraph.hasse /-
 /-- The Hasse diagram of an order as a simple graph. The graph of the covering relation. -/
 def hasse : SimpleGraph α where
   Adj a b := a ⋖ b ∨ b ⋖ a
   symm a b := Or.symm
   loopless a h := h.elim (irrefl _) (irrefl _)
 #align simple_graph.hasse SimpleGraph.hasse
+-/
 
 variable {α β} {a b : α}
 
+#print SimpleGraph.hasse_adj /-
 @[simp]
 theorem hasse_adj : (hasse α).Adj a b ↔ a ⋖ b ∨ b ⋖ a :=
   Iff.rfl
 #align simple_graph.hasse_adj SimpleGraph.hasse_adj
+-/
 
+#print SimpleGraph.hasseDualIso /-
 /-- `αᵒᵈ` and `α` have the same Hasse diagram. -/
 def hasseDualIso : hasse αᵒᵈ ≃g hasse α :=
   { ofDual with map_rel_iff' := fun a b => by simp [or_comm'] }
 #align simple_graph.hasse_dual_iso SimpleGraph.hasseDualIso
+-/
 
+/- warning: simple_graph.hasse_dual_iso_apply -> SimpleGraph.hasseDualIso_apply is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : OrderDual.{u1} α), Eq.{succ u1} α (coeFn.{succ u1, succ u1} (SimpleGraph.Iso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u1} α _inst_1)) (fun (_x : RelIso.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1))) => (OrderDual.{u1} α) -> α) (RelIso.hasCoeToFun.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1))) (SimpleGraph.hasseDualIso.{u1} α _inst_1) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) => (OrderDual.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : OrderDual.{u1} α), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : OrderDual.{u1} α) => α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : OrderDual.{u1} α) => α) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) α (Function.instEmbeddingLikeEmbedding.{succ u1, succ u1} (OrderDual.{u1} α) α)) (RelEmbedding.toEmbedding.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (RelIso.toRelEmbedding.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.hasseDualIso.{u1} α _inst_1))) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) a)
+Case conversion may be inaccurate. Consider using '#align simple_graph.hasse_dual_iso_apply SimpleGraph.hasseDualIso_applyₓ'. -/
 @[simp]
 theorem hasseDualIso_apply (a : αᵒᵈ) : hasseDualIso a = ofDual a :=
   rfl
 #align simple_graph.hasse_dual_iso_apply SimpleGraph.hasseDualIso_apply
 
+/- warning: simple_graph.hasse_dual_iso_symm_apply -> SimpleGraph.hasseDualIso_symm_apply is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : α), Eq.{succ u1} (OrderDual.{u1} α) (coeFn.{succ u1, succ u1} (SimpleGraph.Iso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} α _inst_1) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (fun (_x : RelIso.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)))) => α -> (OrderDual.{u1} α)) (RelIso.hasCoeToFun.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)))) (SimpleGraph.Iso.symm.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u1} α _inst_1) (SimpleGraph.hasseDualIso.{u1} α _inst_1)) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) => α -> (OrderDual.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : α), Eq.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : α) => OrderDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : α) => OrderDual.{u1} α) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} α (OrderDual.{u1} α)) α (OrderDual.{u1} α) (Function.instEmbeddingLikeEmbedding.{succ u1, succ u1} α (OrderDual.{u1} α))) (RelEmbedding.toEmbedding.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (RelIso.toRelEmbedding.{u1, u1} α (OrderDual.{u1} α) (SimpleGraph.Adj.{u1} α (SimpleGraph.hasse.{u1} α _inst_1)) (SimpleGraph.Adj.{u1} (OrderDual.{u1} α) (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1))) (SimpleGraph.Iso.symm.{u1, u1} (OrderDual.{u1} α) α (SimpleGraph.hasse.{u1} (OrderDual.{u1} α) (OrderDual.preorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u1} α _inst_1) (SimpleGraph.hasseDualIso.{u1} α _inst_1)))) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) a)
+Case conversion may be inaccurate. Consider using '#align simple_graph.hasse_dual_iso_symm_apply SimpleGraph.hasseDualIso_symm_applyₓ'. -/
 @[simp]
 theorem hasseDualIso_symm_apply (a : α) : hasseDualIso.symm a = toDual a :=
   rfl
@@ -70,6 +88,12 @@ section PartialOrder
 
 variable [PartialOrder α] [PartialOrder β]
 
+/- warning: simple_graph.hasse_prod -> SimpleGraph.hasse_prod is a dubious translation:
+lean 3 declaration is
+  forall (α : Type.{u1}) (β : Type.{u2}) [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PartialOrder.{u2} β], Eq.{succ (max u1 u2)} (SimpleGraph.{max u1 u2} (Prod.{u1, u2} α β)) (SimpleGraph.hasse.{max u1 u2} (Prod.{u1, u2} α β) (Prod.preorder.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2))) (SimpleGraph.boxProd.{u1, u2} α β (SimpleGraph.hasse.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (SimpleGraph.hasse.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)))
+but is expected to have type
+  forall (α : Type.{u2}) (β : Type.{u1}) [_inst_1 : PartialOrder.{u2} α] [_inst_2 : PartialOrder.{u1} β], Eq.{max (succ u2) (succ u1)} (SimpleGraph.{max u1 u2} (Prod.{u2, u1} α β)) (SimpleGraph.hasse.{max u1 u2} (Prod.{u2, u1} α β) (Prod.instPreorderProd.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) (PartialOrder.toPreorder.{u1} β _inst_2))) (SimpleGraph.boxProd.{u2, u1} α β (SimpleGraph.hasse.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (SimpleGraph.hasse.{u1} β (PartialOrder.toPreorder.{u1} β _inst_2)))
+Case conversion may be inaccurate. Consider using '#align simple_graph.hasse_prod SimpleGraph.hasse_prodₓ'. -/
 @[simp]
 theorem hasse_prod : hasse (α × β) = hasse α □ hasse β :=
   by
@@ -84,6 +108,7 @@ section LinearOrder
 
 variable [LinearOrder α]
 
+#print SimpleGraph.hasse_preconnected_of_succ /-
 theorem hasse_preconnected_of_succ [SuccOrder α] [IsSuccArchimedean α] : (hasse α).Preconnected :=
   fun a b => by
   rw [reachable_iff_refl_trans_gen]
@@ -91,7 +116,9 @@ theorem hasse_preconnected_of_succ [SuccOrder α] [IsSuccArchimedean α] : (hass
     reflTransGen_of_succ _ (fun c hc => Or.inl <| covby_succ_of_not_is_max hc.2.not_isMax)
       fun c hc => Or.inr <| covby_succ_of_not_is_max hc.2.not_isMax
 #align simple_graph.hasse_preconnected_of_succ SimpleGraph.hasse_preconnected_of_succ
+-/
 
+#print SimpleGraph.hasse_preconnected_of_pred /-
 theorem hasse_preconnected_of_pred [PredOrder α] [IsPredArchimedean α] : (hasse α).Preconnected :=
   fun a b => by
   rw [reachable_iff_refl_trans_gen, ← refl_trans_gen_swap]
@@ -99,21 +126,28 @@ theorem hasse_preconnected_of_pred [PredOrder α] [IsPredArchimedean α] : (hass
     reflTransGen_of_pred _ (fun c hc => Or.inl <| pred_covby_of_not_is_min hc.1.not_isMin)
       fun c hc => Or.inr <| pred_covby_of_not_is_min hc.1.not_isMin
 #align simple_graph.hasse_preconnected_of_pred SimpleGraph.hasse_preconnected_of_pred
+-/
 
 end LinearOrder
 
+#print SimpleGraph.pathGraph /-
 /-- The path graph on `n` vertices. -/
 def pathGraph (n : ℕ) : SimpleGraph (Fin n) :=
   hasse _
 #align simple_graph.path_graph SimpleGraph.pathGraph
+-/
 
+#print SimpleGraph.pathGraph_preconnected /-
 theorem pathGraph_preconnected (n : ℕ) : (pathGraph n).Preconnected :=
   hasse_preconnected_of_succ _
 #align simple_graph.path_graph_preconnected SimpleGraph.pathGraph_preconnected
+-/
 
+#print SimpleGraph.pathGraph_connected /-
 theorem pathGraph_connected (n : ℕ) : (pathGraph (n + 1)).Connected :=
   ⟨pathGraph_preconnected _⟩
 #align simple_graph.path_graph_connected SimpleGraph.pathGraph_connected
+-/
 
 end SimpleGraph

8a38a697

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

8a38a697

chore: reduce imports (#9830)

This uses the improved shake script from #9772 to reduce imports across mathlib. The corresponding noshake.json file has been added to #9772.

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

f4c4ca61

Diff

@@ -5,8 +5,9 @@ Authors: Yaël Dillies
 -/
 import Mathlib.Combinatorics.SimpleGraph.Prod
 import Mathlib.Data.Fin.SuccPred
-import Mathlib.Data.ZMod.Basic
+import Mathlib.Data.Nat.SuccPred
 import Mathlib.Order.SuccPred.Relation
+import Mathlib.Tactic.FinCases
 
 #align_import combinatorics.simple_graph.hasse from "leanprover-community/mathlib"@"8a38a697305292b37a61650e2c3bd3502d98c805"

8a38a697

chore(Covby): rename Covby to CovBy (#9578)

Rename

Covby → CovBy, Wcovby → WCovBy
*covby* → *covBy*
wcovby.finset_val → WCovBy.finset_val, wcovby.finset_coe → WCovBy.finset_coe
Covby.is_coatom → CovBy.isCoatom

8b47b2fc

Diff

@@ -13,7 +13,7 @@ import Mathlib.Order.SuccPred.Relation
 /-!
 # The Hasse diagram as a graph
 
-This file defines the Hasse diagram of an order (graph of `Covby`, the covering relation) and the
+This file defines the Hasse diagram of an order (graph of `CovBy`, the covering relation) and the
 path graph on `n` vertices.
 
 ## Main declarations
@@ -71,7 +71,7 @@ variable [PartialOrder α] [PartialOrder β]
 @[simp]
 theorem hasse_prod : hasse (α × β) = hasse α □ hasse β := by
   ext x y
-  simp_rw [boxProd_adj, hasse_adj, Prod.covby_iff, or_and_right, @eq_comm _ y.1, @eq_comm _ y.2,
+  simp_rw [boxProd_adj, hasse_adj, Prod.covBy_iff, or_and_right, @eq_comm _ y.1, @eq_comm _ y.2,
     or_or_or_comm]
 #align simple_graph.hasse_prod SimpleGraph.hasse_prod
 
@@ -85,16 +85,16 @@ theorem hasse_preconnected_of_succ [SuccOrder α] [IsSuccArchimedean α] : (hass
   fun a b => by
   rw [reachable_iff_reflTransGen]
   exact
-    reflTransGen_of_succ _ (fun c hc => Or.inl <| covby_succ_of_not_isMax hc.2.not_isMax)
-      fun c hc => Or.inr <| covby_succ_of_not_isMax hc.2.not_isMax
+    reflTransGen_of_succ _ (fun c hc => Or.inl <| covBy_succ_of_not_isMax hc.2.not_isMax)
+      fun c hc => Or.inr <| covBy_succ_of_not_isMax hc.2.not_isMax
 #align simple_graph.hasse_preconnected_of_succ SimpleGraph.hasse_preconnected_of_succ
 
 theorem hasse_preconnected_of_pred [PredOrder α] [IsPredArchimedean α] : (hasse α).Preconnected :=
   fun a b => by
   rw [reachable_iff_reflTransGen, ← reflTransGen_swap]
   exact
-    reflTransGen_of_pred _ (fun c hc => Or.inl <| pred_covby_of_not_isMin hc.1.not_isMin)
-      fun c hc => Or.inr <| pred_covby_of_not_isMin hc.1.not_isMin
+    reflTransGen_of_pred _ (fun c hc => Or.inl <| pred_covBy_of_not_isMin hc.1.not_isMin)
+      fun c hc => Or.inr <| pred_covBy_of_not_isMin hc.1.not_isMin
 #align simple_graph.hasse_preconnected_of_pred SimpleGraph.hasse_preconnected_of_pred
 
 end LinearOrder
@@ -107,7 +107,7 @@ def pathGraph (n : ℕ) : SimpleGraph (Fin n) :=
 theorem pathGraph_adj {n : ℕ} {u v : Fin n} :
     (pathGraph n).Adj u v ↔ u.val + 1 = v.val ∨ v.val + 1 = u.val := by
   simp only [pathGraph, hasse]
-  simp_rw [← Fin.coe_covby_iff, Nat.covby_iff_succ_eq]
+  simp_rw [← Fin.coe_covBy_iff, Nat.covBy_iff_succ_eq]
 
 theorem pathGraph_preconnected (n : ℕ) : (pathGraph n).Preconnected :=
   hasse_preconnected_of_succ _
@@ -119,6 +119,6 @@ theorem pathGraph_connected (n : ℕ) : (pathGraph (n + 1)).Connected :=
 
 theorem pathGraph_two_eq_top : pathGraph 2 = ⊤ := by
   ext u v
-  fin_cases u <;> fin_cases v <;> simp [pathGraph, ← Fin.coe_covby_iff, Nat.covby_iff_succ_eq]
+  fin_cases u <;> fin_cases v <;> simp [pathGraph, ← Fin.coe_covBy_iff, Nat.covBy_iff_succ_eq]
 
 end SimpleGraph

8a38a697

feat: add 2-coloring of pathGraph and prove its chromatic number is 2 (#8166)

Define a bicoloring for pathGraph and prove that when 2 ≤ n its chromatic number is 2. Creates a ConcreteColorings module to hold such colorings of concrete graphs.

e004ac1c

Diff

@@ -5,6 +5,7 @@ Authors: Yaël Dillies
 -/
 import Mathlib.Combinatorics.SimpleGraph.Prod
 import Mathlib.Data.Fin.SuccPred
+import Mathlib.Data.ZMod.Basic
 import Mathlib.Order.SuccPred.Relation
 
 #align_import combinatorics.simple_graph.hasse from "leanprover-community/mathlib"@"8a38a697305292b37a61650e2c3bd3502d98c805"
@@ -103,6 +104,11 @@ def pathGraph (n : ℕ) : SimpleGraph (Fin n) :=
   hasse _
 #align simple_graph.path_graph SimpleGraph.pathGraph
 
+theorem pathGraph_adj {n : ℕ} {u v : Fin n} :
+    (pathGraph n).Adj u v ↔ u.val + 1 = v.val ∨ v.val + 1 = u.val := by
+  simp only [pathGraph, hasse]
+  simp_rw [← Fin.coe_covby_iff, Nat.covby_iff_succ_eq]
+
 theorem pathGraph_preconnected (n : ℕ) : (pathGraph n).Preconnected :=
   hasse_preconnected_of_succ _
 #align simple_graph.path_graph_preconnected SimpleGraph.pathGraph_preconnected
@@ -111,4 +117,8 @@ theorem pathGraph_connected (n : ℕ) : (pathGraph (n + 1)).Connected :=
   ⟨pathGraph_preconnected _⟩
 #align simple_graph.path_graph_connected SimpleGraph.pathGraph_connected
 
+theorem pathGraph_two_eq_top : pathGraph 2 = ⊤ := by
+  ext u v
+  fin_cases u <;> fin_cases v <;> simp [pathGraph, ← Fin.coe_covby_iff, Nat.covby_iff_succ_eq]
+
 end SimpleGraph

8a38a697

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

@@ -26,7 +26,7 @@ open Order OrderDual Relation
 
 namespace SimpleGraph
 
-variable (α β : Type _)
+variable (α β : Type*)
 
 section Preorder

8a38a697

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,16 +2,13 @@
 Copyright (c) 2022 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
-
-! This file was ported from Lean 3 source module combinatorics.simple_graph.hasse
-! leanprover-community/mathlib commit 8a38a697305292b37a61650e2c3bd3502d98c805
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Combinatorics.SimpleGraph.Prod
 import Mathlib.Data.Fin.SuccPred
 import Mathlib.Order.SuccPred.Relation
 
+#align_import combinatorics.simple_graph.hasse from "leanprover-community/mathlib"@"8a38a697305292b37a61650e2c3bd3502d98c805"
+
 /-!
 # The Hasse diagram as a graph

8a38a697

chore: remove superfluous parentheses in calls to ext (#5258)

Co-authored-by: Xavier Roblot <46200072+xroblot@users.noreply.github.com> Co-authored-by: Joël Riou <joel.riou@universite-paris-saclay.fr> Co-authored-by: Riccardo Brasca <riccardo.brasca@gmail.com> Co-authored-by: Yury G. Kudryashov <urkud@urkud.name> Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Pol'tta / Miyahara Kō <pol_tta@outlook.jp> Co-authored-by: Jason Yuen <jason_yuen2007@hotmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com> Co-authored-by: Jireh Loreaux <loreaujy@gmail.com> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: Heather Macbeth <25316162+hrmacbeth@users.noreply.github.com> Co-authored-by: Jujian Zhang <jujian.zhang1998@outlook.com> Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

3d6731dc

Diff

@@ -72,7 +72,7 @@ variable [PartialOrder α] [PartialOrder β]
 
 @[simp]
 theorem hasse_prod : hasse (α × β) = hasse α □ hasse β := by
-  ext (x y)
+  ext x y
   simp_rw [boxProd_adj, hasse_adj, Prod.covby_iff, or_and_right, @eq_comm _ y.1, @eq_comm _ y.2,
     or_or_or_comm]
 #align simple_graph.hasse_prod SimpleGraph.hasse_prod

8a38a697

chore: tidy various files (#2742)

8c7b65ad

Diff

@@ -51,7 +51,7 @@ theorem hasse_adj : (hasse α).Adj a b ↔ a ⋖ b ∨ b ⋖ a :=
 
 /-- `αᵒᵈ` and `α` have the same Hasse diagram. -/
 def hasseDualIso : hasse αᵒᵈ ≃g hasse α :=
-  { ofDual with map_rel_iff' := @fun a b => by simp [or_comm] }
+  { ofDual with map_rel_iff' := by simp [or_comm] }
 #align simple_graph.hasse_dual_iso SimpleGraph.hasseDualIso
 
 @[simp]

8a38a697

feat: port Combinatorics.SimpleGraph.Hasse (#2582)

depends on: #2565

Co-authored-by: Arien Malec <arien.malec@gmail.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: Moritz Firsching <firsching@google.com>

fa0f201c

`combinatorics.simple_graph.hasse` ⟷ `Mathlib.Combinatorics.SimpleGraph.Hasse`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 6 + 229

combinatorics.simple_graph.hasse ⟷ Mathlib.Combinatorics.SimpleGraph.Hasse

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 6 + 229

`combinatorics.simple_graph.hasse` ⟷ `Mathlib.Combinatorics.SimpleGraph.Hasse`