data.finsupp.well_founded | 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

5fd3186f

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

290a7ba0

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2022 Junyan Xu. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Junyan Xu
 -/
-import Data.Dfinsupp.WellFounded
+import Data.DFinsupp.WellFounded
 import Data.Finsupp.Lex
 
 #align_import data.finsupp.well_founded from "leanprover-community/mathlib"@"290a7ba01fbcab1b64757bdaa270d28f4dcede35"

290a7ba0

bump to nightly-2024-02-01-06

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

5433bded

Diff

@@ -42,6 +42,8 @@ theorem Lex.acc (x : α →₀ N) (h : ∀ a ∈ x.support, Acc (rᶜ ⊓ (· 
     Acc (Finsupp.Lex r s) x := by
   rw [lex_eq_inv_image_dfinsupp_lex]
   classical
+  refine' InvImage.accessible to_dfinsupp (DFinsupp.Lex.acc (fun a => hbot) (fun a => hs) _ _)
+  simpa only [toDFinsupp_support] using h
 #align finsupp.lex.acc Finsupp.Lex.acc
 -/

290a7ba0

bump to nightly-2024-01-31-06

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

61100fe9

Diff

@@ -42,8 +42,6 @@ theorem Lex.acc (x : α →₀ N) (h : ∀ a ∈ x.support, Acc (rᶜ ⊓ (· 
     Acc (Finsupp.Lex r s) x := by
   rw [lex_eq_inv_image_dfinsupp_lex]
   classical
-  refine' InvImage.accessible to_dfinsupp (DFinsupp.Lex.acc (fun a => hbot) (fun a => hs) _ _)
-  simpa only [toDFinsupp_support] using h
 #align finsupp.lex.acc Finsupp.Lex.acc
 -/

290a7ba0

bump to nightly-2023-10-07-06

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

d191b687

Diff

@@ -63,7 +63,7 @@ theorem Lex.wellFounded' [IsTrichotomous α r] (hr : WellFounded r.symm) :
 
 #print Finsupp.Lex.wellFoundedLT /-
 instance Lex.wellFoundedLT [LT α] [IsTrichotomous α (· < ·)] [hα : WellFoundedGT α]
-    [CanonicallyOrderedAddMonoid N] [hN : WellFoundedLT N] : WellFoundedLT (Lex (α →₀ N)) :=
+    [CanonicallyOrderedAddCommMonoid N] [hN : WellFoundedLT N] : WellFoundedLT (Lex (α →₀ N)) :=
   ⟨Lex.wellFounded' (fun n => (zero_le n).not_lt) hN.wf hα.wf⟩
 #align finsupp.lex.well_founded_lt Finsupp.Lex.wellFoundedLT
 -/
@@ -92,7 +92,7 @@ protected theorem wellFoundedLT [Zero N] [Preorder N] [WellFoundedLT N] (hbot :
 -/
 
 #print Finsupp.wellFoundedLT' /-
-instance wellFoundedLT' [CanonicallyOrderedAddMonoid N] [WellFoundedLT N] :
+instance wellFoundedLT' [CanonicallyOrderedAddCommMonoid N] [WellFoundedLT N] :
     WellFoundedLT (α →₀ N) :=
   Finsupp.wellFoundedLT fun a => (zero_le a).not_lt
 #align finsupp.well_founded_lt' Finsupp.wellFoundedLT'

290a7ba0

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 Junyan Xu. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Junyan Xu
 -/
-import Mathbin.Data.Dfinsupp.WellFounded
-import Mathbin.Data.Finsupp.Lex
+import Data.Dfinsupp.WellFounded
+import Data.Finsupp.Lex
 
 #align_import data.finsupp.well_founded from "leanprover-community/mathlib"@"290a7ba01fbcab1b64757bdaa270d28f4dcede35"

290a7ba0

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 Junyan Xu. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Junyan Xu
-
-! This file was ported from Lean 3 source module data.finsupp.well_founded
-! leanprover-community/mathlib commit 290a7ba01fbcab1b64757bdaa270d28f4dcede35
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Dfinsupp.WellFounded
 import Mathbin.Data.Finsupp.Lex
 
+#align_import data.finsupp.well_founded from "leanprover-community/mathlib"@"290a7ba01fbcab1b64757bdaa270d28f4dcede35"
+
 /-!
 # Well-foundedness of the lexicographic and product orders on `finsupp`

290a7ba0

bump to nightly-2023-07-12-07

mathlib commit https://github.com/leanprover-community/mathlib/commit/4e24c4bfcff371c71f7ba22050308aa17815626c

9849f9d1

Diff

@@ -45,8 +45,8 @@ theorem Lex.acc (x : α →₀ N) (h : ∀ a ∈ x.support, Acc (rᶜ ⊓ (· 
     Acc (Finsupp.Lex r s) x := by
   rw [lex_eq_inv_image_dfinsupp_lex]
   classical
-  refine' InvImage.accessible to_dfinsupp (Dfinsupp.Lex.acc (fun a => hbot) (fun a => hs) _ _)
-  simpa only [toDfinsupp_support] using h
+  refine' InvImage.accessible to_dfinsupp (DFinsupp.Lex.acc (fun a => hbot) (fun a => hs) _ _)
+  simpa only [toDFinsupp_support] using h
 #align finsupp.lex.acc Finsupp.Lex.acc
 -/
 
@@ -60,7 +60,7 @@ theorem Lex.wellFounded (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded
 theorem Lex.wellFounded' [IsTrichotomous α r] (hr : WellFounded r.symm) :
     WellFounded (Finsupp.Lex r s) :=
   (lex_eq_invImage_dfinsupp_lex r s).symm ▸
-    InvImage.wf _ (Dfinsupp.Lex.wellFounded' (fun a => hbot) (fun a => hs) hr)
+    InvImage.wf _ (DFinsupp.Lex.wellFounded' (fun a => hbot) (fun a => hs) hr)
 #align finsupp.lex.well_founded' Finsupp.Lex.wellFounded'
 -/
 
@@ -90,7 +90,7 @@ theorem Lex.wellFoundedLT_of_finite [LinearOrder α] [Finite α] [Zero N] [LT N]
 #print Finsupp.wellFoundedLT /-
 protected theorem wellFoundedLT [Zero N] [Preorder N] [WellFoundedLT N] (hbot : ∀ n : N, ¬n < 0) :
     WellFoundedLT (α →₀ N) :=
-  ⟨InvImage.wf toDfinsupp (Dfinsupp.wellFoundedLT fun i a => hbot a).wf⟩
+  ⟨InvImage.wf toDFinsupp (DFinsupp.wellFoundedLT fun i a => hbot a).wf⟩
 #align finsupp.well_founded_lt Finsupp.wellFoundedLT
 -/

290a7ba0

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -38,8 +38,7 @@ namespace Finsupp
 variable [hz : Zero N] {r : α → α → Prop} {s : N → N → Prop} (hbot : ∀ ⦃n⦄, ¬s n 0)
   (hs : WellFounded s)
 
-include hbot hs
-
+#print Finsupp.Lex.acc /-
 /-- Transferred from `dfinsupp.lex.acc`. See the top of that file for an explanation for the
   appearance of the relation `rᶜ ⊓ (≠)`. -/
 theorem Lex.acc (x : α →₀ N) (h : ∀ a ∈ x.support, Acc (rᶜ ⊓ (· ≠ ·)) a) :
@@ -49,35 +48,44 @@ theorem Lex.acc (x : α →₀ N) (h : ∀ a ∈ x.support, Acc (rᶜ ⊓ (· 
   refine' InvImage.accessible to_dfinsupp (Dfinsupp.Lex.acc (fun a => hbot) (fun a => hs) _ _)
   simpa only [toDfinsupp_support] using h
 #align finsupp.lex.acc Finsupp.Lex.acc
+-/
 
+#print Finsupp.Lex.wellFounded /-
 theorem Lex.wellFounded (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded (Finsupp.Lex r s) :=
   ⟨fun x => Lex.acc hbot hs x fun a _ => hr.apply a⟩
 #align finsupp.lex.well_founded Finsupp.Lex.wellFounded
+-/
 
+#print Finsupp.Lex.wellFounded' /-
 theorem Lex.wellFounded' [IsTrichotomous α r] (hr : WellFounded r.symm) :
     WellFounded (Finsupp.Lex r s) :=
   (lex_eq_invImage_dfinsupp_lex r s).symm ▸
     InvImage.wf _ (Dfinsupp.Lex.wellFounded' (fun a => hbot) (fun a => hs) hr)
 #align finsupp.lex.well_founded' Finsupp.Lex.wellFounded'
+-/
 
-omit hbot hs
-
+#print Finsupp.Lex.wellFoundedLT /-
 instance Lex.wellFoundedLT [LT α] [IsTrichotomous α (· < ·)] [hα : WellFoundedGT α]
     [CanonicallyOrderedAddMonoid N] [hN : WellFoundedLT N] : WellFoundedLT (Lex (α →₀ N)) :=
   ⟨Lex.wellFounded' (fun n => (zero_le n).not_lt) hN.wf hα.wf⟩
 #align finsupp.lex.well_founded_lt Finsupp.Lex.wellFoundedLT
+-/
 
 variable (r)
 
+#print Finsupp.Lex.wellFounded_of_finite /-
 theorem Lex.wellFounded_of_finite [IsStrictTotalOrder α r] [Finite α] [Zero N]
     (hs : WellFounded s) : WellFounded (Finsupp.Lex r s) :=
   InvImage.wf (@equivFunOnFinite α N _ _) (Pi.Lex.wellFounded r fun a => hs)
 #align finsupp.lex.well_founded_of_finite Finsupp.Lex.wellFounded_of_finite
+-/
 
+#print Finsupp.Lex.wellFoundedLT_of_finite /-
 theorem Lex.wellFoundedLT_of_finite [LinearOrder α] [Finite α] [Zero N] [LT N]
     [hwf : WellFoundedLT N] : WellFoundedLT (Lex (α →₀ N)) :=
   ⟨Finsupp.Lex.wellFounded_of_finite (· < ·) hwf.1⟩
 #align finsupp.lex.well_founded_lt_of_finite Finsupp.Lex.wellFoundedLT_of_finite
+-/
 
 #print Finsupp.wellFoundedLT /-
 protected theorem wellFoundedLT [Zero N] [Preorder N] [WellFoundedLT N] (hbot : ∀ n : N, ¬n < 0) :
@@ -86,10 +94,12 @@ protected theorem wellFoundedLT [Zero N] [Preorder N] [WellFoundedLT N] (hbot :
 #align finsupp.well_founded_lt Finsupp.wellFoundedLT
 -/
 
+#print Finsupp.wellFoundedLT' /-
 instance wellFoundedLT' [CanonicallyOrderedAddMonoid N] [WellFoundedLT N] :
     WellFoundedLT (α →₀ N) :=
   Finsupp.wellFoundedLT fun a => (zero_le a).not_lt
 #align finsupp.well_founded_lt' Finsupp.wellFoundedLT'
+-/
 
 #print Finsupp.wellFoundedLT_of_finite /-
 instance wellFoundedLT_of_finite [Finite α] [Zero N] [Preorder N] [WellFoundedLT N] :

290a7ba0

bump to nightly-2023-06-04-18

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

3fb4268b

Diff

@@ -46,8 +46,8 @@ theorem Lex.acc (x : α →₀ N) (h : ∀ a ∈ x.support, Acc (rᶜ ⊓ (· 
     Acc (Finsupp.Lex r s) x := by
   rw [lex_eq_inv_image_dfinsupp_lex]
   classical
-    refine' InvImage.accessible to_dfinsupp (Dfinsupp.Lex.acc (fun a => hbot) (fun a => hs) _ _)
-    simpa only [toDfinsupp_support] using h
+  refine' InvImage.accessible to_dfinsupp (Dfinsupp.Lex.acc (fun a => hbot) (fun a => hs) _ _)
+  simpa only [toDfinsupp_support] using h
 #align finsupp.lex.acc Finsupp.Lex.acc
 
 theorem Lex.wellFounded (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded (Finsupp.Lex r s) :=

290a7ba0

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -79,20 +79,24 @@ theorem Lex.wellFoundedLT_of_finite [LinearOrder α] [Finite α] [Zero N] [LT N]
   ⟨Finsupp.Lex.wellFounded_of_finite (· < ·) hwf.1⟩
 #align finsupp.lex.well_founded_lt_of_finite Finsupp.Lex.wellFoundedLT_of_finite
 
+#print Finsupp.wellFoundedLT /-
 protected theorem wellFoundedLT [Zero N] [Preorder N] [WellFoundedLT N] (hbot : ∀ n : N, ¬n < 0) :
     WellFoundedLT (α →₀ N) :=
   ⟨InvImage.wf toDfinsupp (Dfinsupp.wellFoundedLT fun i a => hbot a).wf⟩
 #align finsupp.well_founded_lt Finsupp.wellFoundedLT
+-/
 
 instance wellFoundedLT' [CanonicallyOrderedAddMonoid N] [WellFoundedLT N] :
     WellFoundedLT (α →₀ N) :=
   Finsupp.wellFoundedLT fun a => (zero_le a).not_lt
 #align finsupp.well_founded_lt' Finsupp.wellFoundedLT'
 
+#print Finsupp.wellFoundedLT_of_finite /-
 instance wellFoundedLT_of_finite [Finite α] [Zero N] [Preorder N] [WellFoundedLT N] :
     WellFoundedLT (α →₀ N) :=
   ⟨InvImage.wf equivFunOnFinite Function.wellFoundedLT.wf⟩
 #align finsupp.well_founded_lt_of_finite Finsupp.wellFoundedLT_of_finite
+-/
 
 end Finsupp

290a7ba0

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -40,12 +40,6 @@ variable [hz : Zero N] {r : α → α → Prop} {s : N → N → Prop} (hbot : 
 
 include hbot hs
 
-/- warning: finsupp.lex.acc -> Finsupp.Lex.acc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [hz : Zero.{u2} N] {r : α -> α -> Prop} {s : N -> N -> Prop}, (forall {{n : N}}, Not (s n (OfNat.ofNat.{u2} N 0 (OfNat.mk.{u2} N 0 (Zero.zero.{u2} N hz))))) -> (WellFounded.{succ u2} N s) -> (forall (x : Finsupp.{u1, u2} α N hz), (forall (a : α), (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a (Finsupp.support.{u1, u2} α N hz x)) -> (Acc.{succ u1} α (Inf.inf.{u1} (α -> α -> Prop) (Pi.hasInf.{u1, u1} α (fun (ᾰ : α) => α -> Prop) (fun (i : α) => Pi.hasInf.{u1, 0} α (fun (ᾰ : α) => Prop) (fun (i : α) => SemilatticeInf.toHasInf.{0} Prop (Lattice.toSemilatticeInf.{0} Prop (ConditionallyCompleteLattice.toLattice.{0} Prop (CompleteLattice.toConditionallyCompleteLattice.{0} Prop Prop.completeLattice)))))) (HasCompl.compl.{u1} (α -> α -> Prop) (Pi.hasCompl.{u1, u1} α (fun (ᾰ : α) => α -> Prop) (fun (i : α) => Pi.hasCompl.{u1, 0} α (fun (ᾰ : α) => Prop) (fun (i : α) => Prop.hasCompl))) r) (Ne.{succ u1} α)) a)) -> (Acc.{max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N hz) (Finsupp.Lex.{u1, u2} α N hz r s) x))
-but is expected to have type
-  forall {α : Type.{u2}} {N : Type.{u1}} [hz : Zero.{u1} N] {r : α -> α -> Prop} {s : N -> N -> Prop}, (forall {{n : N}}, Not (s n (OfNat.ofNat.{u1} N 0 (Zero.toOfNat0.{u1} N hz)))) -> (WellFounded.{succ u1} N s) -> (forall (x : Finsupp.{u2, u1} α N hz), (forall (a : α), (Membership.mem.{u2, u2} α (Finset.{u2} α) (Finset.instMembershipFinset.{u2} α) a (Finsupp.support.{u2, u1} α N hz x)) -> (Acc.{succ u2} α (Inf.inf.{u2} (α -> α -> Prop) (Pi.instInfForAll.{u2, u2} α (fun (ᾰ : α) => α -> Prop) (fun (i : α) => Pi.instInfForAll.{u2, 0} α (fun (ᾰ : α) => Prop) (fun (i : α) => Lattice.toInf.{0} Prop (ConditionallyCompleteLattice.toLattice.{0} Prop (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Prop (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} Prop (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} Prop Prop.completeLinearOrder))))))) (HasCompl.compl.{u2} (α -> α -> Prop) (Pi.hasCompl.{u2, u2} α (fun (ᾰ : α) => α -> Prop) (fun (i : α) => Pi.hasCompl.{u2, 0} α (fun (ᾰ : α) => Prop) (fun (i : α) => Prop.hasCompl))) r) (fun (x._@.Mathlib.Data.Finsupp.WellFounded._hyg.102 : α) (x._@.Mathlib.Data.Finsupp.WellFounded._hyg.104 : α) => Ne.{succ u2} α x._@.Mathlib.Data.Finsupp.WellFounded._hyg.102 x._@.Mathlib.Data.Finsupp.WellFounded._hyg.104)) a)) -> (Acc.{max (succ u1) (succ u2)} (Finsupp.{u2, u1} α N hz) (Finsupp.Lex.{u2, u1} α N hz r s) x))
-Case conversion may be inaccurate. Consider using '#align finsupp.lex.acc Finsupp.Lex.accₓ'. -/
 /-- Transferred from `dfinsupp.lex.acc`. See the top of that file for an explanation for the
   appearance of the relation `rᶜ ⊓ (≠)`. -/
 theorem Lex.acc (x : α →₀ N) (h : ∀ a ∈ x.support, Acc (rᶜ ⊓ (· ≠ ·)) a) :
@@ -56,22 +50,10 @@ theorem Lex.acc (x : α →₀ N) (h : ∀ a ∈ x.support, Acc (rᶜ ⊓ (· 
     simpa only [toDfinsupp_support] using h
 #align finsupp.lex.acc Finsupp.Lex.acc
 
-/- warning: finsupp.lex.well_founded -> Finsupp.Lex.wellFounded is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [hz : Zero.{u2} N] {r : α -> α -> Prop} {s : N -> N -> Prop}, (forall {{n : N}}, Not (s n (OfNat.ofNat.{u2} N 0 (OfNat.mk.{u2} N 0 (Zero.zero.{u2} N hz))))) -> (WellFounded.{succ u2} N s) -> (WellFounded.{succ u1} α (Inf.inf.{u1} (α -> α -> Prop) (Pi.hasInf.{u1, u1} α (fun (ᾰ : α) => α -> Prop) (fun (i : α) => Pi.hasInf.{u1, 0} α (fun (ᾰ : α) => Prop) (fun (i : α) => SemilatticeInf.toHasInf.{0} Prop (Lattice.toSemilatticeInf.{0} Prop (ConditionallyCompleteLattice.toLattice.{0} Prop (CompleteLattice.toConditionallyCompleteLattice.{0} Prop Prop.completeLattice)))))) (HasCompl.compl.{u1} (α -> α -> Prop) (Pi.hasCompl.{u1, u1} α (fun (ᾰ : α) => α -> Prop) (fun (i : α) => Pi.hasCompl.{u1, 0} α (fun (ᾰ : α) => Prop) (fun (i : α) => Prop.hasCompl))) r) (Ne.{succ u1} α))) -> (WellFounded.{max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N hz) (Finsupp.Lex.{u1, u2} α N hz r s))
-but is expected to have type
-  forall {α : Type.{u2}} {N : Type.{u1}} [hz : Zero.{u1} N] {r : α -> α -> Prop} {s : N -> N -> Prop}, (forall {{n : N}}, Not (s n (OfNat.ofNat.{u1} N 0 (Zero.toOfNat0.{u1} N hz)))) -> (WellFounded.{succ u1} N s) -> (WellFounded.{succ u2} α (Inf.inf.{u2} (α -> α -> Prop) (Pi.instInfForAll.{u2, u2} α (fun (ᾰ : α) => α -> Prop) (fun (i : α) => Pi.instInfForAll.{u2, 0} α (fun (ᾰ : α) => Prop) (fun (i : α) => Lattice.toInf.{0} Prop (ConditionallyCompleteLattice.toLattice.{0} Prop (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Prop (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} Prop (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} Prop Prop.completeLinearOrder))))))) (HasCompl.compl.{u2} (α -> α -> Prop) (Pi.hasCompl.{u2, u2} α (fun (ᾰ : α) => α -> Prop) (fun (i : α) => Pi.hasCompl.{u2, 0} α (fun (ᾰ : α) => Prop) (fun (i : α) => Prop.hasCompl))) r) (fun (x._@.Mathlib.Data.Finsupp.WellFounded._hyg.228 : α) (x._@.Mathlib.Data.Finsupp.WellFounded._hyg.230 : α) => Ne.{succ u2} α x._@.Mathlib.Data.Finsupp.WellFounded._hyg.228 x._@.Mathlib.Data.Finsupp.WellFounded._hyg.230))) -> (WellFounded.{max (succ u1) (succ u2)} (Finsupp.{u2, u1} α N hz) (Finsupp.Lex.{u2, u1} α N hz r s))
-Case conversion may be inaccurate. Consider using '#align finsupp.lex.well_founded Finsupp.Lex.wellFoundedₓ'. -/
 theorem Lex.wellFounded (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded (Finsupp.Lex r s) :=
   ⟨fun x => Lex.acc hbot hs x fun a _ => hr.apply a⟩
 #align finsupp.lex.well_founded Finsupp.Lex.wellFounded
 
-/- warning: finsupp.lex.well_founded' -> Finsupp.Lex.wellFounded' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [hz : Zero.{u2} N] {r : α -> α -> Prop} {s : N -> N -> Prop}, (forall {{n : N}}, Not (s n (OfNat.ofNat.{u2} N 0 (OfNat.mk.{u2} N 0 (Zero.zero.{u2} N hz))))) -> (WellFounded.{succ u2} N s) -> (forall [_inst_1 : IsTrichotomous.{u1} α r], (WellFounded.{succ u1} α (Function.swap.{succ u1, succ u1, 1} α α (fun (ᾰ : α) (ᾰ : α) => Prop) r)) -> (WellFounded.{max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N hz) (Finsupp.Lex.{u1, u2} α N hz r s)))
-but is expected to have type
-  forall {α : Type.{u2}} {N : Type.{u1}} [hz : Zero.{u1} N] {r : α -> α -> Prop} {s : N -> N -> Prop}, (forall {{n : N}}, Not (s n (OfNat.ofNat.{u1} N 0 (Zero.toOfNat0.{u1} N hz)))) -> (WellFounded.{succ u1} N s) -> (forall [_inst_1 : IsTrichotomous.{u2} α r], (WellFounded.{succ u2} α (Function.swap.{succ u2, succ u2, 1} α α (fun (ᾰ : α) (ᾰ : α) => Prop) r)) -> (WellFounded.{max (succ u1) (succ u2)} (Finsupp.{u2, u1} α N hz) (Finsupp.Lex.{u2, u1} α N hz r s)))
-Case conversion may be inaccurate. Consider using '#align finsupp.lex.well_founded' Finsupp.Lex.wellFounded'ₓ'. -/
 theorem Lex.wellFounded' [IsTrichotomous α r] (hr : WellFounded r.symm) :
     WellFounded (Finsupp.Lex r s) :=
   (lex_eq_invImage_dfinsupp_lex r s).symm ▸
@@ -80,12 +62,6 @@ theorem Lex.wellFounded' [IsTrichotomous α r] (hr : WellFounded r.symm) :
 
 omit hbot hs
 
-/- warning: finsupp.lex.well_founded_lt -> Finsupp.Lex.wellFoundedLT is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LT.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (LT.lt.{u1} α _inst_1)] [hα : WellFoundedGT.{u1} α _inst_1] [_inst_3 : CanonicallyOrderedAddMonoid.{u2} N] [hN : WellFoundedLT.{u2} N (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3))))], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3))))))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3))))) _inst_1 (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3)))))
-but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LT.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (fun (x._@.Mathlib.Data.Finsupp.WellFounded._hyg.381 : α) (x._@.Mathlib.Data.Finsupp.WellFounded._hyg.383 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Data.Finsupp.WellFounded._hyg.381 x._@.Mathlib.Data.Finsupp.WellFounded._hyg.383)] [hα : WellFoundedGT.{u1} α _inst_1] [_inst_3 : CanonicallyOrderedAddMonoid.{u2} N] [hN : WellFoundedLT.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3))))], WellFoundedLT.{max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3)))))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3)))) _inst_1 (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3)))))
-Case conversion may be inaccurate. Consider using '#align finsupp.lex.well_founded_lt Finsupp.Lex.wellFoundedLTₓ'. -/
 instance Lex.wellFoundedLT [LT α] [IsTrichotomous α (· < ·)] [hα : WellFoundedGT α]
     [CanonicallyOrderedAddMonoid N] [hN : WellFoundedLT N] : WellFoundedLT (Lex (α →₀ N)) :=
   ⟨Lex.wellFounded' (fun n => (zero_le n).not_lt) hN.wf hα.wf⟩
