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

90659cbe

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

97eab485

bump to nightly-2024-04-25-08

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

ad7a2212

Diff

@@ -171,7 +171,7 @@ theorem odd_card_odd_degree_vertices_ne [Fintype V] [DecidableEq V] [DecidableRe
   have hc : (fun w : V => w ≠ v ∧ Odd (G.degree w)) = fun w : V => Odd (G.degree w) ∧ w ≠ v :=
     by
     ext w
-    rw [and_comm']
+    rw [and_comm]
   simp only [hc, filter_congr_decidable]
   rw [← filter_filter, filter_ne', card_erase_of_mem]
   · refine' ⟨k - 1, tsub_eq_of_eq_add <| hg.trans _⟩

97eab485

bump to nightly-2024-04-19-08

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

a9e81450

Diff

@@ -139,7 +139,7 @@ theorem even_card_odd_degree_vertices [Fintype V] [DecidableRel G.Adj] :
     Even (univ.filterₓ fun v => Odd (G.degree v)).card := by
   classical
   have h := congr_arg (fun n => ↑n : ℕ → ZMod 2) G.sum_degrees_eq_twice_card_edges
-  simp only [ZMod.nat_cast_self, MulZeroClass.zero_mul, Nat.cast_mul] at h
+  simp only [ZMod.natCast_self, MulZeroClass.zero_mul, Nat.cast_mul] at h
   rw [Nat.cast_sum, ← sum_filter_ne_zero] at h
   rw [@sum_congr _ _ _ _ (fun v => (G.degree v : ZMod 2)) (fun v => (1 : ZMod 2)) _ rfl] at h
   · simp only [filter_congr_decidable, mul_one, nsmul_eq_mul, sum_const, Ne.def] at h

97eab485

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -6,7 +6,7 @@ Authors: Kyle Miller
 import Combinatorics.SimpleGraph.Basic
 import Algebra.BigOperators.Basic
 import Data.Nat.Parity
-import Data.Zmod.Parity
+import Data.ZMod.Parity
 
 #align_import combinatorics.simple_graph.degree_sum from "leanprover-community/mathlib"@"97eab48559068f3d6313da387714ef25768fb730"

97eab485

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -139,10 +139,10 @@ theorem even_card_odd_degree_vertices [Fintype V] [DecidableRel G.Adj] :
     Even (univ.filterₓ fun v => Odd (G.degree v)).card := by
   classical
   have h := congr_arg (fun n => ↑n : ℕ → ZMod 2) G.sum_degrees_eq_twice_card_edges
-  simp only [ZMod.nat_cast_self, MulZeroClass.zero_mul, Nat.cast_mul] at h 
-  rw [Nat.cast_sum, ← sum_filter_ne_zero] at h 
-  rw [@sum_congr _ _ _ _ (fun v => (G.degree v : ZMod 2)) (fun v => (1 : ZMod 2)) _ rfl] at h 
-  · simp only [filter_congr_decidable, mul_one, nsmul_eq_mul, sum_const, Ne.def] at h 
+  simp only [ZMod.nat_cast_self, MulZeroClass.zero_mul, Nat.cast_mul] at h
+  rw [Nat.cast_sum, ← sum_filter_ne_zero] at h
+  rw [@sum_congr _ _ _ _ (fun v => (G.degree v : ZMod 2)) (fun v => (1 : ZMod 2)) _ rfl] at h
+  · simp only [filter_congr_decidable, mul_one, nsmul_eq_mul, sum_const, Ne.def] at h
     rw [← ZMod.eq_zero_iff_even]
     convert h
     ext v
@@ -166,7 +166,7 @@ theorem odd_card_odd_degree_vertices_ne [Fintype V] [DecidableEq V] [DecidableRe
       use v
       simp only [true_and_iff, mem_filter, mem_univ]
       use h
-    rwa [← card_pos, hg, ← two_mul, mul_pos_iff_of_pos_left] at hh 
+    rwa [← card_pos, hg, ← two_mul, mul_pos_iff_of_pos_left] at hh
     exact zero_lt_two
   have hc : (fun w : V => w ≠ v ∧ Odd (G.degree w)) = fun w : V => Odd (G.degree w) ∧ w ≠ v :=
     by
@@ -193,7 +193,7 @@ theorem exists_ne_odd_degree_of_exists_odd_degree [Fintype V] [DecidableRel G.Ad
     rw [hg]
     apply Nat.succ_pos
   rcases card_pos.mp hg' with ⟨w, hw⟩
-  simp only [true_and_iff, mem_filter, mem_univ, Ne.def] at hw 
+  simp only [true_and_iff, mem_filter, mem_univ, Ne.def] at hw
   exact ⟨w, hw⟩
 #align simple_graph.exists_ne_odd_degree_of_exists_odd_degree SimpleGraph.exists_ne_odd_degree_of_exists_odd_degree
 -/

97eab485

bump to nightly-2024-02-01-06

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

5433bded

Diff

@@ -136,7 +136,21 @@ end DegreeSum
 #print SimpleGraph.even_card_odd_degree_vertices /-
 /-- The handshaking lemma.  See also `simple_graph.sum_degrees_eq_twice_card_edges`. -/
 theorem even_card_odd_degree_vertices [Fintype V] [DecidableRel G.Adj] :
-    Even (univ.filterₓ fun v => Odd (G.degree v)).card := by classical
+    Even (univ.filterₓ fun v => Odd (G.degree v)).card := by
+  classical
+  have h := congr_arg (fun n => ↑n : ℕ → ZMod 2) G.sum_degrees_eq_twice_card_edges
+  simp only [ZMod.nat_cast_self, MulZeroClass.zero_mul, Nat.cast_mul] at h 
+  rw [Nat.cast_sum, ← sum_filter_ne_zero] at h 
+  rw [@sum_congr _ _ _ _ (fun v => (G.degree v : ZMod 2)) (fun v => (1 : ZMod 2)) _ rfl] at h 
+  · simp only [filter_congr_decidable, mul_one, nsmul_eq_mul, sum_const, Ne.def] at h 
+    rw [← ZMod.eq_zero_iff_even]
+    convert h
+    ext v
+    rw [← ZMod.ne_zero_iff_odd]
+  · intro v
+    simp only [true_and_iff, mem_filter, mem_univ, Ne.def]
+    rw [ZMod.eq_zero_iff_even, ZMod.eq_one_iff_odd, Nat.odd_iff_not_even, imp_self]
+    trivial
 #align simple_graph.even_card_odd_degree_vertices SimpleGraph.even_card_odd_degree_vertices
 -/

97eab485

bump to nightly-2024-01-31-06

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

61100fe9

Diff

@@ -136,21 +136,7 @@ end DegreeSum
 #print SimpleGraph.even_card_odd_degree_vertices /-
 /-- The handshaking lemma.  See also `simple_graph.sum_degrees_eq_twice_card_edges`. -/
 theorem even_card_odd_degree_vertices [Fintype V] [DecidableRel G.Adj] :
-    Even (univ.filterₓ fun v => Odd (G.degree v)).card := by
-  classical
-  have h := congr_arg (fun n => ↑n : ℕ → ZMod 2) G.sum_degrees_eq_twice_card_edges
-  simp only [ZMod.nat_cast_self, MulZeroClass.zero_mul, Nat.cast_mul] at h 
-  rw [Nat.cast_sum, ← sum_filter_ne_zero] at h 
-  rw [@sum_congr _ _ _ _ (fun v => (G.degree v : ZMod 2)) (fun v => (1 : ZMod 2)) _ rfl] at h 
-  · simp only [filter_congr_decidable, mul_one, nsmul_eq_mul, sum_const, Ne.def] at h 
-    rw [← ZMod.eq_zero_iff_even]
-    convert h
-    ext v
-    rw [← ZMod.ne_zero_iff_odd]
-  · intro v
-    simp only [true_and_iff, mem_filter, mem_univ, Ne.def]
-    rw [ZMod.eq_zero_iff_even, ZMod.eq_one_iff_odd, Nat.odd_iff_not_even, imp_self]
-    trivial
+    Even (univ.filterₓ fun v => Odd (G.degree v)).card := by classical
 #align simple_graph.even_card_odd_degree_vertices SimpleGraph.even_card_odd_degree_vertices
 -/

97eab485

bump to nightly-2023-12-28-06

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

c30f5587

Diff

@@ -166,7 +166,7 @@ theorem odd_card_odd_degree_vertices_ne [Fintype V] [DecidableEq V] [DecidableRe
       use v
       simp only [true_and_iff, mem_filter, mem_univ]
       use h
-    rwa [← card_pos, hg, ← two_mul, zero_lt_mul_left] at hh 
+    rwa [← card_pos, hg, ← two_mul, mul_pos_iff_of_pos_left] at hh 
     exact zero_lt_two
   have hc : (fun w : V => w ≠ v ∧ Odd (G.degree w)) = fun w : V => Odd (G.degree w) ∧ w ≠ v :=
     by

97eab485

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,10 +3,10 @@ Copyright (c) 2020 Kyle Miller. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kyle Miller
 -/
-import Mathbin.Combinatorics.SimpleGraph.Basic
-import Mathbin.Algebra.BigOperators.Basic
-import Mathbin.Data.Nat.Parity
-import Mathbin.Data.Zmod.Parity
+import Combinatorics.SimpleGraph.Basic
+import Algebra.BigOperators.Basic
+import Data.Nat.Parity
+import Data.Zmod.Parity
 
 #align_import combinatorics.simple_graph.degree_sum from "leanprover-community/mathlib"@"97eab48559068f3d6313da387714ef25768fb730"

97eab485

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 2020 Kyle Miller. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kyle Miller
-
-! This file was ported from Lean 3 source module combinatorics.simple_graph.degree_sum
-! leanprover-community/mathlib commit 97eab48559068f3d6313da387714ef25768fb730
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Combinatorics.SimpleGraph.Basic
 import Mathbin.Algebra.BigOperators.Basic
 import Mathbin.Data.Nat.Parity
 import Mathbin.Data.Zmod.Parity
 
+#align_import combinatorics.simple_graph.degree_sum from "leanprover-community/mathlib"@"97eab48559068f3d6313da387714ef25768fb730"
+
 /-!
 # Degree-sum formula and handshaking lemma

97eab485

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -100,6 +100,7 @@ theorem Dart.edge_fiber (d : G.Dart) :
 
 variable (G)
 
+#print SimpleGraph.dart_edge_fiber_card /-
 theorem dart_edge_fiber_card (e : Sym2 V) (h : e ∈ G.edgeSetEmbedding) :
     (univ.filterₓ fun d : G.Dart => d.edge = e).card = 2 :=
   by
@@ -110,7 +111,9 @@ theorem dart_edge_fiber_card (e : Sym2 V) (h : e ∈ G.edgeSetEmbedding) :
   rw [mem_singleton]
   exact d.symm_ne.symm
 #align simple_graph.dart_edge_fiber_card SimpleGraph.dart_edge_fiber_card
+-/
 
+#print SimpleGraph.dart_card_eq_twice_card_edges /-
 theorem dart_card_eq_twice_card_edges : Fintype.card G.Dart = 2 * G.edgeFinset.card :=
   by
   rw [← card_univ]
@@ -121,15 +124,19 @@ theorem dart_card_eq_twice_card_edges : Fintype.card G.Dart = 2 * G.edgeFinset.c
   apply G.dart_edge_fiber_card e
   rwa [← mem_edge_finset]
 #align simple_graph.dart_card_eq_twice_card_edges SimpleGraph.dart_card_eq_twice_card_edges
+-/
 
+#print SimpleGraph.sum_degrees_eq_twice_card_edges /-
 /-- The degree-sum formula.  This is also known as the handshaking lemma, which might
 more specifically refer to `simple_graph.even_card_odd_degree_vertices`. -/
 theorem sum_degrees_eq_twice_card_edges : ∑ v, G.degree v = 2 * G.edgeFinset.card :=
   G.dart_card_eq_sum_degrees.symm.trans G.dart_card_eq_twice_card_edges
 #align simple_graph.sum_degrees_eq_twice_card_edges SimpleGraph.sum_degrees_eq_twice_card_edges
+-/
 
 end DegreeSum
 
+#print SimpleGraph.even_card_odd_degree_vertices /-
 /-- The handshaking lemma.  See also `simple_graph.sum_degrees_eq_twice_card_edges`. -/
 theorem even_card_odd_degree_vertices [Fintype V] [DecidableRel G.Adj] :
     Even (univ.filterₓ fun v => Odd (G.degree v)).card := by
@@ -148,7 +155,9 @@ theorem even_card_odd_degree_vertices [Fintype V] [DecidableRel G.Adj] :
     rw [ZMod.eq_zero_iff_even, ZMod.eq_one_iff_odd, Nat.odd_iff_not_even, imp_self]
     trivial
 #align simple_graph.even_card_odd_degree_vertices SimpleGraph.even_card_odd_degree_vertices
+-/
 
+#print SimpleGraph.odd_card_odd_degree_vertices_ne /-
 theorem odd_card_odd_degree_vertices_ne [Fintype V] [DecidableEq V] [DecidableRel G.Adj] (v : V)
     (h : Odd (G.degree v)) : Odd (univ.filterₓ fun w => w ≠ v ∧ Odd (G.degree w)).card :=
   by
@@ -174,6 +183,7 @@ theorem odd_card_odd_degree_vertices_ne [Fintype V] [DecidableEq V] [DecidableRe
     exact (tsub_add_cancel_of_le <| Nat.succ_le_iff.2 hk).symm
   · simpa only [true_and_iff, mem_filter, mem_univ]
 #align simple_graph.odd_card_odd_degree_vertices_ne SimpleGraph.odd_card_odd_degree_vertices_ne
+-/
 
 #print SimpleGraph.exists_ne_odd_degree_of_exists_odd_degree /-
 theorem exists_ne_odd_degree_of_exists_odd_degree [Fintype V] [DecidableRel G.Adj] (v : V)

97eab485

bump to nightly-2023-06-10-07

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

3fdc57bc

Diff

@@ -124,7 +124,7 @@ theorem dart_card_eq_twice_card_edges : Fintype.card G.Dart = 2 * G.edgeFinset.c
 
 /-- The degree-sum formula.  This is also known as the handshaking lemma, which might
 more specifically refer to `simple_graph.even_card_odd_degree_vertices`. -/
-theorem sum_degrees_eq_twice_card_edges : (∑ v, G.degree v) = 2 * G.edgeFinset.card :=
+theorem sum_degrees_eq_twice_card_edges : ∑ v, G.degree v = 2 * G.edgeFinset.card :=
   G.dart_card_eq_sum_degrees.symm.trans G.dart_card_eq_twice_card_edges
 #align simple_graph.sum_degrees_eq_twice_card_edges SimpleGraph.sum_degrees_eq_twice_card_edges

97eab485

bump to nightly-2023-06-04-18

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

3fb4268b

Diff

@@ -134,19 +134,19 @@ end DegreeSum
 theorem even_card_odd_degree_vertices [Fintype V] [DecidableRel G.Adj] :
     Even (univ.filterₓ fun v => Odd (G.degree v)).card := by
   classical
-    have h := congr_arg (fun n => ↑n : ℕ → ZMod 2) G.sum_degrees_eq_twice_card_edges
-    simp only [ZMod.nat_cast_self, MulZeroClass.zero_mul, Nat.cast_mul] at h 
-    rw [Nat.cast_sum, ← sum_filter_ne_zero] at h 
-    rw [@sum_congr _ _ _ _ (fun v => (G.degree v : ZMod 2)) (fun v => (1 : ZMod 2)) _ rfl] at h 
-    · simp only [filter_congr_decidable, mul_one, nsmul_eq_mul, sum_const, Ne.def] at h 
-      rw [← ZMod.eq_zero_iff_even]
-      convert h
-      ext v
-      rw [← ZMod.ne_zero_iff_odd]
-    · intro v
-      simp only [true_and_iff, mem_filter, mem_univ, Ne.def]
-      rw [ZMod.eq_zero_iff_even, ZMod.eq_one_iff_odd, Nat.odd_iff_not_even, imp_self]
-      trivial
+  have h := congr_arg (fun n => ↑n : ℕ → ZMod 2) G.sum_degrees_eq_twice_card_edges
+  simp only [ZMod.nat_cast_self, MulZeroClass.zero_mul, Nat.cast_mul] at h 
+  rw [Nat.cast_sum, ← sum_filter_ne_zero] at h 
+  rw [@sum_congr _ _ _ _ (fun v => (G.degree v : ZMod 2)) (fun v => (1 : ZMod 2)) _ rfl] at h 
+  · simp only [filter_congr_decidable, mul_one, nsmul_eq_mul, sum_const, Ne.def] at h 
+    rw [← ZMod.eq_zero_iff_even]
+    convert h
+    ext v
+    rw [← ZMod.ne_zero_iff_odd]
+  · intro v
+    simp only [true_and_iff, mem_filter, mem_univ, Ne.def]
+    rw [ZMod.eq_zero_iff_even, ZMod.eq_one_iff_odd, Nat.odd_iff_not_even, imp_self]
+    trivial
 #align simple_graph.even_card_odd_degree_vertices SimpleGraph.even_card_odd_degree_vertices
 
 theorem odd_card_odd_degree_vertices_ne [Fintype V] [DecidableEq V] [DecidableRel G.Adj] (v : V)

97eab485

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -135,10 +135,10 @@ theorem even_card_odd_degree_vertices [Fintype V] [DecidableRel G.Adj] :
     Even (univ.filterₓ fun v => Odd (G.degree v)).card := by
   classical
     have h := congr_arg (fun n => ↑n : ℕ → ZMod 2) G.sum_degrees_eq_twice_card_edges
-    simp only [ZMod.nat_cast_self, MulZeroClass.zero_mul, Nat.cast_mul] at h
-    rw [Nat.cast_sum, ← sum_filter_ne_zero] at h
-    rw [@sum_congr _ _ _ _ (fun v => (G.degree v : ZMod 2)) (fun v => (1 : ZMod 2)) _ rfl] at h
-    · simp only [filter_congr_decidable, mul_one, nsmul_eq_mul, sum_const, Ne.def] at h
+    simp only [ZMod.nat_cast_self, MulZeroClass.zero_mul, Nat.cast_mul] at h 
+    rw [Nat.cast_sum, ← sum_filter_ne_zero] at h 
+    rw [@sum_congr _ _ _ _ (fun v => (G.degree v : ZMod 2)) (fun v => (1 : ZMod 2)) _ rfl] at h 
+    · simp only [filter_congr_decidable, mul_one, nsmul_eq_mul, sum_const, Ne.def] at h 
       rw [← ZMod.eq_zero_iff_even]
       convert h
       ext v
@@ -160,7 +160,7 @@ theorem odd_card_odd_degree_vertices_ne [Fintype V] [DecidableEq V] [DecidableRe
       use v
       simp only [true_and_iff, mem_filter, mem_univ]
       use h
-    rwa [← card_pos, hg, ← two_mul, zero_lt_mul_left] at hh
+    rwa [← card_pos, hg, ← two_mul, zero_lt_mul_left] at hh 
     exact zero_lt_two
   have hc : (fun w : V => w ≠ v ∧ Odd (G.degree w)) = fun w : V => Odd (G.degree w) ∧ w ≠ v :=
     by
@@ -186,7 +186,7 @@ theorem exists_ne_odd_degree_of_exists_odd_degree [Fintype V] [DecidableRel G.Ad
     rw [hg]
     apply Nat.succ_pos
   rcases card_pos.mp hg' with ⟨w, hw⟩
-  simp only [true_and_iff, mem_filter, mem_univ, Ne.def] at hw
+  simp only [true_and_iff, mem_filter, mem_univ, Ne.def] at hw 
   exact ⟨w, hw⟩
 #align simple_graph.exists_ne_odd_degree_of_exists_odd_degree SimpleGraph.exists_ne_odd_degree_of_exists_odd_degree
 -/

97eab485

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -46,7 +46,7 @@ simple graphs, sums, degree-sum formula, handshaking lemma
 
 open Finset
 
-open BigOperators
+open scoped BigOperators
 
 namespace SimpleGraph

97eab485

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -100,12 +100,6 @@ theorem Dart.edge_fiber (d : G.Dart) :
 
 variable (G)
 
-/- warning: simple_graph.dart_edge_fiber_card -> SimpleGraph.dart_edge_fiber_card is a dubious translation:
-lean 3 declaration is
-  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : DecidableEq.{succ u1} V] (e : Sym2.{u1} V), (Membership.Mem.{u1, u1} (Sym2.{u1} V) (Set.{u1} (Sym2.{u1} V)) (Set.hasMem.{u1} (Sym2.{u1} V)) e (coeFn.{succ u1, succ u1} (OrderEmbedding.{u1, u1} (SimpleGraph.{u1} V) (Set.{u1} (Sym2.{u1} V)) (SimpleGraph.hasLe.{u1} V) (Set.hasLe.{u1} (Sym2.{u1} V))) (fun (_x : RelEmbedding.{u1, u1} (SimpleGraph.{u1} V) (Set.{u1} (Sym2.{u1} V)) (LE.le.{u1} (SimpleGraph.{u1} V) (SimpleGraph.hasLe.{u1} V)) (LE.le.{u1} (Set.{u1} (Sym2.{u1} V)) (Set.hasLe.{u1} (Sym2.{u1} V)))) => (SimpleGraph.{u1} V) -> (Set.{u1} (Sym2.{u1} V))) (RelEmbedding.hasCoeToFun.{u1, u1} (SimpleGraph.{u1} V) (Set.{u1} (Sym2.{u1} V)) (LE.le.{u1} (SimpleGraph.{u1} V) (SimpleGraph.hasLe.{u1} V)) (LE.le.{u1} (Set.{u1} (Sym2.{u1} V)) (Set.hasLe.{u1} (Sym2.{u1} V)))) (SimpleGraph.edgeSetEmbedding.{u1} V) G)) -> (Eq.{1} Nat (Finset.card.{u1} (SimpleGraph.Dart.{u1} V G) (Finset.filter.{u1} (SimpleGraph.Dart.{u1} V G) (fun (d : SimpleGraph.Dart.{u1} V G) => Eq.{succ u1} (Sym2.{u1} V) (SimpleGraph.Dart.edge.{u1} V G d) e) (fun (a : SimpleGraph.Dart.{u1} V G) => Quotient.decidableEq.{succ u1} (Prod.{u1, u1} V V) (Sym2.Rel.setoid.{u1} V) (fun (a : Prod.{u1, u1} V V) (b : Prod.{u1, u1} V V) => Sym2.Rel.decidableRel.{u1} V (fun (a : V) (b : V) => _inst_3 a b) a b) (SimpleGraph.Dart.edge.{u1} V G a) e) (Finset.univ.{u1} (SimpleGraph.Dart.{u1} V G) (SimpleGraph.Dart.fintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))
-but is expected to have type
-  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : DecidableEq.{succ u1} V] (e : Sym2.{u1} V), (Membership.mem.{u1, u1} (Sym2.{u1} V) (Set.{u1} (Sym2.{u1} V)) (Set.instMembershipSet.{u1} (Sym2.{u1} V)) e (SimpleGraph.edgeSet.{u1} V G)) -> (Eq.{1} Nat (Finset.card.{u1} (SimpleGraph.Dart.{u1} V G) (Finset.filter.{u1} (SimpleGraph.Dart.{u1} V G) (fun (d : SimpleGraph.Dart.{u1} V G) => Eq.{succ u1} (Sym2.{u1} V) (SimpleGraph.Dart.edge.{u1} V G d) e) (fun (a : SimpleGraph.Dart.{u1} V G) => Quotient.decidableEq.{succ u1} (Prod.{u1, u1} V V) (Sym2.Rel.setoid.{u1} V) (fun (a : Prod.{u1, u1} V V) (b : Prod.{u1, u1} V V) => (fun (a : Prod.{u1, u1} V V) (b : Prod.{u1, u1} V V) => Sym2.instRelDecidable'.{u1} V (fun (a : V) (b : V) => _inst_3 a b) a b) a b) (SimpleGraph.Dart.edge.{u1} V G a) e) (Finset.univ.{u1} (SimpleGraph.Dart.{u1} V G) (SimpleGraph.Dart.fintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))
-Case conversion may be inaccurate. Consider using '#align simple_graph.dart_edge_fiber_card SimpleGraph.dart_edge_fiber_cardₓ'. -/
 theorem dart_edge_fiber_card (e : Sym2 V) (h : e ∈ G.edgeSetEmbedding) :
     (univ.filterₓ fun d : G.Dart => d.edge = e).card = 2 :=
   by
@@ -117,12 +111,6 @@ theorem dart_edge_fiber_card (e : Sym2 V) (h : e ∈ G.edgeSetEmbedding) :
   exact d.symm_ne.symm
 #align simple_graph.dart_edge_fiber_card SimpleGraph.dart_edge_fiber_card
 
-/- warning: simple_graph.dart_card_eq_twice_card_edges -> SimpleGraph.dart_card_eq_twice_card_edges is a dubious translation:
-lean 3 declaration is
-  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : DecidableEq.{succ u1} V], Eq.{1} Nat (Fintype.card.{u1} (SimpleGraph.Dart.{u1} V G) (SimpleGraph.Dart.fintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b))) (HMul.hMul.{0, 0, 0} Nat Nat Nat (instHMul.{0} Nat Nat.hasMul) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) (Finset.card.{u1} (Sym2.{u1} V) (SimpleGraph.edgeFinset.{u1} V G (SimpleGraph.fintypeEdgeSet.{u1} V G (fun (a : V) (b : V) => _inst_3 a b) _inst_1 (fun (a : V) (b : V) => _inst_2 a b)))))
-but is expected to have type
-  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : Fintype.{u1} (Sym2.{u1} V)] [inst._@.Mathlib.Combinatorics.SimpleGraph.DegreeSum._hyg.684 : DecidableEq.{succ u1} V], Eq.{1} Nat (Fintype.card.{u1} (SimpleGraph.Dart.{u1} V G) (SimpleGraph.Dart.fintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b))) (HMul.hMul.{0, 0, 0} Nat Nat Nat (instHMul.{0} Nat instMulNat) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) (Finset.card.{u1} (Sym2.{u1} V) (SimpleGraph.edgeFinset.{u1} V G (SimpleGraph.fintypeEdgeSet.{u1} V G _inst_3 (fun (a : V) (b : V) => _inst_2 a b)))))
-Case conversion may be inaccurate. Consider using '#align simple_graph.dart_card_eq_twice_card_edges SimpleGraph.dart_card_eq_twice_card_edgesₓ'. -/
 theorem dart_card_eq_twice_card_edges : Fintype.card G.Dart = 2 * G.edgeFinset.card :=
   by
   rw [← card_univ]
@@ -134,12 +122,6 @@ theorem dart_card_eq_twice_card_edges : Fintype.card G.Dart = 2 * G.edgeFinset.c
   rwa [← mem_edge_finset]
 #align simple_graph.dart_card_eq_twice_card_edges SimpleGraph.dart_card_eq_twice_card_edges
 
-/- warning: simple_graph.sum_degrees_eq_twice_card_edges -> SimpleGraph.sum_degrees_eq_twice_card_edges is a dubious translation:
-lean 3 declaration is
-  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : DecidableEq.{succ u1} V], Eq.{1} Nat (Finset.sum.{0, u1} Nat V Nat.addCommMonoid (Finset.univ.{u1} V _inst_1) (fun (v : V) => SimpleGraph.degree.{u1} V G v (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b) v))) (HMul.hMul.{0, 0, 0} Nat Nat Nat (instHMul.{0} Nat Nat.hasMul) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) (Finset.card.{u1} (Sym2.{u1} V) (SimpleGraph.edgeFinset.{u1} V G (SimpleGraph.fintypeEdgeSet.{u1} V G (fun (a : V) (b : V) => _inst_3 a b) _inst_1 (fun (a : V) (b : V) => _inst_2 a b)))))
-but is expected to have type
-  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : Fintype.{u1} (Sym2.{u1} V)] [inst._@.Mathlib.Combinatorics.SimpleGraph.DegreeSum._hyg.883 : DecidableEq.{succ u1} V], Eq.{1} Nat (Finset.sum.{0, u1} Nat V Nat.addCommMonoid (Finset.univ.{u1} V _inst_1) (fun (v : V) => SimpleGraph.degree.{u1} V G v (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b) v))) (HMul.hMul.{0, 0, 0} Nat Nat Nat (instHMul.{0} Nat instMulNat) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) (Finset.card.{u1} (Sym2.{u1} V) (SimpleGraph.edgeFinset.{u1} V G (SimpleGraph.fintypeEdgeSet.{u1} V G _inst_3 (fun (a : V) (b : V) => _inst_2 a b)))))
-Case conversion may be inaccurate. Consider using '#align simple_graph.sum_degrees_eq_twice_card_edges SimpleGraph.sum_degrees_eq_twice_card_edgesₓ'. -/
 /-- The degree-sum formula.  This is also known as the handshaking lemma, which might
 more specifically refer to `simple_graph.even_card_odd_degree_vertices`. -/
 theorem sum_degrees_eq_twice_card_edges : (∑ v, G.degree v) = 2 * G.edgeFinset.card :=
@@ -148,12 +130,6 @@ theorem sum_degrees_eq_twice_card_edges : (∑ v, G.degree v) = 2 * G.edgeFinset
 
 end DegreeSum
 
-/- warning: simple_graph.even_card_odd_degree_vertices -> SimpleGraph.even_card_odd_degree_vertices is a dubious translation:
-lean 3 declaration is
-  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)], Even.{0} Nat Nat.hasAdd (Finset.card.{u1} V (Finset.filter.{u1} V (fun (v : V) => Odd.{0} Nat Nat.semiring (SimpleGraph.degree.{u1} V G v (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b) v))) (fun (a : V) => Nat.Odd.decidablePred (SimpleGraph.degree.{u1} V G a (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b) a))) (Finset.univ.{u1} V _inst_1)))
-but is expected to have type
-  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)], Even.{0} Nat instAddNat (Finset.card.{u1} V (Finset.filter.{u1} V (fun (v : V) => Odd.{0} Nat Nat.semiring (SimpleGraph.degree.{u1} V G v (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b) v))) (fun (a : V) => Nat.instDecidablePredNatOddSemiring (SimpleGraph.degree.{u1} V G a (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b) a))) (Finset.univ.{u1} V _inst_1)))
-Case conversion may be inaccurate. Consider using '#align simple_graph.even_card_odd_degree_vertices SimpleGraph.even_card_odd_degree_verticesₓ'. -/
 /-- The handshaking lemma.  See also `simple_graph.sum_degrees_eq_twice_card_edges`. -/
 theorem even_card_odd_degree_vertices [Fintype V] [DecidableRel G.Adj] :
     Even (univ.filterₓ fun v => Odd (G.degree v)).card := by
