data.finset.sum | Mathlib porting status

(last sync)

feat(data/sum/interval): The lexicographic sum of two locally finite orders is locally finite (#11352)

This proves locally_finite_order (α ⊕ₗ β) where α and β are locally finite themselves.

Diff

@@ -54,6 +54,8 @@ multiset.mem_disj_sum
 @[simp] lemma inl_mem_disj_sum : inl a ∈ s.disj_sum t ↔ a ∈ s := inl_mem_disj_sum
 @[simp] lemma inr_mem_disj_sum : inr b ∈ s.disj_sum t ↔ b ∈ t := inr_mem_disj_sum
 
+@[simp] lemma disj_sum_eq_empty : s.disj_sum t = ∅ ↔ s = ∅ ∧ t = ∅ := by simp [ext_iff]
+
 lemma disj_sum_mono (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) : s₁.disj_sum t₁ ⊆ s₂.disj_sum t₂ :=
 val_le_iff.1 $ disj_sum_mono (val_le_iff.2 hs) (val_le_iff.2 ht)

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

bump to nightly-2023-11-03-06

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

e743ac84

Diff

@@ -101,9 +101,11 @@ theorem inr_mem_disjSum : inr b ∈ s.disjSum t ↔ b ∈ t :=
 #align finset.inr_mem_disj_sum Finset.inr_mem_disjSum
 -/
 
+#print Finset.disjSum_eq_empty /-
 @[simp]
 theorem disjSum_eq_empty : s.disjSum t = ∅ ↔ s = ∅ ∧ t = ∅ := by simp [ext_iff]
 #align finset.disj_sum_eq_empty Finset.disjSum_eq_empty
+-/
 
 #print Finset.disjSum_mono /-
 theorem disjSum_mono (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) : s₁.disjSum t₁ ⊆ s₂.disjSum t₂ :=

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 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.Data.Multiset.Sum
-import Mathbin.Data.Finset.Card
+import Data.Multiset.Sum
+import Data.Finset.Card
 
 #align_import data.finset.sum from "leanprover-community/mathlib"@"48a058d7e39a80ed56858505719a0b2197900999"

bump to nightly-2023-08-03-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/48a058d7e39a80ed56858505719a0b2197900999

906749b9

Diff

@@ -6,7 +6,7 @@ Authors: Yaël Dillies
 import Mathbin.Data.Multiset.Sum
 import Mathbin.Data.Finset.Card
 
-#align_import data.finset.sum from "leanprover-community/mathlib"@"e04043d6bf7264a3c84bc69711dc354958ca4516"
+#align_import data.finset.sum from "leanprover-community/mathlib"@"48a058d7e39a80ed56858505719a0b2197900999"
 
 /-!
 # Disjoint sum of finsets
@@ -101,6 +101,10 @@ theorem inr_mem_disjSum : inr b ∈ s.disjSum t ↔ b ∈ t :=
 #align finset.inr_mem_disj_sum Finset.inr_mem_disjSum
 -/
 
+@[simp]
+theorem disjSum_eq_empty : s.disjSum t = ∅ ↔ s = ∅ ∧ t = ∅ := by simp [ext_iff]
+#align finset.disj_sum_eq_empty Finset.disjSum_eq_empty
+
 #print Finset.disjSum_mono /-
 theorem disjSum_mono (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) : s₁.disjSum t₁ ⊆ s₂.disjSum t₂ :=
   val_le_iff.1 <| disjSum_mono (val_le_iff.2 hs) (val_le_iff.2 ht)

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 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 data.finset.sum
-! leanprover-community/mathlib commit e04043d6bf7264a3c84bc69711dc354958ca4516
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Multiset.Sum
 import Mathbin.Data.Finset.Card
 
+#align_import data.finset.sum from "leanprover-community/mathlib"@"e04043d6bf7264a3c84bc69711dc354958ca4516"
+
 /-!
 # Disjoint sum of finsets

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -39,42 +39,56 @@ def disjSum : Finset (Sum α β) :=
 #align finset.disj_sum Finset.disjSum
 -/
 
+#print Finset.val_disjSum /-
 @[simp]
 theorem val_disjSum : (s.disjSum t).1 = s.1.disjSum t.1 :=
   rfl
 #align finset.val_disj_sum Finset.val_disjSum
+-/
 
+#print Finset.empty_disjSum /-
 @[simp]
 theorem empty_disjSum : (∅ : Finset α).disjSum t = t.map Embedding.inr :=
   val_inj.1 <| Multiset.zero_disjSum _
 #align finset.empty_disj_sum Finset.empty_disjSum
+-/
 
+#print Finset.disjSum_empty /-
 @[simp]
 theorem disjSum_empty : s.disjSum (∅ : Finset β) = s.map Embedding.inl :=
   val_inj.1 <| Multiset.disjSum_zero _
 #align finset.disj_sum_empty Finset.disjSum_empty
+-/
 
+#print Finset.card_disjSum /-
 @[simp]
 theorem card_disjSum : (s.disjSum t).card = s.card + t.card :=
   Multiset.card_disjSum _ _
 #align finset.card_disj_sum Finset.card_disjSum
+-/
 
+#print Finset.disjoint_map_inl_map_inr /-
 theorem disjoint_map_inl_map_inr : Disjoint (s.map Embedding.inl) (t.map Embedding.inr) := by
   simp_rw [disjoint_left, mem_map]; rintro x ⟨a, _, rfl⟩ ⟨b, _, ⟨⟩⟩
 #align finset.disjoint_map_inl_map_inr Finset.disjoint_map_inl_map_inr
+-/
 
+#print Finset.map_inl_disjUnion_map_inr /-
 @[simp]
 theorem map_inl_disjUnion_map_inr :
     (s.map Embedding.inl).disjUnion (t.map Embedding.inr) (disjoint_map_inl_map_inr _ _) =
       s.disjSum t :=
   rfl
 #align finset.map_inl_disj_union_map_inr Finset.map_inl_disjUnion_map_inr
+-/
 
 variable {s t} {s₁ s₂ : Finset α} {t₁ t₂ : Finset β} {a : α} {b : β} {x : Sum α β}
 
+#print Finset.mem_disjSum /-
 theorem mem_disjSum : x ∈ s.disjSum t ↔ (∃ a, a ∈ s ∧ inl a = x) ∨ ∃ b, b ∈ t ∧ inr b = x :=
   Multiset.mem_disjSum
 #align finset.mem_disj_sum Finset.mem_disjSum
+-/
 
 #print Finset.inl_mem_disjSum /-
 @[simp]
@@ -90,9 +104,11 @@ theorem inr_mem_disjSum : inr b ∈ s.disjSum t ↔ b ∈ t :=
 #align finset.inr_mem_disj_sum Finset.inr_mem_disjSum
 -/
 
+#print Finset.disjSum_mono /-
 theorem disjSum_mono (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) : s₁.disjSum t₁ ⊆ s₂.disjSum t₂ :=
   val_le_iff.1 <| disjSum_mono (val_le_iff.2 hs) (val_le_iff.2 ht)
 #align finset.disj_sum_mono Finset.disjSum_mono
+-/
 
 #print Finset.disjSum_mono_left /-
 theorem disjSum_mono_left (t : Finset β) : Monotone fun s : Finset α => s.disjSum t :=
@@ -100,19 +116,25 @@ theorem disjSum_mono_left (t : Finset β) : Monotone fun s : Finset α => s.disj
 #align finset.disj_sum_mono_left Finset.disjSum_mono_left
 -/
 
+#print Finset.disjSum_mono_right /-
 theorem disjSum_mono_right (s : Finset α) : Monotone (s.disjSum : Finset β → Finset (Sum α β)) :=
   fun t₁ t₂ => disjSum_mono Subset.rfl
 #align finset.disj_sum_mono_right Finset.disjSum_mono_right
+-/
 
+#print Finset.disjSum_ssubset_disjSum_of_ssubset_of_subset /-
 theorem disjSum_ssubset_disjSum_of_ssubset_of_subset (hs : s₁ ⊂ s₂) (ht : t₁ ⊆ t₂) :
     s₁.disjSum t₁ ⊂ s₂.disjSum t₂ :=
   val_lt_iff.1 <| disjSum_lt_disjSum_of_lt_of_le (val_lt_iff.2 hs) (val_le_iff.2 ht)
 #align finset.disj_sum_ssubset_disj_sum_of_ssubset_of_subset Finset.disjSum_ssubset_disjSum_of_ssubset_of_subset
+-/
 
+#print Finset.disjSum_ssubset_disjSum_of_subset_of_ssubset /-
 theorem disjSum_ssubset_disjSum_of_subset_of_ssubset (hs : s₁ ⊆ s₂) (ht : t₁ ⊂ t₂) :
     s₁.disjSum t₁ ⊂ s₂.disjSum t₂ :=
   val_lt_iff.1 <| disjSum_lt_disjSum_of_le_of_lt (val_le_iff.2 hs) (val_lt_iff.2 ht)
 #align finset.disj_sum_ssubset_disj_sum_of_subset_of_ssubset Finset.disjSum_ssubset_disjSum_of_subset_of_ssubset
+-/
 
 #print Finset.disjSum_strictMono_left /-
 theorem disjSum_strictMono_left (t : Finset β) : StrictMono fun s : Finset α => s.disjSum t :=
@@ -120,10 +142,12 @@ theorem disjSum_strictMono_left (t : Finset β) : StrictMono fun s : Finset α =
 #align finset.disj_sum_strict_mono_left Finset.disjSum_strictMono_left
 -/
 
+#print Finset.disj_sum_strictMono_right /-
 theorem disj_sum_strictMono_right (s : Finset α) :
     StrictMono (s.disjSum : Finset β → Finset (Sum α β)) := fun s₁ s₂ =>
   disjSum_ssubset_disjSum_of_subset_of_ssubset Subset.rfl
 #align finset.disj_sum_strict_mono_right Finset.disj_sum_strictMono_right
+-/
 
 end Finset

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -39,66 +39,30 @@ def disjSum : Finset (Sum α β) :=
 #align finset.disj_sum Finset.disjSum
 -/
 
-/- warning: finset.val_disj_sum -> Finset.val_disjSum is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (s : Finset.{u1} α) (t : Finset.{u2} β), Eq.{succ (max u1 u2)} (Multiset.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.val.{max u1 u2} (Sum.{u1, u2} α β) (Finset.disjSum.{u1, u2} α β s t)) (Multiset.disjSum.{u1, u2} α β (Finset.val.{u1} α s) (Finset.val.{u2} β t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (s : Finset.{u2} α) (t : Finset.{u1} β), Eq.{max (succ u2) (succ u1)} (Multiset.{max u2 u1} (Sum.{u2, u1} α β)) (Finset.val.{max u2 u1} (Sum.{u2, u1} α β) (Finset.disjSum.{u2, u1} α β s t)) (Multiset.disjSum.{u2, u1} α β (Finset.val.{u2} α s) (Finset.val.{u1} β t))
-Case conversion may be inaccurate. Consider using '#align finset.val_disj_sum Finset.val_disjSumₓ'. -/
 @[simp]
 theorem val_disjSum : (s.disjSum t).1 = s.1.disjSum t.1 :=
   rfl
 #align finset.val_disj_sum Finset.val_disjSum
 
-/- warning: finset.empty_disj_sum -> Finset.empty_disjSum is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (t : Finset.{u2} β), Eq.{succ (max u1 u2)} (Finset.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.disjSum.{u1, u2} α β (EmptyCollection.emptyCollection.{u1} (Finset.{u1} α) (Finset.hasEmptyc.{u1} α)) t) (Finset.map.{u2, max u1 u2} β (Sum.{u1, u2} α β) (Function.Embedding.inr.{u1, u2} α β) t)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (t : Finset.{u1} β), Eq.{max (succ u2) (succ u1)} (Finset.{max u1 u2} (Sum.{u2, u1} α β)) (Finset.disjSum.{u2, u1} α β (EmptyCollection.emptyCollection.{u2} (Finset.{u2} α) (Finset.instEmptyCollectionFinset.{u2} α)) t) (Finset.map.{u1, max u1 u2} β (Sum.{u2, u1} α β) (Function.Embedding.inr.{u2, u1} α β) t)
-Case conversion may be inaccurate. Consider using '#align finset.empty_disj_sum Finset.empty_disjSumₓ'. -/
 @[simp]
 theorem empty_disjSum : (∅ : Finset α).disjSum t = t.map Embedding.inr :=
   val_inj.1 <| Multiset.zero_disjSum _
 #align finset.empty_disj_sum Finset.empty_disjSum
 
-/- warning: finset.disj_sum_empty -> Finset.disjSum_empty is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (s : Finset.{u1} α), Eq.{succ (max u1 u2)} (Finset.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.disjSum.{u1, u2} α β s (EmptyCollection.emptyCollection.{u2} (Finset.{u2} β) (Finset.hasEmptyc.{u2} β))) (Finset.map.{u1, max u1 u2} α (Sum.{u1, u2} α β) (Function.Embedding.inl.{u1, u2} α β) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (s : Finset.{u2} α), Eq.{max (succ u2) (succ u1)} (Finset.{max u1 u2} (Sum.{u2, u1} α β)) (Finset.disjSum.{u2, u1} α β s (EmptyCollection.emptyCollection.{u1} (Finset.{u1} β) (Finset.instEmptyCollectionFinset.{u1} β))) (Finset.map.{u2, max u1 u2} α (Sum.{u2, u1} α β) (Function.Embedding.inl.{u2, u1} α β) s)
-Case conversion may be inaccurate. Consider using '#align finset.disj_sum_empty Finset.disjSum_emptyₓ'. -/
 @[simp]
 theorem disjSum_empty : s.disjSum (∅ : Finset β) = s.map Embedding.inl :=
   val_inj.1 <| Multiset.disjSum_zero _
 #align finset.disj_sum_empty Finset.disjSum_empty
 
-/- warning: finset.card_disj_sum -> Finset.card_disjSum is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (s : Finset.{u1} α) (t : Finset.{u2} β), Eq.{1} Nat (Finset.card.{max u1 u2} (Sum.{u1, u2} α β) (Finset.disjSum.{u1, u2} α β s t)) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) (Finset.card.{u1} α s) (Finset.card.{u2} β t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (s : Finset.{u2} α) (t : Finset.{u1} β), Eq.{1} Nat (Finset.card.{max u2 u1} (Sum.{u2, u1} α β) (Finset.disjSum.{u2, u1} α β s t)) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) (Finset.card.{u2} α s) (Finset.card.{u1} β t))
-Case conversion may be inaccurate. Consider using '#align finset.card_disj_sum Finset.card_disjSumₓ'. -/
 @[simp]
 theorem card_disjSum : (s.disjSum t).card = s.card + t.card :=
   Multiset.card_disjSum _ _
 #align finset.card_disj_sum Finset.card_disjSum
 
-/- warning: finset.disjoint_map_inl_map_inr -> Finset.disjoint_map_inl_map_inr is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (s : Finset.{u1} α) (t : Finset.{u2} β), Disjoint.{max u1 u2} (Finset.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.partialOrder.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.orderBot.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.map.{u1, max u1 u2} α (Sum.{u1, u2} α β) (Function.Embedding.inl.{u1, u2} α β) s) (Finset.map.{u2, max u1 u2} β (Sum.{u1, u2} α β) (Function.Embedding.inr.{u1, u2} α β) t)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} (s : Finset.{u1} α) (t : Finset.{u2} β), Disjoint.{max u2 u1} (Finset.{max u2 u1} (Sum.{u1, u2} α β)) (Finset.partialOrder.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.instOrderBotFinsetToLEToPreorderPartialOrder.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.map.{u1, max u2 u1} α (Sum.{u1, u2} α β) (Function.Embedding.inl.{u1, u2} α β) s) (Finset.map.{u2, max u1 u2} β (Sum.{u1, u2} α β) (Function.Embedding.inr.{u1, u2} α β) t)
-Case conversion may be inaccurate. Consider using '#align finset.disjoint_map_inl_map_inr Finset.disjoint_map_inl_map_inrₓ'. -/
 theorem disjoint_map_inl_map_inr : Disjoint (s.map Embedding.inl) (t.map Embedding.inr) := by
   simp_rw [disjoint_left, mem_map]; rintro x ⟨a, _, rfl⟩ ⟨b, _, ⟨⟩⟩
 #align finset.disjoint_map_inl_map_inr Finset.disjoint_map_inl_map_inr
 
-/- warning: finset.map_inl_disj_union_map_inr -> Finset.map_inl_disjUnion_map_inr is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (s : Finset.{u1} α) (t : Finset.{u2} β), Eq.{succ (max u1 u2)} (Finset.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.disjUnion.{max u1 u2} (Sum.{u1, u2} α β) (Finset.map.{u1, max u1 u2} α (Sum.{u1, u2} α β) (Function.Embedding.inl.{u1, u2} α β) s) (Finset.map.{u2, max u1 u2} β (Sum.{u1, u2} α β) (Function.Embedding.inr.{u1, u2} α β) t) (Finset.disjoint_map_inl_map_inr.{u1, u2} α β s t)) (Finset.disjSum.{u1, u2} α β s t)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (s : Finset.{u2} α) (t : Finset.{u1} β), Eq.{max (succ u2) (succ u1)} (Finset.{max u2 u1} (Sum.{u2, u1} α β)) (Finset.disjUnion.{max u2 u1} (Sum.{u2, u1} α β) (Finset.map.{u2, max u1 u2} α (Sum.{u2, u1} α β) (Function.Embedding.inl.{u2, u1} α β) s) (Finset.map.{u1, max u2 u1} β (Sum.{u2, u1} α β) (Function.Embedding.inr.{u2, u1} α β) t) (Finset.disjoint_map_inl_map_inr.{u2, u1} α β s t)) (Finset.disjSum.{u2, u1} α β s t)
-Case conversion may be inaccurate. Consider using '#align finset.map_inl_disj_union_map_inr Finset.map_inl_disjUnion_map_inrₓ'. -/
 @[simp]
 theorem map_inl_disjUnion_map_inr :
     (s.map Embedding.inl).disjUnion (t.map Embedding.inr) (disjoint_map_inl_map_inr _ _) =
@@ -108,12 +72,6 @@ theorem map_inl_disjUnion_map_inr :
 
 variable {s t} {s₁ s₂ : Finset α} {t₁ t₂ : Finset β} {a : α} {b : β} {x : Sum α β}
 
-/- warning: finset.mem_disj_sum -> Finset.mem_disjSum is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Finset.{u1} α} {t : Finset.{u2} β} {x : Sum.{u1, u2} α β}, Iff (Membership.Mem.{max u1 u2, max u1 u2} (Sum.{u1, u2} α β) (Finset.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.hasMem.{max u1 u2} (Sum.{u1, u2} α β)) x (Finset.disjSum.{u1, u2} α β s t)) (Or (Exists.{succ u1} α (fun (a : α) => And (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) (Eq.{max (succ u1) (succ u2)} (Sum.{u1, u2} α β) (Sum.inl.{u1, u2} α β a) x))) (Exists.{succ u2} β (fun (b : β) => And (Membership.Mem.{u2, u2} β (Finset.{u2} β) (Finset.hasMem.{u2} β) b t) (Eq.{max (succ u1) (succ u2)} (Sum.{u1, u2} α β) (Sum.inr.{u1, u2} α β b) x))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Finset.{u2} α} {t : Finset.{u1} β} {x : Sum.{u2, u1} α β}, Iff (Membership.mem.{max u2 u1, max u2 u1} (Sum.{u2, u1} α β) (Finset.{max u1 u2} (Sum.{u2, u1} α β)) (Finset.instMembershipFinset.{max u2 u1} (Sum.{u2, u1} α β)) x (Finset.disjSum.{u2, u1} α β s t)) (Or (Exists.{succ u2} α (fun (a : α) => And (Membership.mem.{u2, u2} α (Finset.{u2} α) (Finset.instMembershipFinset.{u2} α) a s) (Eq.{max (succ u2) (succ u1)} (Sum.{u2, u1} α β) (Sum.inl.{u2, u1} α β a) x))) (Exists.{succ u1} β (fun (b : β) => And (Membership.mem.{u1, u1} β (Finset.{u1} β) (Finset.instMembershipFinset.{u1} β) b t) (Eq.{max (succ u2) (succ u1)} (Sum.{u2, u1} α β) (Sum.inr.{u2, u1} α β b) x))))
-Case conversion may be inaccurate. Consider using '#align finset.mem_disj_sum Finset.mem_disjSumₓ'. -/
 theorem mem_disjSum : x ∈ s.disjSum t ↔ (∃ a, a ∈ s ∧ inl a = x) ∨ ∃ b, b ∈ t ∧ inr b = x :=
   Multiset.mem_disjSum
 #align finset.mem_disj_sum Finset.mem_disjSum
@@ -132,12 +90,6 @@ theorem inr_mem_disjSum : inr b ∈ s.disjSum t ↔ b ∈ t :=
 #align finset.inr_mem_disj_sum Finset.inr_mem_disjSum
 -/
 
-/- warning: finset.disj_sum_mono -> Finset.disjSum_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s₁ : Finset.{u1} α} {s₂ : Finset.{u1} α} {t₁ : Finset.{u2} β} {t₂ : Finset.{u2} β}, (HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.hasSubset.{u1} α) s₁ s₂) -> (HasSubset.Subset.{u2} (Finset.{u2} β) (Finset.hasSubset.{u2} β) t₁ t₂) -> (HasSubset.Subset.{max u1 u2} (Finset.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.hasSubset.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.disjSum.{u1, u2} α β s₁ t₁) (Finset.disjSum.{u1, u2} α β s₂ t₂))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s₁ : Finset.{u2} α} {s₂ : Finset.{u2} α} {t₁ : Finset.{u1} β} {t₂ : Finset.{u1} β}, (HasSubset.Subset.{u2} (Finset.{u2} α) (Finset.instHasSubsetFinset.{u2} α) s₁ s₂) -> (HasSubset.Subset.{u1} (Finset.{u1} β) (Finset.instHasSubsetFinset.{u1} β) t₁ t₂) -> (HasSubset.Subset.{max u2 u1} (Finset.{max u1 u2} (Sum.{u2, u1} α β)) (Finset.instHasSubsetFinset.{max u2 u1} (Sum.{u2, u1} α β)) (Finset.disjSum.{u2, u1} α β s₁ t₁) (Finset.disjSum.{u2, u1} α β s₂ t₂))
-Case conversion may be inaccurate. Consider using '#align finset.disj_sum_mono Finset.disjSum_monoₓ'. -/
 theorem disjSum_mono (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) : s₁.disjSum t₁ ⊆ s₂.disjSum t₂ :=
   val_le_iff.1 <| disjSum_mono (val_le_iff.2 hs) (val_le_iff.2 ht)
 #align finset.disj_sum_mono Finset.disjSum_mono