@@ -93,56 +69,26 @@ instance Lex.wellFoundedLT [LT α] [IsTrichotomous α (· < ·)] [hα : WellFoun
 
 variable (r)
 
-/- warning: finsupp.lex.well_founded_of_finite -> Finsupp.Lex.wellFounded_of_finite is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} (r : α -> α -> Prop) {s : N -> N -> Prop} [_inst_1 : IsStrictTotalOrder.{u1} α r] [_inst_2 : Finite.{succ u1} α] [_inst_3 : Zero.{u2} N], (WellFounded.{succ u2} N s) -> (WellFounded.{max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_3) (Finsupp.Lex.{u1, u2} α N _inst_3 r s))
-but is expected to have type
-  forall {α : Type.{u2}} {N : Type.{u1}} (r : α -> α -> Prop) {s : N -> N -> Prop} [_inst_1 : IsStrictTotalOrder.{u2} α r] [_inst_2 : Finite.{succ u2} α] [_inst_3 : Zero.{u1} N], (WellFounded.{succ u1} N s) -> (WellFounded.{max (succ u1) (succ u2)} (Finsupp.{u2, u1} α N _inst_3) (Finsupp.Lex.{u2, u1} α N _inst_3 r s))
-Case conversion may be inaccurate. Consider using '#align finsupp.lex.well_founded_of_finite Finsupp.Lex.wellFounded_of_finiteₓ'. -/
 theorem Lex.wellFounded_of_finite [IsStrictTotalOrder α r] [Finite α] [Zero N]
     (hs : WellFounded s) : WellFounded (Finsupp.Lex r s) :=
   InvImage.wf (@equivFunOnFinite α N _ _) (Pi.Lex.wellFounded r fun a => hs)
 #align finsupp.lex.well_founded_of_finite Finsupp.Lex.wellFounded_of_finite
 