@@ -173,12 +149,6 @@ theorem even_card_odd_degree_vertices [Fintype V] [DecidableRel G.Adj] :
       trivial
 #align simple_graph.even_card_odd_degree_vertices SimpleGraph.even_card_odd_degree_vertices
 
-/- warning: simple_graph.odd_card_odd_degree_vertices_ne -> SimpleGraph.odd_card_odd_degree_vertices_ne is a dubious translation:
-lean 3 declaration is
-  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableEq.{succ u1} V] [_inst_3 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] (v : V), (Odd.{0} Nat Nat.semiring (SimpleGraph.degree.{u1} V G v (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_3 a b) v))) -> (Odd.{0} Nat Nat.semiring (Finset.card.{u1} V (Finset.filter.{u1} V (fun (w : V) => And (Ne.{succ u1} V w v) (Odd.{0} Nat Nat.semiring (SimpleGraph.degree.{u1} V G w (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_3 a b) w)))) (fun (a : V) => And.decidable (Ne.{succ u1} V a v) (Odd.{0} Nat Nat.semiring (SimpleGraph.degree.{u1} V G a (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_3 a b) a))) (Ne.decidable.{succ u1} V (fun (a : V) (b : V) => _inst_2 a b) a v) (Nat.Odd.decidablePred (SimpleGraph.degree.{u1} V G a (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_3 a b) a)))) (Finset.univ.{u1} V _inst_1))))
-but is expected to have type
-  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableEq.{succ u1} V] [_inst_3 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] (v : V), (Odd.{0} Nat Nat.semiring (SimpleGraph.degree.{u1} V G v (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_3 a b) v))) -> (Odd.{0} Nat Nat.semiring (Finset.card.{u1} V (Finset.filter.{u1} V (fun (w : V) => And (Ne.{succ u1} V w v) (Odd.{0} Nat Nat.semiring (SimpleGraph.degree.{u1} V G w (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_3 a b) w)))) (fun (a : V) => instDecidableAnd (Ne.{succ u1} V a v) (Odd.{0} Nat Nat.semiring (SimpleGraph.degree.{u1} V G a (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_3 a b) a))) (instDecidableNot (Eq.{succ u1} V a v) (_inst_2 a v)) (Nat.instDecidablePredNatOddSemiring (SimpleGraph.degree.{u1} V G a (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_3 a b) a)))) (Finset.univ.{u1} V _inst_1))))
-Case conversion may be inaccurate. Consider using '#align simple_graph.odd_card_odd_degree_vertices_ne SimpleGraph.odd_card_odd_degree_vertices_neₓ'. -/
 theorem odd_card_odd_degree_vertices_ne [Fintype V] [DecidableEq V] [DecidableRel G.Adj] (v : V)
     (h : Odd (G.degree v)) : Odd (univ.filterₓ fun w => w ≠ v ∧ Odd (G.degree w)).card :=
   by