@@ -148,33 +100,15 @@ theorem disjSum_mono_left (t : Finset β) : Monotone fun s : Finset α => s.disj
 #align finset.disj_sum_mono_left Finset.disjSum_mono_left
 -/
 
-/- warning: finset.disj_sum_mono_right -> Finset.disjSum_mono_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (s : Finset.{u1} α), Monotone.{u2, max u1 u2} (Finset.{u2} β) (Finset.{max u1 u2} (Sum.{u1, u2} α β)) (PartialOrder.toPreorder.{u2} (Finset.{u2} β) (Finset.partialOrder.{u2} β)) (PartialOrder.toPreorder.{max u1 u2} (Finset.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.partialOrder.{max u1 u2} (Sum.{u1, u2} α β))) (Finset.disjSum.{u1, u2} α β s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (s : Finset.{u2} α), Monotone.{u1, max u2 u1} (Finset.{u1} β) (Finset.{max u1 u2} (Sum.{u2, u1} α β)) (PartialOrder.toPreorder.{u1} (Finset.{u1} β) (Finset.partialOrder.{u1} β)) (PartialOrder.toPreorder.{max u2 u1} (Finset.{max u1 u2} (Sum.{u2, u1} α β)) (Finset.partialOrder.{max u2 u1} (Sum.{u2, u1} α β))) (Finset.disjSum.{u2, u1} α β s)
-Case conversion may be inaccurate. Consider using '#align finset.disj_sum_mono_right Finset.disjSum_mono_rightₓ'. -/
 theorem disjSum_mono_right (s : Finset α) : Monotone (s.disjSum : Finset β → Finset (Sum α β)) :=
   fun t₁ t₂ => disjSum_mono Subset.rfl
 #align finset.disj_sum_mono_right Finset.disjSum_mono_right
 
-/- warning: finset.disj_sum_ssubset_disj_sum_of_ssubset_of_subset -> Finset.disjSum_ssubset_disjSum_of_ssubset_of_subset is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s₁ : Finset.{u1} α} {s₂ : Finset.{u1} α} {t₁ : Finset.{u2} β} {t₂ : Finset.{u2} β}, (HasSSubset.SSubset.{u1} (Finset.{u1} α) (Finset.hasSsubset.{u1} α) s₁ s₂) -> (HasSubset.Subset.{u2} (Finset.{u2} β) (Finset.hasSubset.{u2} β) t₁ t₂) -> (HasSSubset.SSubset.{max u1 u2} (Finset.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.hasSsubset.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.disjSum.{u1, u2} α β s₁ t₁) (Finset.disjSum.{u1, u2} α β s₂ t₂))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s₁ : Finset.{u2} α} {s₂ : Finset.{u2} α} {t₁ : Finset.{u1} β} {t₂ : Finset.{u1} β}, (HasSSubset.SSubset.{u2} (Finset.{u2} α) (Finset.instHasSSubsetFinset.{u2} α) s₁ s₂) -> (HasSubset.Subset.{u1} (Finset.{u1} β) (Finset.instHasSubsetFinset.{u1} β) t₁ t₂) -> (HasSSubset.SSubset.{max u2 u1} (Finset.{max u1 u2} (Sum.{u2, u1} α β)) (Finset.instHasSSubsetFinset.{max u2 u1} (Sum.{u2, u1} α β)) (Finset.disjSum.{u2, u1} α β s₁ t₁) (Finset.disjSum.{u2, u1} α β s₂ t₂))
-Case conversion may be inaccurate. Consider using '#align finset.disj_sum_ssubset_disj_sum_of_ssubset_of_subset Finset.disjSum_ssubset_disjSum_of_ssubset_of_subsetₓ'. -/
 theorem disjSum_ssubset_disjSum_of_ssubset_of_subset (hs : s₁ ⊂ s₂) (ht : t₁ ⊆ t₂) :
     s₁.disjSum t₁ ⊂ s₂.disjSum t₂ :=
   val_lt_iff.1 <| disjSum_lt_disjSum_of_lt_of_le (val_lt_iff.2 hs) (val_le_iff.2 ht)
 #align finset.disj_sum_ssubset_disj_sum_of_ssubset_of_subset Finset.disjSum_ssubset_disjSum_of_ssubset_of_subset
 