-/- warning: finsupp.lex.well_founded_lt_of_finite -> Finsupp.Lex.wellFoundedLT_of_finite is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Finite.{succ u1} α] [_inst_3 : Zero.{u2} N] [_inst_4 : LT.{u2} N] [hwf : WellFoundedLT.{u2} N _inst_4], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_3)) (Finsupp.Lex.hasLt.{u1, u2} α N _inst_3 (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) _inst_4)
-but is expected to have type
-  forall {α : Type.{u2}} {N : Type.{u1}} [_inst_1 : LinearOrder.{u2} α] [_inst_2 : Finite.{succ u2} α] [_inst_3 : Zero.{u1} N] [_inst_4 : LT.{u1} N] [hwf : WellFoundedLT.{u1} N _inst_4], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_3)) (Finsupp.instLTLexFinsupp.{u2, u1} α N _inst_3 (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))) _inst_4)
-Case conversion may be inaccurate. Consider using '#align finsupp.lex.well_founded_lt_of_finite Finsupp.Lex.wellFoundedLT_of_finiteₓ'. -/
 theorem Lex.wellFoundedLT_of_finite [LinearOrder α] [Finite α] [Zero N] [LT N]
     [hwf : WellFoundedLT N] : WellFoundedLT (Lex (α →₀ N)) :=
   ⟨Finsupp.Lex.wellFounded_of_finite (· < ·) hwf.1⟩
 #align finsupp.lex.well_founded_lt_of_finite Finsupp.Lex.wellFoundedLT_of_finite
 