97eab485

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -126,10 +126,8 @@ Case conversion may be inaccurate. Consider using '#align simple_graph.dart_card
 theorem dart_card_eq_twice_card_edges : Fintype.card G.Dart = 2 * G.edgeFinset.card :=
   by
   rw [← card_univ]
-  rw [@card_eq_sum_card_fiberwise _ _ _ dart.edge _ G.edge_finset fun d h =>
-      by
-      rw [mem_edge_finset]
-      apply dart.edge_mem]
+  rw [@card_eq_sum_card_fiberwise _ _ _ dart.edge _ G.edge_finset fun d h => by
+      rw [mem_edge_finset]; apply dart.edge_mem]
   rw [← mul_comm, sum_const_nat]
   intro e h
   apply G.dart_edge_fiber_card e

97eab485

bump to nightly-2023-03-25-02

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

9ce440f0

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kyle Miller
 
 ! This file was ported from Lean 3 source module combinatorics.simple_graph.degree_sum
-! leanprover-community/mathlib commit 90659cbe25e59ec302e2fb92b00e9732160cc620
+! leanprover-community/mathlib commit 97eab48559068f3d6313da387714ef25768fb730
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -16,6 +16,9 @@ import Mathbin.Data.Zmod.Parity
 /-!
 # Degree-sum formula and handshaking lemma
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 The degree-sum formula is that the sum of the degrees of the vertices in
 a finite graph is equal to twice the number of edges.  The handshaking lemma,
 a corollary, is that the number of odd-degree vertices is even.