-/- warning: finset.disj_sum_ssubset_disj_sum_of_subset_of_ssubset -> Finset.disjSum_ssubset_disjSum_of_subset_of_ssubset is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s₁ : Finset.{u1} α} {s₂ : Finset.{u1} α} {t₁ : Finset.{u2} β} {t₂ : Finset.{u2} β}, (HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.hasSubset.{u1} α) s₁ s₂) -> (HasSSubset.SSubset.{u2} (Finset.{u2} β) (Finset.hasSsubset.{u2} β) t₁ t₂) -> (HasSSubset.SSubset.{max u1 u2} (Finset.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.hasSsubset.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.disjSum.{u1, u2} α β s₁ t₁) (Finset.disjSum.{u1, u2} α β s₂ t₂))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s₁ : Finset.{u2} α} {s₂ : Finset.{u2} α} {t₁ : Finset.{u1} β} {t₂ : Finset.{u1} β}, (HasSubset.Subset.{u2} (Finset.{u2} α) (Finset.instHasSubsetFinset.{u2} α) s₁ s₂) -> (HasSSubset.SSubset.{u1} (Finset.{u1} β) (Finset.instHasSSubsetFinset.{u1} β) t₁ t₂) -> (HasSSubset.SSubset.{max u2 u1} (Finset.{max u1 u2} (Sum.{u2, u1} α β)) (Finset.instHasSSubsetFinset.{max u2 u1} (Sum.{u2, u1} α β)) (Finset.disjSum.{u2, u1} α β s₁ t₁) (Finset.disjSum.{u2, u1} α β s₂ t₂))
-Case conversion may be inaccurate. Consider using '#align finset.disj_sum_ssubset_disj_sum_of_subset_of_ssubset Finset.disjSum_ssubset_disjSum_of_subset_of_ssubsetₓ'. -/
 theorem disjSum_ssubset_disjSum_of_subset_of_ssubset (hs : s₁ ⊆ s₂) (ht : t₁ ⊂ t₂) :
     s₁.disjSum t₁ ⊂ s₂.disjSum t₂ :=
   val_lt_iff.1 <| disjSum_lt_disjSum_of_le_of_lt (val_le_iff.2 hs) (val_lt_iff.2 ht)