-/- warning: finsupp.well_founded_lt -> Finsupp.wellFoundedLT is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : Preorder.{u2} N] [_inst_3 : WellFoundedLT.{u2} N (Preorder.toHasLt.{u2} N _inst_2)], (forall (n : N), Not (LT.lt.{u2} N (Preorder.toHasLt.{u2} N _inst_2) n (OfNat.ofNat.{u2} N 0 (OfNat.mk.{u2} N 0 (Zero.zero.{u2} N _inst_1))))) -> (WellFoundedLT.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Preorder.toHasLt.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Finsupp.preorder.{u1, u2} α N _inst_1 _inst_2)))
-but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : Preorder.{u2} N] [_inst_3 : WellFoundedLT.{u2} N (Preorder.toLT.{u2} N _inst_2)], (forall (n : N), Not (LT.lt.{u2} N (Preorder.toLT.{u2} N _inst_2) n (OfNat.ofNat.{u2} N 0 (Zero.toOfNat0.{u2} N _inst_1)))) -> (WellFoundedLT.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1) (Preorder.toLT.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Finsupp.preorder.{u1, u2} α N _inst_1 _inst_2)))
-Case conversion may be inaccurate. Consider using '#align finsupp.well_founded_lt Finsupp.wellFoundedLTₓ'. -/
 protected theorem wellFoundedLT [Zero N] [Preorder N] [WellFoundedLT N] (hbot : ∀ n : N, ¬n < 0) :
     WellFoundedLT (α →₀ N) :=
   ⟨InvImage.wf toDfinsupp (Dfinsupp.wellFoundedLT fun i a => hbot a).wf⟩
 #align finsupp.well_founded_lt Finsupp.wellFoundedLT
 
-/- warning: finsupp.well_founded_lt' -> Finsupp.wellFoundedLT' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : CanonicallyOrderedAddMonoid.{u2} N] [_inst_2 : WellFoundedLT.{u2} N (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))], WellFoundedLT.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))))) (Preorder.toHasLt.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))))) (Finsupp.preorder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))) (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : CanonicallyOrderedAddMonoid.{u2} N] [_inst_2 : WellFoundedLT.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))], WellFoundedLT.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))) (Preorder.toLT.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))) (Finsupp.preorder.{u1, u2} α N (AddMonoid.toZero.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))) (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align finsupp.well_founded_lt' Finsupp.wellFoundedLT'ₓ'. -/
 instance wellFoundedLT' [CanonicallyOrderedAddMonoid N] [WellFoundedLT N] :
     WellFoundedLT (α →₀ N) :=
   Finsupp.wellFoundedLT fun a => (zero_le a).not_lt
 #align finsupp.well_founded_lt' Finsupp.wellFoundedLT'
 
-/- warning: finsupp.well_founded_lt_of_finite -> Finsupp.wellFoundedLT_of_finite is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Finite.{succ u1} α] [_inst_2 : Zero.{u2} N] [_inst_3 : Preorder.{u2} N] [_inst_4 : WellFoundedLT.{u2} N (Preorder.toHasLt.{u2} N _inst_3)], WellFoundedLT.{max u1 u2} (Finsupp.{u1, u2} α N _inst_2) (Preorder.toHasLt.{max u1 u2} (Finsupp.{u1, u2} α N _inst_2) (Finsupp.preorder.{u1, u2} α N _inst_2 _inst_3))
-but is expected to have type
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Finite.{succ u1} α] [_inst_2 : Zero.{u2} N] [_inst_3 : Preorder.{u2} N] [_inst_4 : WellFoundedLT.{u2} N (Preorder.toLT.{u2} N _inst_3)], WellFoundedLT.{max u2 u1} (Finsupp.{u1, u2} α N _inst_2) (Preorder.toLT.{max u1 u2} (Finsupp.{u1, u2} α N _inst_2) (Finsupp.preorder.{u1, u2} α N _inst_2 _inst_3))
-Case conversion may be inaccurate. Consider using '#align finsupp.well_founded_lt_of_finite Finsupp.wellFoundedLT_of_finiteₓ'. -/
 instance wellFoundedLT_of_finite [Finite α] [Zero N] [Preorder N] [WellFoundedLT N] :
     WellFoundedLT (α →₀ N) :=
   ⟨InvImage.wf equivFunOnFinite Function.wellFoundedLT.wf⟩

290a7ba0

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -82,7 +82,7 @@ omit hbot hs
 
 /- warning: finsupp.lex.well_founded_lt -> Finsupp.Lex.wellFoundedLT is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LT.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (LT.lt.{u1} α _inst_1)] [hα : WellFoundedGT.{u1} α _inst_1] [_inst_3 : CanonicallyOrderedAddMonoid.{u2} N] [hN : WellFoundedLT.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3))))], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3))))))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3))))) _inst_1 (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3)))))
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LT.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (LT.lt.{u1} α _inst_1)] [hα : WellFoundedGT.{u1} α _inst_1] [_inst_3 : CanonicallyOrderedAddMonoid.{u2} N] [hN : WellFoundedLT.{u2} N (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3))))], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3))))))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3))))) _inst_1 (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3)))))
 but is expected to have type
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LT.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (fun (x._@.Mathlib.Data.Finsupp.WellFounded._hyg.381 : α) (x._@.Mathlib.Data.Finsupp.WellFounded._hyg.383 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Data.Finsupp.WellFounded._hyg.381 x._@.Mathlib.Data.Finsupp.WellFounded._hyg.383)] [hα : WellFoundedGT.{u1} α _inst_1] [_inst_3 : CanonicallyOrderedAddMonoid.{u2} N] [hN : WellFoundedLT.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3))))], WellFoundedLT.{max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3)))))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3)))) _inst_1 (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3)))))
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.well_founded_lt Finsupp.Lex.wellFoundedLTₓ'. -/
@@ -106,7 +106,7 @@ theorem Lex.wellFounded_of_finite [IsStrictTotalOrder α r] [Finite α] [Zero N]
 
 /- warning: finsupp.lex.well_founded_lt_of_finite -> Finsupp.Lex.wellFoundedLT_of_finite is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Finite.{succ u1} α] [_inst_3 : Zero.{u2} N] [_inst_4 : LT.{u2} N] [hwf : WellFoundedLT.{u2} N _inst_4], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_3)) (Finsupp.Lex.hasLt.{u1, u2} α N _inst_3 (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) _inst_4)
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Finite.{succ u1} α] [_inst_3 : Zero.{u2} N] [_inst_4 : LT.{u2} N] [hwf : WellFoundedLT.{u2} N _inst_4], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_3)) (Finsupp.Lex.hasLt.{u1, u2} α N _inst_3 (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) _inst_4)
 but is expected to have type
   forall {α : Type.{u2}} {N : Type.{u1}} [_inst_1 : LinearOrder.{u2} α] [_inst_2 : Finite.{succ u2} α] [_inst_3 : Zero.{u1} N] [_inst_4 : LT.{u1} N] [hwf : WellFoundedLT.{u1} N _inst_4], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_3)) (Finsupp.instLTLexFinsupp.{u2, u1} α N _inst_3 (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))) _inst_4)
 Case conversion may be inaccurate. Consider using '#align finsupp.lex.well_founded_lt_of_finite Finsupp.Lex.wellFoundedLT_of_finiteₓ'. -/
@@ -115,16 +115,20 @@ theorem Lex.wellFoundedLT_of_finite [LinearOrder α] [Finite α] [Zero N] [LT N]
   ⟨Finsupp.Lex.wellFounded_of_finite (· < ·) hwf.1⟩
 #align finsupp.lex.well_founded_lt_of_finite Finsupp.Lex.wellFoundedLT_of_finite
 
-#print Finsupp.wellFoundedLT /-
+/- warning: finsupp.well_founded_lt -> Finsupp.wellFoundedLT is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : Preorder.{u2} N] [_inst_3 : WellFoundedLT.{u2} N (Preorder.toHasLt.{u2} N _inst_2)], (forall (n : N), Not (LT.lt.{u2} N (Preorder.toHasLt.{u2} N _inst_2) n (OfNat.ofNat.{u2} N 0 (OfNat.mk.{u2} N 0 (Zero.zero.{u2} N _inst_1))))) -> (WellFoundedLT.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Preorder.toHasLt.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Finsupp.preorder.{u1, u2} α N _inst_1 _inst_2)))
+but is expected to have type
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Zero.{u2} N] [_inst_2 : Preorder.{u2} N] [_inst_3 : WellFoundedLT.{u2} N (Preorder.toLT.{u2} N _inst_2)], (forall (n : N), Not (LT.lt.{u2} N (Preorder.toLT.{u2} N _inst_2) n (OfNat.ofNat.{u2} N 0 (Zero.toOfNat0.{u2} N _inst_1)))) -> (WellFoundedLT.{max u2 u1} (Finsupp.{u1, u2} α N _inst_1) (Preorder.toLT.{max u1 u2} (Finsupp.{u1, u2} α N _inst_1) (Finsupp.preorder.{u1, u2} α N _inst_1 _inst_2)))
+Case conversion may be inaccurate. Consider using '#align finsupp.well_founded_lt Finsupp.wellFoundedLTₓ'. -/
 protected theorem wellFoundedLT [Zero N] [Preorder N] [WellFoundedLT N] (hbot : ∀ n : N, ¬n < 0) :
     WellFoundedLT (α →₀ N) :=
   ⟨InvImage.wf toDfinsupp (Dfinsupp.wellFoundedLT fun i a => hbot a).wf⟩
 #align finsupp.well_founded_lt Finsupp.wellFoundedLT