90659cbe

bump to nightly-2023-03-24-22

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

6eace303

Diff

@@ -88,16 +88,12 @@ theorem dart_card_eq_sum_degrees : Fintype.card G.Dart = ∑ v, G.degree v :=
 
 variable {G} [DecidableEq V]
 
-/- warning: simple_graph.dart.edge_fiber -> SimpleGraph.Dart.edge_fiber is a dubious translation:
-lean 3 declaration is
-  forall {V : Type.{u1}} {G : SimpleGraph.{u1} V} [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : DecidableEq.{succ u1} V] (d : SimpleGraph.Dart.{u1} V G), Eq.{succ u1} (Finset.{u1} (SimpleGraph.Dart.{u1} V G)) (Finset.filter.{u1} (SimpleGraph.Dart.{u1} V G) (fun (d' : SimpleGraph.Dart.{u1} V G) => Eq.{succ u1} (Sym2.{u1} V) (SimpleGraph.Dart.edge.{u1} V G d') (SimpleGraph.Dart.edge.{u1} V G d)) (fun (a : SimpleGraph.Dart.{u1} V G) => Quotient.decidableEq.{succ u1} (Prod.{u1, u1} V V) (Sym2.Rel.setoid.{u1} V) (fun (a : Prod.{u1, u1} V V) (b : Prod.{u1, u1} V V) => Sym2.Rel.decidableRel.{u1} V (fun (a : V) (b : V) => _inst_3 a b) a b) (SimpleGraph.Dart.edge.{u1} V G a) (SimpleGraph.Dart.edge.{u1} V G d)) (Finset.univ.{u1} (SimpleGraph.Dart.{u1} V G) (SimpleGraph.Dart.fintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b)))) (Insert.insert.{u1, u1} (SimpleGraph.Dart.{u1} V G) (Finset.{u1} (SimpleGraph.Dart.{u1} V G)) (Finset.hasInsert.{u1} (SimpleGraph.Dart.{u1} V G) (fun (a : SimpleGraph.Dart.{u1} V G) (b : SimpleGraph.Dart.{u1} V G) => SimpleGraph.Dart.decidableEq.{u1} V (fun (a : V) (b : V) => _inst_3 a b) G a b)) d (Singleton.singleton.{u1, u1} (SimpleGraph.Dart.{u1} V G) (Finset.{u1} (SimpleGraph.Dart.{u1} V G)) (Finset.hasSingleton.{u1} (SimpleGraph.Dart.{u1} V G)) (SimpleGraph.Dart.symm.{u1} V G d)))
-but is expected to have type
-  forall {V : Type.{u1}} {G : SimpleGraph.{u1} V} [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : DecidableEq.{succ u1} V] (d : SimpleGraph.Dart.{u1} V G), Eq.{succ u1} (Finset.{u1} (SimpleGraph.Dart.{u1} V G)) (Finset.filter.{u1} (SimpleGraph.Dart.{u1} V G) (fun (d' : SimpleGraph.Dart.{u1} V G) => Eq.{succ u1} (Sym2.{u1} V) (SimpleGraph.Dart.edge.{u1} V G d') (SimpleGraph.Dart.edge.{u1} V G d)) (fun (a : SimpleGraph.Dart.{u1} V G) => Sym2.instDecidableEqSym2.{u1} V (fun (a : V) (b : V) => _inst_3 a b) (SimpleGraph.Dart.edge.{u1} V G a) (SimpleGraph.Dart.edge.{u1} V G d)) (Finset.univ.{u1} (SimpleGraph.Dart.{u1} V G) (SimpleGraph.Dart.fintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b)))) (Insert.insert.{u1, u1} (SimpleGraph.Dart.{u1} V G) (Finset.{u1} (SimpleGraph.Dart.{u1} V G)) (Finset.instInsertFinset.{u1} (SimpleGraph.Dart.{u1} V G) (fun (a : SimpleGraph.Dart.{u1} V G) (b : SimpleGraph.Dart.{u1} V G) => SimpleGraph.instDecidableEqDart.{u1} V G (fun (a : V) (b : V) => _inst_3 a b) a b)) d (Singleton.singleton.{u1, u1} (SimpleGraph.Dart.{u1} V G) (Finset.{u1} (SimpleGraph.Dart.{u1} V G)) (Finset.instSingletonFinset.{u1} (SimpleGraph.Dart.{u1} V G)) (SimpleGraph.Dart.symm.{u1} V G d)))
-Case conversion may be inaccurate. Consider using '#align simple_graph.dart.edge_fiber SimpleGraph.Dart.edge_fiberₓ'. -/
+#print SimpleGraph.Dart.edge_fiber /-
 theorem Dart.edge_fiber (d : G.Dart) :
     (univ.filterₓ fun d' : G.Dart => d'.edge = d.edge) = {d, d.symm} :=
   Finset.ext fun d' => by simpa using dart_edge_eq_iff d' d
 #align simple_graph.dart.edge_fiber SimpleGraph.Dart.edge_fiber
+-/
 
 variable (G)
 