@@ -186,12 +120,6 @@ theorem disjSum_strictMono_left (t : Finset β) : StrictMono fun s : Finset α =
 #align finset.disj_sum_strict_mono_left Finset.disjSum_strictMono_left
 -/
 
-/- warning: finset.disj_sum_strict_mono_right -> Finset.disj_sum_strictMono_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (s : Finset.{u1} α), StrictMono.{u2, max u1 u2} (Finset.{u2} β) (Finset.{max u1 u2} (Sum.{u1, u2} α β)) (PartialOrder.toPreorder.{u2} (Finset.{u2} β) (Finset.partialOrder.{u2} β)) (PartialOrder.toPreorder.{max u1 u2} (Finset.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.partialOrder.{max u1 u2} (Sum.{u1, u2} α β))) (Finset.disjSum.{u1, u2} α β s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (s : Finset.{u2} α), StrictMono.{u1, max u2 u1} (Finset.{u1} β) (Finset.{max u1 u2} (Sum.{u2, u1} α β)) (PartialOrder.toPreorder.{u1} (Finset.{u1} β) (Finset.partialOrder.{u1} β)) (PartialOrder.toPreorder.{max u2 u1} (Finset.{max u1 u2} (Sum.{u2, u1} α β)) (Finset.partialOrder.{max u2 u1} (Sum.{u2, u1} α β))) (Finset.disjSum.{u2, u1} α β s)
-Case conversion may be inaccurate. Consider using '#align finset.disj_sum_strict_mono_right Finset.disj_sum_strictMono_rightₓ'. -/
 theorem disj_sum_strictMono_right (s : Finset α) :
     StrictMono (s.disjSum : Finset β → Finset (Sum α β)) := fun s₁ s₂ =>
   disjSum_ssubset_disjSum_of_subset_of_ssubset Subset.rfl

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -89,10 +89,8 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} (s : Finset.{u1} α) (t : Finset.{u2} β), Disjoint.{max u2 u1} (Finset.{max u2 u1} (Sum.{u1, u2} α β)) (Finset.partialOrder.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.instOrderBotFinsetToLEToPreorderPartialOrder.{max u1 u2} (Sum.{u1, u2} α β)) (Finset.map.{u1, max u2 u1} α (Sum.{u1, u2} α β) (Function.Embedding.inl.{u1, u2} α β) s) (Finset.map.{u2, max u1 u2} β (Sum.{u1, u2} α β) (Function.Embedding.inr.{u1, u2} α β) t)
 Case conversion may be inaccurate. Consider using '#align finset.disjoint_map_inl_map_inr Finset.disjoint_map_inl_map_inrₓ'. -/