--/
 
 /- warning: finsupp.well_founded_lt' -> Finsupp.wellFoundedLT' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : CanonicallyOrderedAddMonoid.{u2} N] [_inst_2 : WellFoundedLT.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))], WellFoundedLT.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))))) (Preorder.toLT.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))))) (Finsupp.preorder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))) (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))))
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : CanonicallyOrderedAddMonoid.{u2} N] [_inst_2 : WellFoundedLT.{u2} N (Preorder.toHasLt.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))], WellFoundedLT.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))))) (Preorder.toHasLt.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))))) (Finsupp.preorder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))) (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : CanonicallyOrderedAddMonoid.{u2} N] [_inst_2 : WellFoundedLT.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))], WellFoundedLT.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))) (Preorder.toLT.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))) (Finsupp.preorder.{u1, u2} α N (AddMonoid.toZero.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))) (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))))
 Case conversion may be inaccurate. Consider using '#align finsupp.well_founded_lt' Finsupp.wellFoundedLT'ₓ'. -/
@@ -133,12 +137,16 @@ instance wellFoundedLT' [CanonicallyOrderedAddMonoid N] [WellFoundedLT N] :
   Finsupp.wellFoundedLT fun a => (zero_le a).not_lt
 #align finsupp.well_founded_lt' Finsupp.wellFoundedLT'
 
-#print Finsupp.wellFoundedLT_of_finite /-
+/- warning: finsupp.well_founded_lt_of_finite -> Finsupp.wellFoundedLT_of_finite is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Finite.{succ u1} α] [_inst_2 : Zero.{u2} N] [_inst_3 : Preorder.{u2} N] [_inst_4 : WellFoundedLT.{u2} N (Preorder.toHasLt.{u2} N _inst_3)], WellFoundedLT.{max u1 u2} (Finsupp.{u1, u2} α N _inst_2) (Preorder.toHasLt.{max u1 u2} (Finsupp.{u1, u2} α N _inst_2) (Finsupp.preorder.{u1, u2} α N _inst_2 _inst_3))
+but is expected to have type
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : Finite.{succ u1} α] [_inst_2 : Zero.{u2} N] [_inst_3 : Preorder.{u2} N] [_inst_4 : WellFoundedLT.{u2} N (Preorder.toLT.{u2} N _inst_3)], WellFoundedLT.{max u2 u1} (Finsupp.{u1, u2} α N _inst_2) (Preorder.toLT.{max u1 u2} (Finsupp.{u1, u2} α N _inst_2) (Finsupp.preorder.{u1, u2} α N _inst_2 _inst_3))
+Case conversion may be inaccurate. Consider using '#align finsupp.well_founded_lt_of_finite Finsupp.wellFoundedLT_of_finiteₓ'. -/
 instance wellFoundedLT_of_finite [Finite α] [Zero N] [Preorder N] [WellFoundedLT N] :
     WellFoundedLT (α →₀ N) :=
   ⟨InvImage.wf equivFunOnFinite Function.wellFoundedLT.wf⟩
 #align finsupp.well_founded_lt_of_finite Finsupp.wellFoundedLT_of_finite
--/
 
 end Finsupp

290a7ba0

bump to nightly-2023-03-27-10

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

1caedb6b

Diff

@@ -122,16 +122,16 @@ protected theorem wellFoundedLT [Zero N] [Preorder N] [WellFoundedLT N] (hbot :
 #align finsupp.well_founded_lt Finsupp.wellFoundedLT
 -/
 
-/- warning: finsupp.well_founded_lt' -> Finsupp.well_founded_lt' is a dubious translation:
+/- warning: finsupp.well_founded_lt' -> Finsupp.wellFoundedLT' is a dubious translation:
 lean 3 declaration is
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : CanonicallyOrderedAddMonoid.{u2} N] [_inst_2 : WellFoundedLT.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))], WellFoundedLT.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))))) (Preorder.toLT.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))))) (Finsupp.preorder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))) (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : CanonicallyOrderedAddMonoid.{u2} N] [_inst_2 : WellFoundedLT.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))], WellFoundedLT.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))) (Preorder.toLT.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))) (Finsupp.preorder.{u1, u2} α N (AddMonoid.toZero.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))) (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align finsupp.well_founded_lt' Finsupp.well_founded_lt'ₓ'. -/
-instance well_founded_lt' [CanonicallyOrderedAddMonoid N] [WellFoundedLT N] :
+Case conversion may be inaccurate. Consider using '#align finsupp.well_founded_lt' Finsupp.wellFoundedLT'ₓ'. -/
+instance wellFoundedLT' [CanonicallyOrderedAddMonoid N] [WellFoundedLT N] :
     WellFoundedLT (α →₀ N) :=
   Finsupp.wellFoundedLT fun a => (zero_le a).not_lt
-#align finsupp.well_founded_lt' Finsupp.well_founded_lt'
+#align finsupp.well_founded_lt' Finsupp.wellFoundedLT'
 
 #print Finsupp.wellFoundedLT_of_finite /-
 instance wellFoundedLT_of_finite [Finite α] [Zero N] [Preorder N] [WellFoundedLT N] :

290a7ba0

bump to nightly-2023-03-21-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/290a7ba01fbcab1b64757bdaa270d28f4dcede35

c67df486

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Junyan Xu
 
 ! This file was ported from Lean 3 source module data.finsupp.well_founded
-! leanprover-community/mathlib commit 5fd3186f1ec30a75d5f65732e3ce5e623382556f
+! leanprover-community/mathlib commit 290a7ba01fbcab1b64757bdaa270d28f4dcede35
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.Data.Finsupp.Lex
 /-!
 # Well-foundedness of the lexicographic and product orders on `finsupp`
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 `finsupp.lex.well_founded` and the two variants that follow it essentially say that if
 `(>)` is a well order on `α`, `(<)` is well-founded on `N`, and `0` is a bottom element in `N`,
 then the lexicographic `(<)` is well-founded on `α →₀ N`.

5fd3186f

bump to nightly-2023-03-19-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/1f4705ccdfe1e557fc54a0ce081a05e33d2e6240

2ebbb111

Diff

@@ -37,6 +37,12 @@ variable [hz : Zero N] {r : α → α → Prop} {s : N → N → Prop} (hbot : 
 
 include hbot hs
 
+/- warning: finsupp.lex.acc -> Finsupp.Lex.acc is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {N : Type.{u2}} [hz : Zero.{u2} N] {r : α -> α -> Prop} {s : N -> N -> Prop}, (forall {{n : N}}, Not (s n (OfNat.ofNat.{u2} N 0 (OfNat.mk.{u2} N 0 (Zero.zero.{u2} N hz))))) -> (WellFounded.{succ u2} N s) -> (forall (x : Finsupp.{u1, u2} α N hz), (forall (a : α), (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a (Finsupp.support.{u1, u2} α N hz x)) -> (Acc.{succ u1} α (Inf.inf.{u1} (α -> α -> Prop) (Pi.hasInf.{u1, u1} α (fun (ᾰ : α) => α -> Prop) (fun (i : α) => Pi.hasInf.{u1, 0} α (fun (ᾰ : α) => Prop) (fun (i : α) => SemilatticeInf.toHasInf.{0} Prop (Lattice.toSemilatticeInf.{0} Prop (ConditionallyCompleteLattice.toLattice.{0} Prop (CompleteLattice.toConditionallyCompleteLattice.{0} Prop Prop.completeLattice)))))) (HasCompl.compl.{u1} (α -> α -> Prop) (Pi.hasCompl.{u1, u1} α (fun (ᾰ : α) => α -> Prop) (fun (i : α) => Pi.hasCompl.{u1, 0} α (fun (ᾰ : α) => Prop) (fun (i : α) => Prop.hasCompl))) r) (Ne.{succ u1} α)) a)) -> (Acc.{max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N hz) (Finsupp.Lex.{u1, u2} α N hz r s) x))
+but is expected to have type
+  forall {α : Type.{u2}} {N : Type.{u1}} [hz : Zero.{u1} N] {r : α -> α -> Prop} {s : N -> N -> Prop}, (forall {{n : N}}, Not (s n (OfNat.ofNat.{u1} N 0 (Zero.toOfNat0.{u1} N hz)))) -> (WellFounded.{succ u1} N s) -> (forall (x : Finsupp.{u2, u1} α N hz), (forall (a : α), (Membership.mem.{u2, u2} α (Finset.{u2} α) (Finset.instMembershipFinset.{u2} α) a (Finsupp.support.{u2, u1} α N hz x)) -> (Acc.{succ u2} α (Inf.inf.{u2} (α -> α -> Prop) (Pi.instInfForAll.{u2, u2} α (fun (ᾰ : α) => α -> Prop) (fun (i : α) => Pi.instInfForAll.{u2, 0} α (fun (ᾰ : α) => Prop) (fun (i : α) => Lattice.toInf.{0} Prop (ConditionallyCompleteLattice.toLattice.{0} Prop (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Prop (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} Prop (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} Prop Prop.completeLinearOrder))))))) (HasCompl.compl.{u2} (α -> α -> Prop) (Pi.hasCompl.{u2, u2} α (fun (ᾰ : α) => α -> Prop) (fun (i : α) => Pi.hasCompl.{u2, 0} α (fun (ᾰ : α) => Prop) (fun (i : α) => Prop.hasCompl))) r) (fun (x._@.Mathlib.Data.Finsupp.WellFounded._hyg.102 : α) (x._@.Mathlib.Data.Finsupp.WellFounded._hyg.104 : α) => Ne.{succ u2} α x._@.Mathlib.Data.Finsupp.WellFounded._hyg.102 x._@.Mathlib.Data.Finsupp.WellFounded._hyg.104)) a)) -> (Acc.{max (succ u1) (succ u2)} (Finsupp.{u2, u1} α N hz) (Finsupp.Lex.{u2, u1} α N hz r s) x))
+Case conversion may be inaccurate. Consider using '#align finsupp.lex.acc Finsupp.Lex.accₓ'. -/
 /-- Transferred from `dfinsupp.lex.acc`. See the top of that file for an explanation for the
   appearance of the relation `rᶜ ⊓ (≠)`. -/
 theorem Lex.acc (x : α →₀ N) (h : ∀ a ∈ x.support, Acc (rᶜ ⊓ (· ≠ ·)) a) :