@@ -105,7 +101,7 @@ variable (G)
 lean 3 declaration is
   forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : DecidableEq.{succ u1} V] (e : Sym2.{u1} V), (Membership.Mem.{u1, u1} (Sym2.{u1} V) (Set.{u1} (Sym2.{u1} V)) (Set.hasMem.{u1} (Sym2.{u1} V)) e (coeFn.{succ u1, succ u1} (OrderEmbedding.{u1, u1} (SimpleGraph.{u1} V) (Set.{u1} (Sym2.{u1} V)) (SimpleGraph.hasLe.{u1} V) (Set.hasLe.{u1} (Sym2.{u1} V))) (fun (_x : RelEmbedding.{u1, u1} (SimpleGraph.{u1} V) (Set.{u1} (Sym2.{u1} V)) (LE.le.{u1} (SimpleGraph.{u1} V) (SimpleGraph.hasLe.{u1} V)) (LE.le.{u1} (Set.{u1} (Sym2.{u1} V)) (Set.hasLe.{u1} (Sym2.{u1} V)))) => (SimpleGraph.{u1} V) -> (Set.{u1} (Sym2.{u1} V))) (RelEmbedding.hasCoeToFun.{u1, u1} (SimpleGraph.{u1} V) (Set.{u1} (Sym2.{u1} V)) (LE.le.{u1} (SimpleGraph.{u1} V) (SimpleGraph.hasLe.{u1} V)) (LE.le.{u1} (Set.{u1} (Sym2.{u1} V)) (Set.hasLe.{u1} (Sym2.{u1} V)))) (SimpleGraph.edgeSetEmbedding.{u1} V) G)) -> (Eq.{1} Nat (Finset.card.{u1} (SimpleGraph.Dart.{u1} V G) (Finset.filter.{u1} (SimpleGraph.Dart.{u1} V G) (fun (d : SimpleGraph.Dart.{u1} V G) => Eq.{succ u1} (Sym2.{u1} V) (SimpleGraph.Dart.edge.{u1} V G d) e) (fun (a : SimpleGraph.Dart.{u1} V G) => Quotient.decidableEq.{succ u1} (Prod.{u1, u1} V V) (Sym2.Rel.setoid.{u1} V) (fun (a : Prod.{u1, u1} V V) (b : Prod.{u1, u1} V V) => Sym2.Rel.decidableRel.{u1} V (fun (a : V) (b : V) => _inst_3 a b) a b) (SimpleGraph.Dart.edge.{u1} V G a) e) (Finset.univ.{u1} (SimpleGraph.Dart.{u1} V G) (SimpleGraph.Dart.fintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))
 but is expected to have type
-  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : DecidableEq.{succ u1} V] (e : Sym2.{u1} V), (Membership.mem.{u1, u1} (Sym2.{u1} V) (Set.{u1} (Sym2.{u1} V)) (Set.instMembershipSet.{u1} (Sym2.{u1} V)) e (SimpleGraph.edgeSet.{u1} V G)) -> (Eq.{1} Nat (Finset.card.{u1} (SimpleGraph.Dart.{u1} V G) (Finset.filter.{u1} (SimpleGraph.Dart.{u1} V G) (fun (d : SimpleGraph.Dart.{u1} V G) => Eq.{succ u1} (Sym2.{u1} V) (SimpleGraph.Dart.edge.{u1} V G d) e) (fun (a : SimpleGraph.Dart.{u1} V G) => Sym2.instDecidableEqSym2.{u1} V (fun (a : V) (b : V) => _inst_3 a b) (SimpleGraph.Dart.edge.{u1} V G a) e) (Finset.univ.{u1} (SimpleGraph.Dart.{u1} V G) (SimpleGraph.Dart.fintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))
+  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : DecidableEq.{succ u1} V] (e : Sym2.{u1} V), (Membership.mem.{u1, u1} (Sym2.{u1} V) (Set.{u1} (Sym2.{u1} V)) (Set.instMembershipSet.{u1} (Sym2.{u1} V)) e (SimpleGraph.edgeSet.{u1} V G)) -> (Eq.{1} Nat (Finset.card.{u1} (SimpleGraph.Dart.{u1} V G) (Finset.filter.{u1} (SimpleGraph.Dart.{u1} V G) (fun (d : SimpleGraph.Dart.{u1} V G) => Eq.{succ u1} (Sym2.{u1} V) (SimpleGraph.Dart.edge.{u1} V G d) e) (fun (a : SimpleGraph.Dart.{u1} V G) => Quotient.decidableEq.{succ u1} (Prod.{u1, u1} V V) (Sym2.Rel.setoid.{u1} V) (fun (a : Prod.{u1, u1} V V) (b : Prod.{u1, u1} V V) => (fun (a : Prod.{u1, u1} V V) (b : Prod.{u1, u1} V V) => Sym2.instRelDecidable'.{u1} V (fun (a : V) (b : V) => _inst_3 a b) a b) a b) (SimpleGraph.Dart.edge.{u1} V G a) e) (Finset.univ.{u1} (SimpleGraph.Dart.{u1} V G) (SimpleGraph.Dart.fintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))
 Case conversion may be inaccurate. Consider using '#align simple_graph.dart_edge_fiber_card SimpleGraph.dart_edge_fiber_cardₓ'. -/
 theorem dart_edge_fiber_card (e : Sym2 V) (h : e ∈ G.edgeSetEmbedding) :
     (univ.filterₓ fun d : G.Dart => d.edge = e).card = 2 :=

90659cbe

bump to nightly-2023-03-24-02

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

9cc39ff3

Diff

@@ -122,7 +122,7 @@ theorem dart_edge_fiber_card (e : Sym2 V) (h : e ∈ G.edgeSetEmbedding) :
 lean 3 declaration is
   forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : DecidableEq.{succ u1} V], Eq.{1} Nat (Fintype.card.{u1} (SimpleGraph.Dart.{u1} V G) (SimpleGraph.Dart.fintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b))) (HMul.hMul.{0, 0, 0} Nat Nat Nat (instHMul.{0} Nat Nat.hasMul) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) (Finset.card.{u1} (Sym2.{u1} V) (SimpleGraph.edgeFinset.{u1} V G (SimpleGraph.fintypeEdgeSet.{u1} V G (fun (a : V) (b : V) => _inst_3 a b) _inst_1 (fun (a : V) (b : V) => _inst_2 a b)))))
 but is expected to have type
-  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : Fintype.{u1} (Sym2.{u1} V)] [inst._@.Mathlib.Combinatorics.SimpleGraph.DegreeSum._hyg.669 : DecidableEq.{succ u1} V], Eq.{1} Nat (Fintype.card.{u1} (SimpleGraph.Dart.{u1} V G) (SimpleGraph.Dart.fintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b))) (HMul.hMul.{0, 0, 0} Nat Nat Nat (instHMul.{0} Nat instMulNat) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) (Finset.card.{u1} (Sym2.{u1} V) (SimpleGraph.edgeFinset.{u1} V G (SimpleGraph.fintypeEdgeSet.{u1} V G _inst_3 (fun (a : V) (b : V) => _inst_2 a b)))))
+  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : Fintype.{u1} (Sym2.{u1} V)] [inst._@.Mathlib.Combinatorics.SimpleGraph.DegreeSum._hyg.684 : DecidableEq.{succ u1} V], Eq.{1} Nat (Fintype.card.{u1} (SimpleGraph.Dart.{u1} V G) (SimpleGraph.Dart.fintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b))) (HMul.hMul.{0, 0, 0} Nat Nat Nat (instHMul.{0} Nat instMulNat) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) (Finset.card.{u1} (Sym2.{u1} V) (SimpleGraph.edgeFinset.{u1} V G (SimpleGraph.fintypeEdgeSet.{u1} V G _inst_3 (fun (a : V) (b : V) => _inst_2 a b)))))
 Case conversion may be inaccurate. Consider using '#align simple_graph.dart_card_eq_twice_card_edges SimpleGraph.dart_card_eq_twice_card_edgesₓ'. -/
 theorem dart_card_eq_twice_card_edges : Fintype.card G.Dart = 2 * G.edgeFinset.card :=
   by
@@ -141,7 +141,7 @@ theorem dart_card_eq_twice_card_edges : Fintype.card G.Dart = 2 * G.edgeFinset.c
 lean 3 declaration is
   forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : DecidableEq.{succ u1} V], Eq.{1} Nat (Finset.sum.{0, u1} Nat V Nat.addCommMonoid (Finset.univ.{u1} V _inst_1) (fun (v : V) => SimpleGraph.degree.{u1} V G v (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b) v))) (HMul.hMul.{0, 0, 0} Nat Nat Nat (instHMul.{0} Nat Nat.hasMul) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) (Finset.card.{u1} (Sym2.{u1} V) (SimpleGraph.edgeFinset.{u1} V G (SimpleGraph.fintypeEdgeSet.{u1} V G (fun (a : V) (b : V) => _inst_3 a b) _inst_1 (fun (a : V) (b : V) => _inst_2 a b)))))
 but is expected to have type
-  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : Fintype.{u1} (Sym2.{u1} V)] [inst._@.Mathlib.Combinatorics.SimpleGraph.DegreeSum._hyg.868 : DecidableEq.{succ u1} V], Eq.{1} Nat (Finset.sum.{0, u1} Nat V Nat.addCommMonoid (Finset.univ.{u1} V _inst_1) (fun (v : V) => SimpleGraph.degree.{u1} V G v (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b) v))) (HMul.hMul.{0, 0, 0} Nat Nat Nat (instHMul.{0} Nat instMulNat) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) (Finset.card.{u1} (Sym2.{u1} V) (SimpleGraph.edgeFinset.{u1} V G (SimpleGraph.fintypeEdgeSet.{u1} V G _inst_3 (fun (a : V) (b : V) => _inst_2 a b)))))
+  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : Fintype.{u1} (Sym2.{u1} V)] [inst._@.Mathlib.Combinatorics.SimpleGraph.DegreeSum._hyg.883 : DecidableEq.{succ u1} V], Eq.{1} Nat (Finset.sum.{0, u1} Nat V Nat.addCommMonoid (Finset.univ.{u1} V _inst_1) (fun (v : V) => SimpleGraph.degree.{u1} V G v (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b) v))) (HMul.hMul.{0, 0, 0} Nat Nat Nat (instHMul.{0} Nat instMulNat) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) (Finset.card.{u1} (Sym2.{u1} V) (SimpleGraph.edgeFinset.{u1} V G (SimpleGraph.fintypeEdgeSet.{u1} V G _inst_3 (fun (a : V) (b : V) => _inst_2 a b)))))
 Case conversion may be inaccurate. Consider using '#align simple_graph.sum_degrees_eq_twice_card_edges SimpleGraph.sum_degrees_eq_twice_card_edgesₓ'. -/
 /-- The degree-sum formula.  This is also known as the handshaking lemma, which might
 more specifically refer to `simple_graph.even_card_odd_degree_vertices`. -/

90659cbe

bump to nightly-2023-03-23-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/57e09a1296bfb4330ddf6624f1028ba186117d82

372772ba

Diff

@@ -55,6 +55,7 @@ section DegreeSum
 
 variable [Fintype V] [DecidableRel G.Adj]
 
+#print SimpleGraph.dart_fst_fiber /-
 theorem dart_fst_fiber [DecidableEq V] (v : V) :
     (univ.filterₓ fun d : G.Dart => d.fst = v) = univ.image (G.dartOfNeighborSet v) :=
   by
@@ -66,22 +67,33 @@ theorem dart_fst_fiber [DecidableEq V] (v : V) :
   · rintro ⟨e, he, rfl⟩
     rfl
 #align simple_graph.dart_fst_fiber SimpleGraph.dart_fst_fiber
+-/
 
+#print SimpleGraph.dart_fst_fiber_card_eq_degree /-
 theorem dart_fst_fiber_card_eq_degree [DecidableEq V] (v : V) :
     (univ.filterₓ fun d : G.Dart => d.fst = v).card = G.degree v := by
   simpa only [dart_fst_fiber, Finset.card_univ, card_neighbor_set_eq_degree] using
     card_image_of_injective univ (G.dart_of_neighbor_set_injective v)
 #align simple_graph.dart_fst_fiber_card_eq_degree SimpleGraph.dart_fst_fiber_card_eq_degree
+-/
 
+#print SimpleGraph.dart_card_eq_sum_degrees /-
 theorem dart_card_eq_sum_degrees : Fintype.card G.Dart = ∑ v, G.degree v :=
   by
   haveI := Classical.decEq V
   simp only [← card_univ, ← dart_fst_fiber_card_eq_degree]
   exact card_eq_sum_card_fiberwise (by simp)
 #align simple_graph.dart_card_eq_sum_degrees SimpleGraph.dart_card_eq_sum_degrees
+-/
 
 variable {G} [DecidableEq V]
 
+/- warning: simple_graph.dart.edge_fiber -> SimpleGraph.Dart.edge_fiber is a dubious translation:
+lean 3 declaration is
+  forall {V : Type.{u1}} {G : SimpleGraph.{u1} V} [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : DecidableEq.{succ u1} V] (d : SimpleGraph.Dart.{u1} V G), Eq.{succ u1} (Finset.{u1} (SimpleGraph.Dart.{u1} V G)) (Finset.filter.{u1} (SimpleGraph.Dart.{u1} V G) (fun (d' : SimpleGraph.Dart.{u1} V G) => Eq.{succ u1} (Sym2.{u1} V) (SimpleGraph.Dart.edge.{u1} V G d') (SimpleGraph.Dart.edge.{u1} V G d)) (fun (a : SimpleGraph.Dart.{u1} V G) => Quotient.decidableEq.{succ u1} (Prod.{u1, u1} V V) (Sym2.Rel.setoid.{u1} V) (fun (a : Prod.{u1, u1} V V) (b : Prod.{u1, u1} V V) => Sym2.Rel.decidableRel.{u1} V (fun (a : V) (b : V) => _inst_3 a b) a b) (SimpleGraph.Dart.edge.{u1} V G a) (SimpleGraph.Dart.edge.{u1} V G d)) (Finset.univ.{u1} (SimpleGraph.Dart.{u1} V G) (SimpleGraph.Dart.fintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b)))) (Insert.insert.{u1, u1} (SimpleGraph.Dart.{u1} V G) (Finset.{u1} (SimpleGraph.Dart.{u1} V G)) (Finset.hasInsert.{u1} (SimpleGraph.Dart.{u1} V G) (fun (a : SimpleGraph.Dart.{u1} V G) (b : SimpleGraph.Dart.{u1} V G) => SimpleGraph.Dart.decidableEq.{u1} V (fun (a : V) (b : V) => _inst_3 a b) G a b)) d (Singleton.singleton.{u1, u1} (SimpleGraph.Dart.{u1} V G) (Finset.{u1} (SimpleGraph.Dart.{u1} V G)) (Finset.hasSingleton.{u1} (SimpleGraph.Dart.{u1} V G)) (SimpleGraph.Dart.symm.{u1} V G d)))
+but is expected to have type
+  forall {V : Type.{u1}} {G : SimpleGraph.{u1} V} [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : DecidableEq.{succ u1} V] (d : SimpleGraph.Dart.{u1} V G), Eq.{succ u1} (Finset.{u1} (SimpleGraph.Dart.{u1} V G)) (Finset.filter.{u1} (SimpleGraph.Dart.{u1} V G) (fun (d' : SimpleGraph.Dart.{u1} V G) => Eq.{succ u1} (Sym2.{u1} V) (SimpleGraph.Dart.edge.{u1} V G d') (SimpleGraph.Dart.edge.{u1} V G d)) (fun (a : SimpleGraph.Dart.{u1} V G) => Sym2.instDecidableEqSym2.{u1} V (fun (a : V) (b : V) => _inst_3 a b) (SimpleGraph.Dart.edge.{u1} V G a) (SimpleGraph.Dart.edge.{u1} V G d)) (Finset.univ.{u1} (SimpleGraph.Dart.{u1} V G) (SimpleGraph.Dart.fintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b)))) (Insert.insert.{u1, u1} (SimpleGraph.Dart.{u1} V G) (Finset.{u1} (SimpleGraph.Dart.{u1} V G)) (Finset.instInsertFinset.{u1} (SimpleGraph.Dart.{u1} V G) (fun (a : SimpleGraph.Dart.{u1} V G) (b : SimpleGraph.Dart.{u1} V G) => SimpleGraph.instDecidableEqDart.{u1} V G (fun (a : V) (b : V) => _inst_3 a b) a b)) d (Singleton.singleton.{u1, u1} (SimpleGraph.Dart.{u1} V G) (Finset.{u1} (SimpleGraph.Dart.{u1} V G)) (Finset.instSingletonFinset.{u1} (SimpleGraph.Dart.{u1} V G)) (SimpleGraph.Dart.symm.{u1} V G d)))
+Case conversion may be inaccurate. Consider using '#align simple_graph.dart.edge_fiber SimpleGraph.Dart.edge_fiberₓ'. -/
 theorem Dart.edge_fiber (d : G.Dart) :
     (univ.filterₓ fun d' : G.Dart => d'.edge = d.edge) = {d, d.symm} :=
   Finset.ext fun d' => by simpa using dart_edge_eq_iff d' d