-theorem disjoint_map_inl_map_inr : Disjoint (s.map Embedding.inl) (t.map Embedding.inr) :=
-  by
-  simp_rw [disjoint_left, mem_map]
-  rintro x ⟨a, _, rfl⟩ ⟨b, _, ⟨⟩⟩
+theorem disjoint_map_inl_map_inr : Disjoint (s.map Embedding.inl) (t.map Embedding.inr) := by
+  simp_rw [disjoint_left, mem_map]; rintro x ⟨a, _, rfl⟩ ⟨b, _, ⟨⟩⟩
 #align finset.disjoint_map_inl_map_inr Finset.disjoint_map_inl_map_inr
 
 /- warning: finset.map_inl_disj_union_map_inr -> Finset.map_inl_disjUnion_map_inr is a dubious translation:

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

feat: The lexicographic sum of two locally finite orders is locally finite (#6340)

Forward-ports https://github.com/leanprover-community/mathlib/pull/11352

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

479779ea

Diff

@@ -6,7 +6,7 @@ Authors: Yaël Dillies
 import Mathlib.Data.Multiset.Sum
 import Mathlib.Data.Finset.Card
 
-#align_import data.finset.sum from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
+#align_import data.finset.sum from "leanprover-community/mathlib"@"48a058d7e39a80ed56858505719a0b2197900999"
 
 /-!
 # Disjoint sum of finsets
@@ -79,6 +79,10 @@ theorem inr_mem_disjSum : inr b ∈ s.disjSum t ↔ b ∈ t :=
   Multiset.inr_mem_disjSum
 #align finset.inr_mem_disj_sum Finset.inr_mem_disjSum
 
+@[simp]
+theorem disjSum_eq_empty : s.disjSum t = ∅ ↔ s = ∅ ∧ t = ∅ := by simp [ext_iff]
+#align finset.disj_sum_eq_empty Finset.disjSum_eq_empty
+
 theorem disjSum_mono (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) : s₁.disjSum t₁ ⊆ s₂.disjSum t₂ :=
   val_le_iff.1 <| Multiset.disjSum_mono (val_le_iff.2 hs) (val_le_iff.2 ht)
 #align finset.disj_sum_mono Finset.disjSum_mono

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

@@ -24,7 +24,7 @@ open Function Multiset Sum
 
 namespace Finset
 
-variable {α β : Type _} (s : Finset α) (t : Finset β)
+variable {α β : Type*} (s : Finset α) (t : Finset β)
 
 /-- Disjoint sum of finsets. -/
 def disjSum : Finset (Sum α β) :=

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 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 data.finset.sum
-! leanprover-community/mathlib commit 9003f28797c0664a49e4179487267c494477d853
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Multiset.Sum
 import Mathlib.Data.Finset.Card
 
+#align_import data.finset.sum from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
+
 /-!
 # Disjoint sum of finsets

chore: bye-bye, solo bys! (#3825)

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

14167e48

Diff

@@ -54,8 +54,7 @@ theorem card_disjSum : (s.disjSum t).card = s.card + t.card :=
   Multiset.card_disjSum _ _
 #align finset.card_disj_sum Finset.card_disjSum
 
-theorem disjoint_map_inl_map_inr : Disjoint (s.map Embedding.inl) (t.map Embedding.inr) :=
-  by
+theorem disjoint_map_inl_map_inr : Disjoint (s.map Embedding.inl) (t.map Embedding.inr) := by
   simp_rw [disjoint_left, mem_map]
   rintro x ⟨a, _, rfl⟩ ⟨b, _, ⟨⟩⟩
 #align finset.disjoint_map_inl_map_inr Finset.disjoint_map_inl_map_inr

chore: the style linter shouldn't complain about long #align lines (#1643)

54af0498

Diff

@@ -98,16 +98,12 @@ theorem disjSum_mono_right (s : Finset α) : Monotone (s.disjSum : Finset β →
 theorem disjSum_ssubset_disjSum_of_ssubset_of_subset (hs : s₁ ⊂ s₂) (ht : t₁ ⊆ t₂) :
     s₁.disjSum t₁ ⊂ s₂.disjSum t₂ :=
   val_lt_iff.1 <| disjSum_lt_disjSum_of_lt_of_le (val_lt_iff.2 hs) (val_le_iff.2 ht)
-#align
-  finset.disj_sum_ssubset_disj_sum_of_ssubset_of_subset
-  Finset.disjSum_ssubset_disjSum_of_ssubset_of_subset
+#align finset.disj_sum_ssubset_disj_sum_of_ssubset_of_subset Finset.disjSum_ssubset_disjSum_of_ssubset_of_subset
 
 theorem disjSum_ssubset_disjSum_of_subset_of_ssubset (hs : s₁ ⊆ s₂) (ht : t₁ ⊂ t₂) :
     s₁.disjSum t₁ ⊂ s₂.disjSum t₂ :=
   val_lt_iff.1 <| disjSum_lt_disjSum_of_le_of_lt (val_le_iff.2 hs) (val_lt_iff.2 ht)
-#align
-  finset.disj_sum_ssubset_disj_sum_of_subset_of_ssubset
-  Finset.disjSum_ssubset_disjSum_of_subset_of_ssubset
+#align finset.disj_sum_ssubset_disj_sum_of_subset_of_ssubset Finset.disjSum_ssubset_disjSum_of_subset_of_ssubset
 
 theorem disjSum_strictMono_left (t : Finset β) : StrictMono fun s : Finset α => s.disjSum t :=
   fun _ _ hs => disjSum_ssubset_disjSum_of_ssubset_of_subset hs Subset.rfl

feat: port Algebra.BigOperators.Basic (#1628)

Co-authored-by: Siddharth Bhat <siddu.druid@gmail.com> Co-authored-by: ChrisHughes24 <chrishughes24@gmail.com>

2f8a3aa9

Diff

@@ -61,11 +61,11 @@ theorem disjoint_map_inl_map_inr : Disjoint (s.map Embedding.inl) (t.map Embeddi
 #align finset.disjoint_map_inl_map_inr Finset.disjoint_map_inl_map_inr
 
 @[simp]
-theorem map_inl_disj_union_map_inr :
+theorem map_inl_disjUnion_map_inr :
     (s.map Embedding.inl).disjUnion (t.map Embedding.inr) (disjoint_map_inl_map_inr _ _) =
       s.disjSum t :=
   rfl
-#align finset.map_inl_disj_union_map_inr Finset.map_inl_disj_union_map_inr
+#align finset.map_inl_disj_union_map_inr Finset.map_inl_disjUnion_map_inr
 
 variable {s t} {s₁ s₂ : Finset α} {t₁ t₂ : Finset β} {a : α} {b : β} {x : Sum α β}