@@ -47,49 +53,89 @@ theorem Lex.acc (x : α →₀ N) (h : ∀ a ∈ x.support, Acc (rᶜ ⊓ (· 
     simpa only [toDfinsupp_support] using h
 #align finsupp.lex.acc Finsupp.Lex.acc
 
+/- warning: finsupp.lex.well_founded -> Finsupp.Lex.wellFounded is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {N : Type.{u2}} [hz : Zero.{u2} N] {r : α -> α -> Prop} {s : N -> N -> Prop}, (forall {{n : N}}, Not (s n (OfNat.ofNat.{u2} N 0 (OfNat.mk.{u2} N 0 (Zero.zero.{u2} N hz))))) -> (WellFounded.{succ u2} N s) -> (WellFounded.{succ u1} α (Inf.inf.{u1} (α -> α -> Prop) (Pi.hasInf.{u1, u1} α (fun (ᾰ : α) => α -> Prop) (fun (i : α) => Pi.hasInf.{u1, 0} α (fun (ᾰ : α) => Prop) (fun (i : α) => SemilatticeInf.toHasInf.{0} Prop (Lattice.toSemilatticeInf.{0} Prop (ConditionallyCompleteLattice.toLattice.{0} Prop (CompleteLattice.toConditionallyCompleteLattice.{0} Prop Prop.completeLattice)))))) (HasCompl.compl.{u1} (α -> α -> Prop) (Pi.hasCompl.{u1, u1} α (fun (ᾰ : α) => α -> Prop) (fun (i : α) => Pi.hasCompl.{u1, 0} α (fun (ᾰ : α) => Prop) (fun (i : α) => Prop.hasCompl))) r) (Ne.{succ u1} α))) -> (WellFounded.{max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N hz) (Finsupp.Lex.{u1, u2} α N hz r s))
+but is expected to have type
+  forall {α : Type.{u2}} {N : Type.{u1}} [hz : Zero.{u1} N] {r : α -> α -> Prop} {s : N -> N -> Prop}, (forall {{n : N}}, Not (s n (OfNat.ofNat.{u1} N 0 (Zero.toOfNat0.{u1} N hz)))) -> (WellFounded.{succ u1} N s) -> (WellFounded.{succ u2} α (Inf.inf.{u2} (α -> α -> Prop) (Pi.instInfForAll.{u2, u2} α (fun (ᾰ : α) => α -> Prop) (fun (i : α) => Pi.instInfForAll.{u2, 0} α (fun (ᾰ : α) => Prop) (fun (i : α) => Lattice.toInf.{0} Prop (ConditionallyCompleteLattice.toLattice.{0} Prop (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{0} Prop (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} Prop (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{0} Prop Prop.completeLinearOrder))))))) (HasCompl.compl.{u2} (α -> α -> Prop) (Pi.hasCompl.{u2, u2} α (fun (ᾰ : α) => α -> Prop) (fun (i : α) => Pi.hasCompl.{u2, 0} α (fun (ᾰ : α) => Prop) (fun (i : α) => Prop.hasCompl))) r) (fun (x._@.Mathlib.Data.Finsupp.WellFounded._hyg.228 : α) (x._@.Mathlib.Data.Finsupp.WellFounded._hyg.230 : α) => Ne.{succ u2} α x._@.Mathlib.Data.Finsupp.WellFounded._hyg.228 x._@.Mathlib.Data.Finsupp.WellFounded._hyg.230))) -> (WellFounded.{max (succ u1) (succ u2)} (Finsupp.{u2, u1} α N hz) (Finsupp.Lex.{u2, u1} α N hz r s))
+Case conversion may be inaccurate. Consider using '#align finsupp.lex.well_founded Finsupp.Lex.wellFoundedₓ'. -/
 theorem Lex.wellFounded (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded (Finsupp.Lex r s) :=
   ⟨fun x => Lex.acc hbot hs x fun a _ => hr.apply a⟩
 #align finsupp.lex.well_founded Finsupp.Lex.wellFounded
 
-theorem Lex.well_founded' [IsTrichotomous α r] (hr : WellFounded r.symm) :
+/- warning: finsupp.lex.well_founded' -> Finsupp.Lex.wellFounded' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {N : Type.{u2}} [hz : Zero.{u2} N] {r : α -> α -> Prop} {s : N -> N -> Prop}, (forall {{n : N}}, Not (s n (OfNat.ofNat.{u2} N 0 (OfNat.mk.{u2} N 0 (Zero.zero.{u2} N hz))))) -> (WellFounded.{succ u2} N s) -> (forall [_inst_1 : IsTrichotomous.{u1} α r], (WellFounded.{succ u1} α (Function.swap.{succ u1, succ u1, 1} α α (fun (ᾰ : α) (ᾰ : α) => Prop) r)) -> (WellFounded.{max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N hz) (Finsupp.Lex.{u1, u2} α N hz r s)))
+but is expected to have type
+  forall {α : Type.{u2}} {N : Type.{u1}} [hz : Zero.{u1} N] {r : α -> α -> Prop} {s : N -> N -> Prop}, (forall {{n : N}}, Not (s n (OfNat.ofNat.{u1} N 0 (Zero.toOfNat0.{u1} N hz)))) -> (WellFounded.{succ u1} N s) -> (forall [_inst_1 : IsTrichotomous.{u2} α r], (WellFounded.{succ u2} α (Function.swap.{succ u2, succ u2, 1} α α (fun (ᾰ : α) (ᾰ : α) => Prop) r)) -> (WellFounded.{max (succ u1) (succ u2)} (Finsupp.{u2, u1} α N hz) (Finsupp.Lex.{u2, u1} α N hz r s)))
+Case conversion may be inaccurate. Consider using '#align finsupp.lex.well_founded' Finsupp.Lex.wellFounded'ₓ'. -/
+theorem Lex.wellFounded' [IsTrichotomous α r] (hr : WellFounded r.symm) :
     WellFounded (Finsupp.Lex r s) :=
   (lex_eq_invImage_dfinsupp_lex r s).symm ▸
     InvImage.wf _ (Dfinsupp.Lex.wellFounded' (fun a => hbot) (fun a => hs) hr)
-#align finsupp.lex.well_founded' Finsupp.Lex.well_founded'
+#align finsupp.lex.well_founded' Finsupp.Lex.wellFounded'
 
 omit hbot hs
 
+/- warning: finsupp.lex.well_founded_lt -> Finsupp.Lex.wellFoundedLT is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LT.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (LT.lt.{u1} α _inst_1)] [hα : WellFoundedGT.{u1} α _inst_1] [_inst_3 : CanonicallyOrderedAddMonoid.{u2} N] [hN : WellFoundedLT.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3))))], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3))))))) (Finsupp.Lex.hasLt.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3))))) _inst_1 (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3)))))
+but is expected to have type
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LT.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (fun (x._@.Mathlib.Data.Finsupp.WellFounded._hyg.381 : α) (x._@.Mathlib.Data.Finsupp.WellFounded._hyg.383 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Data.Finsupp.WellFounded._hyg.381 x._@.Mathlib.Data.Finsupp.WellFounded._hyg.383)] [hα : WellFoundedGT.{u1} α _inst_1] [_inst_3 : CanonicallyOrderedAddMonoid.{u2} N] [hN : WellFoundedLT.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3))))], WellFoundedLT.{max u2 u1} (Lex.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3)))))) (Finsupp.instLTLexFinsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3)))) _inst_1 (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_3)))))
+Case conversion may be inaccurate. Consider using '#align finsupp.lex.well_founded_lt Finsupp.Lex.wellFoundedLTₓ'. -/
 instance Lex.wellFoundedLT [LT α] [IsTrichotomous α (· < ·)] [hα : WellFoundedGT α]
     [CanonicallyOrderedAddMonoid N] [hN : WellFoundedLT N] : WellFoundedLT (Lex (α →₀ N)) :=