@@ -89,6 +101,12 @@ theorem Dart.edge_fiber (d : G.Dart) :
 
 variable (G)
 
+/- warning: simple_graph.dart_edge_fiber_card -> SimpleGraph.dart_edge_fiber_card is a dubious translation:
+lean 3 declaration is
+  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : DecidableEq.{succ u1} V] (e : Sym2.{u1} V), (Membership.Mem.{u1, u1} (Sym2.{u1} V) (Set.{u1} (Sym2.{u1} V)) (Set.hasMem.{u1} (Sym2.{u1} V)) e (coeFn.{succ u1, succ u1} (OrderEmbedding.{u1, u1} (SimpleGraph.{u1} V) (Set.{u1} (Sym2.{u1} V)) (SimpleGraph.hasLe.{u1} V) (Set.hasLe.{u1} (Sym2.{u1} V))) (fun (_x : RelEmbedding.{u1, u1} (SimpleGraph.{u1} V) (Set.{u1} (Sym2.{u1} V)) (LE.le.{u1} (SimpleGraph.{u1} V) (SimpleGraph.hasLe.{u1} V)) (LE.le.{u1} (Set.{u1} (Sym2.{u1} V)) (Set.hasLe.{u1} (Sym2.{u1} V)))) => (SimpleGraph.{u1} V) -> (Set.{u1} (Sym2.{u1} V))) (RelEmbedding.hasCoeToFun.{u1, u1} (SimpleGraph.{u1} V) (Set.{u1} (Sym2.{u1} V)) (LE.le.{u1} (SimpleGraph.{u1} V) (SimpleGraph.hasLe.{u1} V)) (LE.le.{u1} (Set.{u1} (Sym2.{u1} V)) (Set.hasLe.{u1} (Sym2.{u1} V)))) (SimpleGraph.edgeSetEmbedding.{u1} V) G)) -> (Eq.{1} Nat (Finset.card.{u1} (SimpleGraph.Dart.{u1} V G) (Finset.filter.{u1} (SimpleGraph.Dart.{u1} V G) (fun (d : SimpleGraph.Dart.{u1} V G) => Eq.{succ u1} (Sym2.{u1} V) (SimpleGraph.Dart.edge.{u1} V G d) e) (fun (a : SimpleGraph.Dart.{u1} V G) => Quotient.decidableEq.{succ u1} (Prod.{u1, u1} V V) (Sym2.Rel.setoid.{u1} V) (fun (a : Prod.{u1, u1} V V) (b : Prod.{u1, u1} V V) => Sym2.Rel.decidableRel.{u1} V (fun (a : V) (b : V) => _inst_3 a b) a b) (SimpleGraph.Dart.edge.{u1} V G a) e) (Finset.univ.{u1} (SimpleGraph.Dart.{u1} V G) (SimpleGraph.Dart.fintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))
+but is expected to have type
+  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : DecidableEq.{succ u1} V] (e : Sym2.{u1} V), (Membership.mem.{u1, u1} (Sym2.{u1} V) (Set.{u1} (Sym2.{u1} V)) (Set.instMembershipSet.{u1} (Sym2.{u1} V)) e (SimpleGraph.edgeSet.{u1} V G)) -> (Eq.{1} Nat (Finset.card.{u1} (SimpleGraph.Dart.{u1} V G) (Finset.filter.{u1} (SimpleGraph.Dart.{u1} V G) (fun (d : SimpleGraph.Dart.{u1} V G) => Eq.{succ u1} (Sym2.{u1} V) (SimpleGraph.Dart.edge.{u1} V G d) e) (fun (a : SimpleGraph.Dart.{u1} V G) => Sym2.instDecidableEqSym2.{u1} V (fun (a : V) (b : V) => _inst_3 a b) (SimpleGraph.Dart.edge.{u1} V G a) e) (Finset.univ.{u1} (SimpleGraph.Dart.{u1} V G) (SimpleGraph.Dart.fintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))
+Case conversion may be inaccurate. Consider using '#align simple_graph.dart_edge_fiber_card SimpleGraph.dart_edge_fiber_cardₓ'. -/
 theorem dart_edge_fiber_card (e : Sym2 V) (h : e ∈ G.edgeSetEmbedding) :
     (univ.filterₓ fun d : G.Dart => d.edge = e).card = 2 :=
   by
@@ -100,6 +118,12 @@ theorem dart_edge_fiber_card (e : Sym2 V) (h : e ∈ G.edgeSetEmbedding) :
   exact d.symm_ne.symm
 #align simple_graph.dart_edge_fiber_card SimpleGraph.dart_edge_fiber_card
 
+/- warning: simple_graph.dart_card_eq_twice_card_edges -> SimpleGraph.dart_card_eq_twice_card_edges is a dubious translation:
+lean 3 declaration is
+  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : DecidableEq.{succ u1} V], Eq.{1} Nat (Fintype.card.{u1} (SimpleGraph.Dart.{u1} V G) (SimpleGraph.Dart.fintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b))) (HMul.hMul.{0, 0, 0} Nat Nat Nat (instHMul.{0} Nat Nat.hasMul) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) (Finset.card.{u1} (Sym2.{u1} V) (SimpleGraph.edgeFinset.{u1} V G (SimpleGraph.fintypeEdgeSet.{u1} V G (fun (a : V) (b : V) => _inst_3 a b) _inst_1 (fun (a : V) (b : V) => _inst_2 a b)))))
+but is expected to have type
+  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : Fintype.{u1} (Sym2.{u1} V)] [inst._@.Mathlib.Combinatorics.SimpleGraph.DegreeSum._hyg.669 : DecidableEq.{succ u1} V], Eq.{1} Nat (Fintype.card.{u1} (SimpleGraph.Dart.{u1} V G) (SimpleGraph.Dart.fintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b))) (HMul.hMul.{0, 0, 0} Nat Nat Nat (instHMul.{0} Nat instMulNat) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) (Finset.card.{u1} (Sym2.{u1} V) (SimpleGraph.edgeFinset.{u1} V G (SimpleGraph.fintypeEdgeSet.{u1} V G _inst_3 (fun (a : V) (b : V) => _inst_2 a b)))))
+Case conversion may be inaccurate. Consider using '#align simple_graph.dart_card_eq_twice_card_edges SimpleGraph.dart_card_eq_twice_card_edgesₓ'. -/
 theorem dart_card_eq_twice_card_edges : Fintype.card G.Dart = 2 * G.edgeFinset.card :=
   by
   rw [← card_univ]
@@ -113,6 +137,12 @@ theorem dart_card_eq_twice_card_edges : Fintype.card G.Dart = 2 * G.edgeFinset.c
   rwa [← mem_edge_finset]
 #align simple_graph.dart_card_eq_twice_card_edges SimpleGraph.dart_card_eq_twice_card_edges
 
+/- warning: simple_graph.sum_degrees_eq_twice_card_edges -> SimpleGraph.sum_degrees_eq_twice_card_edges is a dubious translation:
+lean 3 declaration is
+  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : DecidableEq.{succ u1} V], Eq.{1} Nat (Finset.sum.{0, u1} Nat V Nat.addCommMonoid (Finset.univ.{u1} V _inst_1) (fun (v : V) => SimpleGraph.degree.{u1} V G v (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b) v))) (HMul.hMul.{0, 0, 0} Nat Nat Nat (instHMul.{0} Nat Nat.hasMul) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) (Finset.card.{u1} (Sym2.{u1} V) (SimpleGraph.edgeFinset.{u1} V G (SimpleGraph.fintypeEdgeSet.{u1} V G (fun (a : V) (b : V) => _inst_3 a b) _inst_1 (fun (a : V) (b : V) => _inst_2 a b)))))
+but is expected to have type
+  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] [_inst_3 : Fintype.{u1} (Sym2.{u1} V)] [inst._@.Mathlib.Combinatorics.SimpleGraph.DegreeSum._hyg.868 : DecidableEq.{succ u1} V], Eq.{1} Nat (Finset.sum.{0, u1} Nat V Nat.addCommMonoid (Finset.univ.{u1} V _inst_1) (fun (v : V) => SimpleGraph.degree.{u1} V G v (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b) v))) (HMul.hMul.{0, 0, 0} Nat Nat Nat (instHMul.{0} Nat instMulNat) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) (Finset.card.{u1} (Sym2.{u1} V) (SimpleGraph.edgeFinset.{u1} V G (SimpleGraph.fintypeEdgeSet.{u1} V G _inst_3 (fun (a : V) (b : V) => _inst_2 a b)))))
+Case conversion may be inaccurate. Consider using '#align simple_graph.sum_degrees_eq_twice_card_edges SimpleGraph.sum_degrees_eq_twice_card_edgesₓ'. -/
 /-- The degree-sum formula.  This is also known as the handshaking lemma, which might
 more specifically refer to `simple_graph.even_card_odd_degree_vertices`. -/
 theorem sum_degrees_eq_twice_card_edges : (∑ v, G.degree v) = 2 * G.edgeFinset.card :=
@@ -121,6 +151,12 @@ theorem sum_degrees_eq_twice_card_edges : (∑ v, G.degree v) = 2 * G.edgeFinset
 
 end DegreeSum
 
+/- warning: simple_graph.even_card_odd_degree_vertices -> SimpleGraph.even_card_odd_degree_vertices is a dubious translation:
+lean 3 declaration is
+  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)], Even.{0} Nat Nat.hasAdd (Finset.card.{u1} V (Finset.filter.{u1} V (fun (v : V) => Odd.{0} Nat Nat.semiring (SimpleGraph.degree.{u1} V G v (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b) v))) (fun (a : V) => Nat.Odd.decidablePred (SimpleGraph.degree.{u1} V G a (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b) a))) (Finset.univ.{u1} V _inst_1)))
+but is expected to have type
+  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)], Even.{0} Nat instAddNat (Finset.card.{u1} V (Finset.filter.{u1} V (fun (v : V) => Odd.{0} Nat Nat.semiring (SimpleGraph.degree.{u1} V G v (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b) v))) (fun (a : V) => Nat.instDecidablePredNatOddSemiring (SimpleGraph.degree.{u1} V G a (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_2 a b) a))) (Finset.univ.{u1} V _inst_1)))
+Case conversion may be inaccurate. Consider using '#align simple_graph.even_card_odd_degree_vertices SimpleGraph.even_card_odd_degree_verticesₓ'. -/
 /-- The handshaking lemma.  See also `simple_graph.sum_degrees_eq_twice_card_edges`. -/
 theorem even_card_odd_degree_vertices [Fintype V] [DecidableRel G.Adj] :
     Even (univ.filterₓ fun v => Odd (G.degree v)).card := by
@@ -140,6 +176,12 @@ theorem even_card_odd_degree_vertices [Fintype V] [DecidableRel G.Adj] :
       trivial
 #align simple_graph.even_card_odd_degree_vertices SimpleGraph.even_card_odd_degree_vertices
 
+/- warning: simple_graph.odd_card_odd_degree_vertices_ne -> SimpleGraph.odd_card_odd_degree_vertices_ne is a dubious translation:
+lean 3 declaration is
+  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableEq.{succ u1} V] [_inst_3 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] (v : V), (Odd.{0} Nat Nat.semiring (SimpleGraph.degree.{u1} V G v (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_3 a b) v))) -> (Odd.{0} Nat Nat.semiring (Finset.card.{u1} V (Finset.filter.{u1} V (fun (w : V) => And (Ne.{succ u1} V w v) (Odd.{0} Nat Nat.semiring (SimpleGraph.degree.{u1} V G w (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_3 a b) w)))) (fun (a : V) => And.decidable (Ne.{succ u1} V a v) (Odd.{0} Nat Nat.semiring (SimpleGraph.degree.{u1} V G a (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_3 a b) a))) (Ne.decidable.{succ u1} V (fun (a : V) (b : V) => _inst_2 a b) a v) (Nat.Odd.decidablePred (SimpleGraph.degree.{u1} V G a (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_3 a b) a)))) (Finset.univ.{u1} V _inst_1))))
+but is expected to have type
+  forall {V : Type.{u1}} (G : SimpleGraph.{u1} V) [_inst_1 : Fintype.{u1} V] [_inst_2 : DecidableEq.{succ u1} V] [_inst_3 : DecidableRel.{succ u1} V (SimpleGraph.Adj.{u1} V G)] (v : V), (Odd.{0} Nat Nat.semiring (SimpleGraph.degree.{u1} V G v (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_3 a b) v))) -> (Odd.{0} Nat Nat.semiring (Finset.card.{u1} V (Finset.filter.{u1} V (fun (w : V) => And (Ne.{succ u1} V w v) (Odd.{0} Nat Nat.semiring (SimpleGraph.degree.{u1} V G w (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_3 a b) w)))) (fun (a : V) => instDecidableAnd (Ne.{succ u1} V a v) (Odd.{0} Nat Nat.semiring (SimpleGraph.degree.{u1} V G a (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_3 a b) a))) (instDecidableNot (Eq.{succ u1} V a v) (_inst_2 a v)) (Nat.instDecidablePredNatOddSemiring (SimpleGraph.degree.{u1} V G a (SimpleGraph.neighborSetFintype.{u1} V G _inst_1 (fun (a : V) (b : V) => _inst_3 a b) a)))) (Finset.univ.{u1} V _inst_1))))
+Case conversion may be inaccurate. Consider using '#align simple_graph.odd_card_odd_degree_vertices_ne SimpleGraph.odd_card_odd_degree_vertices_neₓ'. -/
 theorem odd_card_odd_degree_vertices_ne [Fintype V] [DecidableEq V] [DecidableRel G.Adj] (v : V)
     (h : Odd (G.degree v)) : Odd (univ.filterₓ fun w => w ≠ v ∧ Odd (G.degree w)).card :=
   by