-  ⟨Lex.well_founded' (fun n => (zero_le n).not_lt) hN.wf hα.wf⟩
+  ⟨Lex.wellFounded' (fun n => (zero_le n).not_lt) hN.wf hα.wf⟩
 #align finsupp.lex.well_founded_lt Finsupp.Lex.wellFoundedLT
 
 variable (r)
 
+/- warning: finsupp.lex.well_founded_of_finite -> Finsupp.Lex.wellFounded_of_finite is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {N : Type.{u2}} (r : α -> α -> Prop) {s : N -> N -> Prop} [_inst_1 : IsStrictTotalOrder.{u1} α r] [_inst_2 : Finite.{succ u1} α] [_inst_3 : Zero.{u2} N], (WellFounded.{succ u2} N s) -> (WellFounded.{max (succ u1) (succ u2)} (Finsupp.{u1, u2} α N _inst_3) (Finsupp.Lex.{u1, u2} α N _inst_3 r s))
+but is expected to have type
+  forall {α : Type.{u2}} {N : Type.{u1}} (r : α -> α -> Prop) {s : N -> N -> Prop} [_inst_1 : IsStrictTotalOrder.{u2} α r] [_inst_2 : Finite.{succ u2} α] [_inst_3 : Zero.{u1} N], (WellFounded.{succ u1} N s) -> (WellFounded.{max (succ u1) (succ u2)} (Finsupp.{u2, u1} α N _inst_3) (Finsupp.Lex.{u2, u1} α N _inst_3 r s))
+Case conversion may be inaccurate. Consider using '#align finsupp.lex.well_founded_of_finite Finsupp.Lex.wellFounded_of_finiteₓ'. -/
 theorem Lex.wellFounded_of_finite [IsStrictTotalOrder α r] [Finite α] [Zero N]
     (hs : WellFounded s) : WellFounded (Finsupp.Lex r s) :=
   InvImage.wf (@equivFunOnFinite α N _ _) (Pi.Lex.wellFounded r fun a => hs)
 #align finsupp.lex.well_founded_of_finite Finsupp.Lex.wellFounded_of_finite
 
+/- warning: finsupp.lex.well_founded_lt_of_finite -> Finsupp.Lex.wellFoundedLT_of_finite is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Finite.{succ u1} α] [_inst_3 : Zero.{u2} N] [_inst_4 : LT.{u2} N] [hwf : WellFoundedLT.{u2} N _inst_4], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u1, u2} α N _inst_3)) (Finsupp.Lex.hasLt.{u1, u2} α N _inst_3 (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) _inst_4)
+but is expected to have type
+  forall {α : Type.{u2}} {N : Type.{u1}} [_inst_1 : LinearOrder.{u2} α] [_inst_2 : Finite.{succ u2} α] [_inst_3 : Zero.{u1} N] [_inst_4 : LT.{u1} N] [hwf : WellFoundedLT.{u1} N _inst_4], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Finsupp.{u2, u1} α N _inst_3)) (Finsupp.instLTLexFinsupp.{u2, u1} α N _inst_3 (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))) _inst_4)
+Case conversion may be inaccurate. Consider using '#align finsupp.lex.well_founded_lt_of_finite Finsupp.Lex.wellFoundedLT_of_finiteₓ'. -/
 theorem Lex.wellFoundedLT_of_finite [LinearOrder α] [Finite α] [Zero N] [LT N]
     [hwf : WellFoundedLT N] : WellFoundedLT (Lex (α →₀ N)) :=
   ⟨Finsupp.Lex.wellFounded_of_finite (· < ·) hwf.1⟩
 #align finsupp.lex.well_founded_lt_of_finite Finsupp.Lex.wellFoundedLT_of_finite
 
+#print Finsupp.wellFoundedLT /-
 protected theorem wellFoundedLT [Zero N] [Preorder N] [WellFoundedLT N] (hbot : ∀ n : N, ¬n < 0) :
     WellFoundedLT (α →₀ N) :=
   ⟨InvImage.wf toDfinsupp (Dfinsupp.wellFoundedLT fun i a => hbot a).wf⟩
 #align finsupp.well_founded_lt Finsupp.wellFoundedLT
+-/
 
+/- warning: finsupp.well_founded_lt' -> Finsupp.well_founded_lt' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : CanonicallyOrderedAddMonoid.{u2} N] [_inst_2 : WellFoundedLT.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))], WellFoundedLT.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))))) (Preorder.toLT.{max u1 u2} (Finsupp.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))))) (Finsupp.preorder.{u1, u2} α N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))) (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))))
+but is expected to have type
+  forall {α : Type.{u1}} {N : Type.{u2}} [_inst_1 : CanonicallyOrderedAddMonoid.{u2} N] [_inst_2 : WellFoundedLT.{u2} N (Preorder.toLT.{u2} N (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))], WellFoundedLT.{max u2 u1} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))) (Preorder.toLT.{max u1 u2} (Finsupp.{u1, u2} α N (AddMonoid.toZero.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1))))) (Finsupp.preorder.{u1, u2} α N (AddMonoid.toZero.{u2} N (AddCommMonoid.toAddMonoid.{u2} N (OrderedAddCommMonoid.toAddCommMonoid.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))) (PartialOrder.toPreorder.{u2} N (OrderedAddCommMonoid.toPartialOrder.{u2} N (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} N _inst_1)))))
+Case conversion may be inaccurate. Consider using '#align finsupp.well_founded_lt' Finsupp.well_founded_lt'ₓ'. -/
 instance well_founded_lt' [CanonicallyOrderedAddMonoid N] [WellFoundedLT N] :
     WellFoundedLT (α →₀ N) :=
   Finsupp.wellFoundedLT fun a => (zero_le a).not_lt
 #align finsupp.well_founded_lt' Finsupp.well_founded_lt'
 
+#print Finsupp.wellFoundedLT_of_finite /-
 instance wellFoundedLT_of_finite [Finite α] [Zero N] [Preorder N] [WellFoundedLT N] :
     WellFoundedLT (α →₀ N) :=
   ⟨InvImage.wf equivFunOnFinite Function.wellFoundedLT.wf⟩
 #align finsupp.well_founded_lt_of_finite Finsupp.wellFoundedLT_of_finite
+-/
 
 end Finsupp

5fd3186f

bump to nightly-2023-03-18-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/02ba8949f486ebecf93fe7460f1ed0564b5e442c

eb7660d5

Diff