@@ -166,6 +208,7 @@ theorem odd_card_odd_degree_vertices_ne [Fintype V] [DecidableEq V] [DecidableRe
   · simpa only [true_and_iff, mem_filter, mem_univ]
 #align simple_graph.odd_card_odd_degree_vertices_ne SimpleGraph.odd_card_odd_degree_vertices_ne
 
+#print SimpleGraph.exists_ne_odd_degree_of_exists_odd_degree /-
 theorem exists_ne_odd_degree_of_exists_odd_degree [Fintype V] [DecidableRel G.Adj] (v : V)
     (h : Odd (G.degree v)) : ∃ w : V, w ≠ v ∧ Odd (G.degree w) :=
   by
@@ -179,6 +222,7 @@ theorem exists_ne_odd_degree_of_exists_odd_degree [Fintype V] [DecidableRel G.Ad
   simp only [true_and_iff, mem_filter, mem_univ, Ne.def] at hw
   exact ⟨w, hw⟩
 #align simple_graph.exists_ne_odd_degree_of_exists_odd_degree SimpleGraph.exists_ne_odd_degree_of_exists_odd_degree
+-/
 
 end SimpleGraph

90659cbe

bump to nightly-2023-03-11-16

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

cd44fb92

Diff

@@ -126,7 +126,7 @@ theorem even_card_odd_degree_vertices [Fintype V] [DecidableRel G.Adj] :
     Even (univ.filterₓ fun v => Odd (G.degree v)).card := by
   classical
     have h := congr_arg (fun n => ↑n : ℕ → ZMod 2) G.sum_degrees_eq_twice_card_edges
-    simp only [ZMod.nat_cast_self, zero_mul, Nat.cast_mul] at h
+    simp only [ZMod.nat_cast_self, MulZeroClass.zero_mul, Nat.cast_mul] at h
     rw [Nat.cast_sum, ← sum_filter_ne_zero] at h
     rw [@sum_congr _ _ _ _ (fun v => (G.degree v : ZMod 2)) (fun v => (1 : ZMod 2)) _ rfl] at h
     · simp only [filter_congr_decidable, mul_one, nsmul_eq_mul, sum_const, Ne.def] at h

90659cbe

bump to nightly-2023-02-25-00

mathlib commit https://github.com/leanprover-community/mathlib/commit/22131150f88a2d125713ffa0f4693e3355b1eb49

aca219f8

Diff

@@ -89,7 +89,7 @@ theorem Dart.edge_fiber (d : G.Dart) :
 
 variable (G)
 
-theorem dart_edge_fiber_card (e : Sym2 V) (h : e ∈ G.edgeSet) :
+theorem dart_edge_fiber_card (e : Sym2 V) (h : e ∈ G.edgeSetEmbedding) :
     (univ.filterₓ fun d : G.Dart => d.edge = e).card = 2 :=
   by
   refine' Sym2.ind (fun v w h => _) e h

90659cbe

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

90659cbe

chore: Rename nat_cast/int_cast/rat_cast to natCast/intCast/ratCast (#11486)

Now that I am defining NNRat.cast, I want a definitive answer to this naming issue. Plenty of lemmas in mathlib already use natCast/intCast/ratCast over nat_cast/int_cast/rat_cast, and this matches with the general expectation that underscore-separated name parts correspond to a single declaration.

145460b9

Diff

@@ -122,7 +122,7 @@ theorem even_card_odd_degree_vertices [Fintype V] [DecidableRel G.Adj] :
     Even (univ.filter fun v => Odd (G.degree v)).card := by
   classical
     have h := congr_arg (fun n => ↑n : ℕ → ZMod 2) G.sum_degrees_eq_twice_card_edges
-    simp only [ZMod.nat_cast_self, zero_mul, Nat.cast_mul] at h
+    simp only [ZMod.natCast_self, zero_mul, Nat.cast_mul] at h
     rw [Nat.cast_sum, ← sum_filter_ne_zero] at h
     rw [@sum_congr _ _ _ _ (fun v => (G.degree v : ZMod 2)) (fun _v => (1 : ZMod 2)) _ rfl] at h
     · simp only [filter_congr, mul_one, nsmul_eq_mul, sum_const, Ne] at h

90659cbe

chore: avoid Ne.def (adaptation for nightly-2024-03-27) (#11801)

1b40c7bc

Diff

@@ -125,12 +125,12 @@ theorem even_card_odd_degree_vertices [Fintype V] [DecidableRel G.Adj] :
     simp only [ZMod.nat_cast_self, zero_mul, Nat.cast_mul] at h
     rw [Nat.cast_sum, ← sum_filter_ne_zero] at h
     rw [@sum_congr _ _ _ _ (fun v => (G.degree v : ZMod 2)) (fun _v => (1 : ZMod 2)) _ rfl] at h
-    · simp only [filter_congr, mul_one, nsmul_eq_mul, sum_const, Ne.def] at h
+    · simp only [filter_congr, mul_one, nsmul_eq_mul, sum_const, Ne] at h
       rw [← ZMod.eq_zero_iff_even]
       convert h
       exact ZMod.ne_zero_iff_odd.symm
     · intro v
-      simp only [true_and_iff, mem_filter, mem_univ, Ne.def]
+      simp only [true_and_iff, mem_filter, mem_univ, Ne]
       rw [ZMod.eq_zero_iff_even, ZMod.eq_one_iff_odd, Nat.odd_iff_not_even, imp_self]
       trivial
 #align simple_graph.even_card_odd_degree_vertices SimpleGraph.even_card_odd_degree_vertices
@@ -165,7 +165,7 @@ theorem exists_ne_odd_degree_of_exists_odd_degree [Fintype V] [DecidableRel G.Ad
     rw [hg]
     apply Nat.succ_pos
   rcases card_pos.mp hg' with ⟨w, hw⟩
-  simp only [true_and_iff, mem_filter, mem_univ, Ne.def] at hw
+  simp only [true_and_iff, mem_filter, mem_univ, Ne] at hw
   exact ⟨w, hw⟩
 #align simple_graph.exists_ne_odd_degree_of_exists_odd_degree SimpleGraph.exists_ne_odd_degree_of_exists_odd_degree

90659cbe

chore: one golf using omega (#11319)

4feda97f

Diff

@@ -153,7 +153,7 @@ theorem odd_card_odd_degree_vertices_ne [Fintype V] [DecidableEq V] [DecidableRe
   · refine' ⟨k - 1, tsub_eq_of_eq_add <| hg.trans _⟩
     rw [add_assoc, one_add_one_eq_two, ← Nat.mul_succ, ← two_mul]
     congr
-    exact (tsub_add_cancel_of_le <| Nat.succ_le_iff.2 hk).symm
+    omega
   · simpa only [true_and_iff, mem_filter, mem_univ]
 #align simple_graph.odd_card_odd_degree_vertices_ne SimpleGraph.odd_card_odd_degree_vertices_ne

90659cbe

chore(SimpleGraph/DegreeSum): drop some DecidableEq assumptions (#10443)

62ac0bdd

Diff

@@ -79,16 +79,16 @@ theorem dart_card_eq_sum_degrees : Fintype.card G.Dart = ∑ v, G.degree v := by
   exact card_eq_sum_card_fiberwise (by simp)
 #align simple_graph.dart_card_eq_sum_degrees SimpleGraph.dart_card_eq_sum_degrees
 
-variable {G} [DecidableEq V]
+variable {G}
 
-theorem Dart.edge_fiber (d : G.Dart) :
+theorem Dart.edge_fiber [DecidableEq V] (d : G.Dart) :
     (univ.filter fun d' : G.Dart => d'.edge = d.edge) = {d, d.symm} :=
   Finset.ext fun d' => by simpa using dart_edge_eq_iff d' d
 #align simple_graph.dart.edge_fiber SimpleGraph.Dart.edge_fiber
 
 variable (G)
 
-theorem dart_edge_fiber_card (e : Sym2 V) (h : e ∈ G.edgeSet) :
+theorem dart_edge_fiber_card [DecidableEq V] (e : Sym2 V) (h : e ∈ G.edgeSet) :
     (univ.filter fun d : G.Dart => d.edge = e).card = 2 := by
   refine' Sym2.ind (fun v w h => _) e h
   let d : G.Dart := ⟨(v, w), h⟩
@@ -99,6 +99,7 @@ theorem dart_edge_fiber_card (e : Sym2 V) (h : e ∈ G.edgeSet) :
 #align simple_graph.dart_edge_fiber_card SimpleGraph.dart_edge_fiber_card
 
 theorem dart_card_eq_twice_card_edges : Fintype.card G.Dart = 2 * G.edgeFinset.card := by
+  classical
   rw [← card_univ]
   rw [@card_eq_sum_card_fiberwise _ _ _ Dart.edge _ G.edgeFinset fun d _h =>
       by rw [mem_edgeFinset]; apply Dart.edge_mem]

90659cbe

refactor: split out graph darts (#10312)

Continuation from #10123. Combinatorics.SimpleGraph.Basic is now under 1000 lines.

bbbf0378

Diff

@@ -3,6 +3,7 @@ Copyright (c) 2020 Kyle Miller. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kyle Miller
 -/
+import Mathlib.Combinatorics.SimpleGraph.Dart
 import Mathlib.Combinatorics.SimpleGraph.Finite
 import Mathlib.Algebra.BigOperators.Basic
 import Mathlib.Data.Finset.Sym

90659cbe

refactor: split out finiteness properties for simple graphs (#10123)

620df7c2

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2020 Kyle Miller. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kyle Miller
 -/
-import Mathlib.Combinatorics.SimpleGraph.Basic
+import Mathlib.Combinatorics.SimpleGraph.Finite
 import Mathlib.Algebra.BigOperators.Basic
 import Mathlib.Data.Finset.Sym
 import Mathlib.Data.Nat.Parity

90659cbe

refactor: remove Sym2's global Prod setoid instance, use s(x, y) notation for unordered pairs (#8729)

The Sym2 type used a global setoid instance on α × α so that ⟦(x, y)⟧ could stand for an unordered pair using standard Quotient syntax. This commit refactors Sym2 to not use Quotient and instead use its own s(x, y) notation. One benefit to this is that this notation produces a term with type Sym2 rather than Quotient.

The Fintype instance for Sym2 is in Mathlib.Data.Finset.Sym. We switch from using the one for Quotient because it does not require DecidableEq.

9ed6b90f

Diff

@@ -5,6 +5,7 @@ Authors: Kyle Miller
 -/
 import Mathlib.Combinatorics.SimpleGraph.Basic
 import Mathlib.Algebra.BigOperators.Basic
+import Mathlib.Data.Finset.Sym
 import Mathlib.Data.Nat.Parity
 import Mathlib.Data.ZMod.Parity

90659cbe

feat: 0 ≤ a * b ↔ (0 < a → 0 ≤ b) ∧ (0 < b → 0 ≤ a) (#9219)

I had a slightly logic-heavy argument that was nicely simplified by stating this lemma. Also fix a few lemma names.

From LeanAPAP and LeanCamCombi

23429eb2

Diff

@@ -140,7 +140,7 @@ theorem odd_card_odd_degree_vertices_ne [Fintype V] [DecidableEq V] [DecidableRe
       use v
       simp only [true_and_iff, mem_filter, mem_univ]
       exact h
-    rwa [← card_pos, hg, ← two_mul, zero_lt_mul_left] at hh
+    rwa [← card_pos, hg, ← two_mul, mul_pos_iff_of_pos_left] at hh
     exact zero_lt_two
   have hc : (fun w : V => w ≠ v ∧ Odd (G.degree w)) = fun w : V => Odd (G.degree w) ∧ w ≠ v := by
     ext w

90659cbe

feat: number of edges in a complete graph (#8631)

d9c853b9

Diff

@@ -39,8 +39,7 @@ simple graphs, sums, degree-sum formula, handshaking lemma
 
 
 open Finset
-
-open BigOperators
+open scoped BigOperators
 
 namespace SimpleGraph

90659cbe

chore: drop MulZeroClass. in mul_zero/zero_mul (#6682)

Search&replace MulZeroClass.mul_zero -> mul_zero, MulZeroClass.zero_mul -> zero_mul.

These were introduced by Mathport, as the full name of mul_zero is actually MulZeroClass.mul_zero (it's exported with the short name).

277dea95

Diff

@@ -120,7 +120,7 @@ theorem even_card_odd_degree_vertices [Fintype V] [DecidableRel G.Adj] :
     Even (univ.filter fun v => Odd (G.degree v)).card := by
   classical
     have h := congr_arg (fun n => ↑n : ℕ → ZMod 2) G.sum_degrees_eq_twice_card_edges
-    simp only [ZMod.nat_cast_self, MulZeroClass.zero_mul, Nat.cast_mul] at h
+    simp only [ZMod.nat_cast_self, zero_mul, Nat.cast_mul] at h
     rw [Nat.cast_sum, ← sum_filter_ne_zero] at h
     rw [@sum_congr _ _ _ _ (fun v => (G.degree v : ZMod 2)) (fun _v => (1 : ZMod 2)) _ rfl] at h
     · simp only [filter_congr, mul_one, nsmul_eq_mul, sum_const, Ne.def] at h

90659cbe

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,17 +2,14 @@
 Copyright (c) 2020 Kyle Miller. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kyle Miller
-
-! This file was ported from Lean 3 source module combinatorics.simple_graph.degree_sum
-! leanprover-community/mathlib commit 90659cbe25e59ec302e2fb92b00e9732160cc620
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Combinatorics.SimpleGraph.Basic
 import Mathlib.Algebra.BigOperators.Basic
 import Mathlib.Data.Nat.Parity
 import Mathlib.Data.ZMod.Parity
 
+#align_import combinatorics.simple_graph.degree_sum from "leanprover-community/mathlib"@"90659cbe25e59ec302e2fb92b00e9732160cc620"
+
 /-!
 # Degree-sum formula and handshaking lemma

90659cbe

fix: ∑' precedence (#5615)

Also remove most superfluous parentheses around big operators (∑, ∏ and variants).
roughly the used regex: ([^a-zA-Zα-ωΑ-Ω'𝓝ℳ₀𝕂ₛ)]) $([∑∏][^()∑∏]*,[^()∑∏:]*)$ ([⊂⊆=<≤]) replaced by $1 $2 $3

03fc68aa

Diff

@@ -112,7 +112,7 @@ theorem dart_card_eq_twice_card_edges : Fintype.card G.Dart = 2 * G.edgeFinset.c
 
 /-- The degree-sum formula.  This is also known as the handshaking lemma, which might
 more specifically refer to `SimpleGraph.even_card_odd_degree_vertices`. -/
-theorem sum_degrees_eq_twice_card_edges : (∑ v, G.degree v) = 2 * G.edgeFinset.card :=
+theorem sum_degrees_eq_twice_card_edges : ∑ v, G.degree v = 2 * G.edgeFinset.card :=
   G.dart_card_eq_sum_degrees.symm.trans G.dart_card_eq_twice_card_edges
 #align simple_graph.sum_degrees_eq_twice_card_edges SimpleGraph.sum_degrees_eq_twice_card_edges

90659cbe

fix: address some congr/convert porting notes (#3058)

1b8e87aa

Diff

@@ -94,12 +94,8 @@ theorem dart_edge_fiber_card (e : Sym2 V) (h : e ∈ G.edgeSet) :
     (univ.filter fun d : G.Dart => d.edge = e).card = 2 := by
   refine' Sym2.ind (fun v w h => _) e h
   let d : G.Dart := ⟨(v, w), h⟩
-  -- Porting note: convert congr_arg card d.edge_fiber doesn't work?
-  -- convert congr_arg card d.edge_fiber
-  -- rw [card_insert_of_not_mem, card_singleton]
-  have x := congr_arg card d.edge_fiber
-  rw [card_insert_of_not_mem, card_singleton] at x
-  convert x
+  convert congr_arg card d.edge_fiber
+  rw [card_insert_of_not_mem, card_singleton]
   rw [mem_singleton]
   exact d.symm_ne.symm
 #align simple_graph.dart_edge_fiber_card SimpleGraph.dart_edge_fiber_card
@@ -132,10 +128,8 @@ theorem even_card_odd_degree_vertices [Fintype V] [DecidableRel G.Adj] :
     rw [@sum_congr _ _ _ _ (fun v => (G.degree v : ZMod 2)) (fun _v => (1 : ZMod 2)) _ rfl] at h
     · simp only [filter_congr, mul_one, nsmul_eq_mul, sum_const, Ne.def] at h
       rw [← ZMod.eq_zero_iff_even]
-      -- Porting note: old code is `convert h` but doesn't work?
-      rw [← h]; congr
-      ext v
-      rw [← ZMod.ne_zero_iff_odd]
+      convert h
+      exact ZMod.ne_zero_iff_odd.symm
     · intro v
       simp only [true_and_iff, mem_filter, mem_univ, Ne.def]
       rw [ZMod.eq_zero_iff_even, ZMod.eq_one_iff_odd, Nat.odd_iff_not_even, imp_self]

90659cbe

feat: Port Combinatorics.SimpleGraph.DegreeSum (#2895)

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

d353a387

`combinatorics.simple_graph.degree_sum` ⟷ `Mathlib.Combinatorics.SimpleGraph.DegreeSum`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 485

combinatorics.simple_graph.degree_sum ⟷ Mathlib.Combinatorics.SimpleGraph.DegreeSum

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 485

`combinatorics.simple_graph.degree_sum` ⟷ `Mathlib.Combinatorics.SimpleGraph.DegreeSum`