@@ -54,7 +54,7 @@ theorem Lex.wellFounded (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded
 theorem Lex.well_founded' [IsTrichotomous α r] (hr : WellFounded r.symm) :
     WellFounded (Finsupp.Lex r s) :=
   (lex_eq_invImage_dfinsupp_lex r s).symm ▸
-    InvImage.wf _ (Dfinsupp.Lex.well_founded' (fun a => hbot) (fun a => hs) hr)
+    InvImage.wf _ (Dfinsupp.Lex.wellFounded' (fun a => hbot) (fun a => hs) hr)
 #align finsupp.lex.well_founded' Finsupp.Lex.well_founded'
 
 omit hbot hs

5fd3186f

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

5fd3186f

style: remove redundant instance arguments (#11581)

I removed some redundant instance arguments throughout Mathlib. To do this, I used VS Code's regex search. See https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/repeating.20instances.20from.20variable.20command I closed the previous PR for this and reopened it.

acda20c6

Diff

@@ -59,17 +59,17 @@ instance Lex.wellFoundedLT {α N} [LT α] [IsTrichotomous α (· < ·)] [hα : W
 
 variable (r)
 
-theorem Lex.wellFounded_of_finite [IsStrictTotalOrder α r] [Finite α] [Zero N]
+theorem Lex.wellFounded_of_finite [IsStrictTotalOrder α r] [Finite α]
     (hs : WellFounded s) : WellFounded (Finsupp.Lex r s) :=
   InvImage.wf (@equivFunOnFinite α N _ _) (Pi.Lex.wellFounded r fun _ => hs)
 #align finsupp.lex.well_founded_of_finite Finsupp.Lex.wellFounded_of_finite
 
-theorem Lex.wellFoundedLT_of_finite [LinearOrder α] [Finite α] [Zero N] [LT N]
+theorem Lex.wellFoundedLT_of_finite [LinearOrder α] [Finite α] [LT N]
     [hwf : WellFoundedLT N] : WellFoundedLT (Lex (α →₀ N)) :=
   ⟨Finsupp.Lex.wellFounded_of_finite (· < ·) hwf.1⟩
 #align finsupp.lex.well_founded_lt_of_finite Finsupp.Lex.wellFoundedLT_of_finite
 
-protected theorem wellFoundedLT [Zero N] [Preorder N] [WellFoundedLT N] (hbot : ∀ n : N, ¬n < 0) :
+protected theorem wellFoundedLT [Preorder N] [WellFoundedLT N] (hbot : ∀ n : N, ¬n < 0) :
     WellFoundedLT (α →₀ N) :=
   ⟨InvImage.wf toDFinsupp (DFinsupp.wellFoundedLT fun _ a => hbot a).wf⟩
 #align finsupp.well_founded_lt Finsupp.wellFoundedLT
@@ -79,7 +79,7 @@ instance wellFoundedLT' {N} [CanonicallyOrderedAddCommMonoid N] [WellFoundedLT N
   Finsupp.wellFoundedLT fun a => (zero_le a).not_lt
 #align finsupp.well_founded_lt' Finsupp.wellFoundedLT'
 
-instance wellFoundedLT_of_finite [Finite α] [Zero N] [Preorder N] [WellFoundedLT N] :
+instance wellFoundedLT_of_finite [Finite α] [Preorder N] [WellFoundedLT N] :
     WellFoundedLT (α →₀ N) :=
   ⟨InvImage.wf equivFunOnFinite Function.wellFoundedLT.wf⟩
 #align finsupp.well_founded_lt_of_finite Finsupp.wellFoundedLT_of_finite

5fd3186f

chore: rename CanonicallyOrderedAddMonoid to ..AddCommMonoid (#7503)

Renames:

CanonicallyOrderedMonoid -> CanonicallyOrderedCommMonoid

CanonicallyOrderedAddMonoid -> CanonicallyOrderedAddCommMonoid

CanonicallyLinearOrderedMonoid -> CanonicallyLinearOrderedCommMonoid

CanonicallyLinearOrderedAddMonoid -> CanonicallyLinearOrderedAddCommMonoid

f3bc24c3

Diff

@@ -53,7 +53,7 @@ theorem Lex.wellFounded' [IsTrichotomous α r] (hr : WellFounded (Function.swap
 #align finsupp.lex.well_founded' Finsupp.Lex.wellFounded'
 
 instance Lex.wellFoundedLT {α N} [LT α] [IsTrichotomous α (· < ·)] [hα : WellFoundedGT α]
-    [CanonicallyOrderedAddMonoid N] [hN : WellFoundedLT N] : WellFoundedLT (Lex (α →₀ N)) :=
+    [CanonicallyOrderedAddCommMonoid N] [hN : WellFoundedLT N] : WellFoundedLT (Lex (α →₀ N)) :=
   ⟨Lex.wellFounded' (fun n => (zero_le n).not_lt) hN.wf hα.wf⟩
 #align finsupp.lex.well_founded_lt Finsupp.Lex.wellFoundedLT
 
@@ -74,7 +74,7 @@ protected theorem wellFoundedLT [Zero N] [Preorder N] [WellFoundedLT N] (hbot :
   ⟨InvImage.wf toDFinsupp (DFinsupp.wellFoundedLT fun _ a => hbot a).wf⟩
 #align finsupp.well_founded_lt Finsupp.wellFoundedLT
 
-instance wellFoundedLT' {N} [CanonicallyOrderedAddMonoid N] [WellFoundedLT N] :
+instance wellFoundedLT' {N} [CanonicallyOrderedAddCommMonoid N] [WellFoundedLT N] :
     WellFoundedLT (α →₀ N) :=
   Finsupp.wellFoundedLT fun a => (zero_le a).not_lt
 #align finsupp.well_founded_lt' Finsupp.wellFoundedLT'

5fd3186f

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

@@ -25,7 +25,7 @@ All results are transferred from `DFinsupp` via `Finsupp.toDFinsupp`.
 -/
 
 
-variable {α N : Type _}
+variable {α N : Type*}
 
 namespace Finsupp

5fd3186f

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 Junyan Xu. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Junyan Xu
-
-! This file was ported from Lean 3 source module data.finsupp.well_founded
-! leanprover-community/mathlib commit 5fd3186f1ec30a75d5f65732e3ce5e623382556f
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.DFinsupp.WellFounded
 import Mathlib.Data.Finsupp.Lex
 
+#align_import data.finsupp.well_founded from "leanprover-community/mathlib"@"5fd3186f1ec30a75d5f65732e3ce5e623382556f"
+
 /-!
 # Well-foundedness of the lexicographic and product orders on `Finsupp`

5fd3186f

chore: rename Dfinsupp to DFinsupp (#5822)

See #4354

268b7d43

Diff

@@ -8,7 +8,7 @@ Authors: Junyan Xu
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
-import Mathlib.Data.Dfinsupp.WellFounded
+import Mathlib.Data.DFinsupp.WellFounded
 import Mathlib.Data.Finsupp.Lex
 
 /-!
@@ -24,7 +24,7 @@ and `(· < ·)` is well-founded on `N`, then the lexicographic `(· < ·)` is we
 `Finsupp.wellFoundedLT` and `wellFoundedLT_of_finite` state the same results for the product
 order `(· < ·)`, but without the ordering conditions on `α`.
 
-All results are transferred from `Dfinsupp` via `Finsupp.toDfinsupp`.
+All results are transferred from `DFinsupp` via `Finsupp.toDFinsupp`.
 -/
 
 
@@ -35,14 +35,14 @@ namespace Finsupp
 variable [Zero N] {r : α → α → Prop} {s : N → N → Prop} (hbot : ∀ ⦃n⦄, ¬s n 0)
   (hs : WellFounded s)
 
-/-- Transferred from `Dfinsupp.Lex.acc`. See the top of that file for an explanation for the
+/-- Transferred from `DFinsupp.Lex.acc`. See the top of that file for an explanation for the
   appearance of the relation `rᶜ ⊓ (≠)`. -/
 theorem Lex.acc (x : α →₀ N) (h : ∀ a ∈ x.support, Acc (rᶜ ⊓ (· ≠ ·)) a) :
     Acc (Finsupp.Lex r s) x := by
   rw [lex_eq_invImage_dfinsupp_lex]
   classical
-    refine' InvImage.accessible toDfinsupp (Dfinsupp.Lex.acc (fun _ => hbot) (fun _ => hs) _ _)
-    simpa only [toDfinsupp_support] using h
+    refine' InvImage.accessible toDFinsupp (DFinsupp.Lex.acc (fun _ => hbot) (fun _ => hs) _ _)
+    simpa only [toDFinsupp_support] using h
 #align finsupp.lex.acc Finsupp.Lex.acc
 
 theorem Lex.wellFounded (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded (Finsupp.Lex r s) :=
@@ -52,7 +52,7 @@ theorem Lex.wellFounded (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded
 theorem Lex.wellFounded' [IsTrichotomous α r] (hr : WellFounded (Function.swap r)) :
     WellFounded (Finsupp.Lex r s) :=
   (lex_eq_invImage_dfinsupp_lex r s).symm ▸
-    InvImage.wf _ (Dfinsupp.Lex.wellFounded' (fun _ => hbot) (fun _ => hs) hr)
+    InvImage.wf _ (DFinsupp.Lex.wellFounded' (fun _ => hbot) (fun _ => hs) hr)
 #align finsupp.lex.well_founded' Finsupp.Lex.wellFounded'
 
 instance Lex.wellFoundedLT {α N} [LT α] [IsTrichotomous α (· < ·)] [hα : WellFoundedGT α]
@@ -74,7 +74,7 @@ theorem Lex.wellFoundedLT_of_finite [LinearOrder α] [Finite α] [Zero N] [LT N]
 
 protected theorem wellFoundedLT [Zero N] [Preorder N] [WellFoundedLT N] (hbot : ∀ n : N, ¬n < 0) :
     WellFoundedLT (α →₀ N) :=
-  ⟨InvImage.wf toDfinsupp (Dfinsupp.wellFoundedLT fun _ a => hbot a).wf⟩
+  ⟨InvImage.wf toDFinsupp (DFinsupp.wellFoundedLT fun _ a => hbot a).wf⟩
 #align finsupp.well_founded_lt Finsupp.wellFoundedLT
 
 instance wellFoundedLT' {N} [CanonicallyOrderedAddMonoid N] [WellFoundedLT N] :

5fd3186f

chore: tidy various files (#3110)

0bcbc985

Diff

@@ -21,7 +21,7 @@ lexicographic `(· < ·)` is well-founded on `α →₀ N`.
 `Finsupp.Lex.wellFoundedLT_of_finite` says that if `α` is finite and equipped with a linear order
 and `(· < ·)` is well-founded on `N`, then the lexicographic `(· < ·)` is well-founded on `α →₀ N`.
 
-`Finsupp.wellFoundedLT` and `well_founded_lt_of_finite` state the same results for the product
+`Finsupp.wellFoundedLT` and `wellFoundedLT_of_finite` state the same results for the product
 order `(· < ·)`, but without the ordering conditions on `α`.
 
 All results are transferred from `Dfinsupp` via `Finsupp.toDfinsupp`.
@@ -77,10 +77,10 @@ protected theorem wellFoundedLT [Zero N] [Preorder N] [WellFoundedLT N] (hbot :
   ⟨InvImage.wf toDfinsupp (Dfinsupp.wellFoundedLT fun _ a => hbot a).wf⟩
 #align finsupp.well_founded_lt Finsupp.wellFoundedLT
 
-instance well_founded_lt' {N} [CanonicallyOrderedAddMonoid N] [WellFoundedLT N] :
+instance wellFoundedLT' {N} [CanonicallyOrderedAddMonoid N] [WellFoundedLT N] :
     WellFoundedLT (α →₀ N) :=
   Finsupp.wellFoundedLT fun a => (zero_le a).not_lt
-#align finsupp.well_founded_lt' Finsupp.well_founded_lt'
+#align finsupp.well_founded_lt' Finsupp.wellFoundedLT'
 
 instance wellFoundedLT_of_finite [Finite α] [Zero N] [Preorder N] [WellFoundedLT N] :
     WellFoundedLT (α →₀ N) :=

5fd3186f

feat: port Data.Finsupp.WellFounded (#2985)

4d97a152

`data.finsupp.well_founded` ⟷ `Mathlib.Data.Finsupp.WellFounded`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 363

data.finsupp.well_founded ⟷ Mathlib.Data.Finsupp.WellFounded

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 363

`data.finsupp.well_founded` ⟷ `Mathlib.Data.Finsupp.WellFounded`