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

e9b8651e

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

1dac236e

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.Lex
+import Data.DFinsupp.Lex
 import Order.GameAdd
 import Order.Antisymmetrization
 import SetTheory.Ordinal.Basic

1dac236e

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -72,8 +72,8 @@ theorem lex_fibration [∀ (i) (s : Set ι), Decidable (i ∈ s)] :
       fun x => piecewise x.2.1 x.2.2 x.1 :=
   by
   rintro ⟨p, x₁, x₂⟩ x ⟨i, hr, hs⟩
-  simp_rw [piecewise_apply] at hs hr 
-  split_ifs at hs 
+  simp_rw [piecewise_apply] at hs hr
+  split_ifs at hs
   classical
   on_goal 1 =>
     refine' ⟨⟨{j | r j i → j ∈ p}, piecewise x₁ x {j | r j i}, x₂⟩, game_add.fst ⟨i, _⟩, _⟩
@@ -91,7 +91,7 @@ theorem lex_fibration [∀ (i) (s : Set ι), Decidable (i ∈ s)] :
   all_goals ext j; simp_rw [piecewise_apply]; split_ifs with h₁ h₂
   · rw [hr j h₂, if_pos (h₁ h₂)]
   · rfl
-  · rw [Set.mem_setOf, not_imp] at h₁ ; rw [hr j h₁.1, if_neg h₁.2]
+  · rw [Set.mem_setOf, not_imp] at h₁; rw [hr j h₁.1, if_neg h₁.2]
   · rw [hr j h₁.1, if_pos h₁.2]
   · rw [hr j h₂, if_neg fun h' => h₁ ⟨h₂, h'⟩]
   · rfl
@@ -146,8 +146,8 @@ theorem Lex.acc_single [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)
   refine' Acc.intro _ fun x => _
   rintro ⟨k, hr, hs⟩
   classical
-  rw [single_apply] at hs 
-  split_ifs at hs  with hik
+  rw [single_apply] at hs
+  split_ifs at hs with hik
   swap
   · exact (hbot hs).elim
   subst hik

1dac236e

bump to nightly-2024-02-01-06

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

5433bded

Diff

@@ -75,6 +75,26 @@ theorem lex_fibration [∀ (i) (s : Set ι), Decidable (i ∈ s)] :
   simp_rw [piecewise_apply] at hs hr 
   split_ifs at hs 
   classical
+  on_goal 1 =>
+    refine' ⟨⟨{j | r j i → j ∈ p}, piecewise x₁ x {j | r j i}, x₂⟩, game_add.fst ⟨i, _⟩, _⟩
+  on_goal 3 =>
+    refine' ⟨⟨{j | r j i ∧ j ∈ p}, x₁, piecewise x₂ x {j | r j i}⟩, game_add.snd ⟨i, _⟩, _⟩
+  pick_goal 3
+  iterate 2 
+    simp_rw [piecewise_apply]
+    refine' ⟨fun j h => if_pos h, _⟩
+    convert hs
+    refine' ite_eq_right_iff.2 fun h' => (hr i h').symm ▸ _
+    first
+    | rw [if_neg h]
+    | rw [if_pos h]
+  all_goals ext j; simp_rw [piecewise_apply]; split_ifs with h₁ h₂
+  · rw [hr j h₂, if_pos (h₁ h₂)]
+  · rfl
+  · rw [Set.mem_setOf, not_imp] at h₁ ; rw [hr j h₁.1, if_neg h₁.2]
+  · rw [hr j h₁.1, if_pos h₁.2]
+  · rw [hr j h₂, if_neg fun h' => h₁ ⟨h₂, h'⟩]
+  · rfl
 #align dfinsupp.lex_fibration DFinsupp.lex_fibration
 -/
 
@@ -83,7 +103,12 @@ variable {r s}
 #print DFinsupp.Lex.acc_of_single_erase /-
 theorem Lex.acc_of_single_erase [DecidableEq ι] {x : Π₀ i, α i} (i : ι)
     (hs : Acc (DFinsupp.Lex r s) <| single i (x i)) (hu : Acc (DFinsupp.Lex r s) <| x.eraseₓ i) :
-    Acc (DFinsupp.Lex r s) x := by classical
+    Acc (DFinsupp.Lex r s) x := by
+  classical
+  convert ←
+    @Acc.of_fibration _ _ _ _ _ (lex_fibration r s) ⟨{i}, _⟩
+      (InvImage.accessible snd <| hs.prod_game_add hu)
+  convert piecewise_single_erase x i
 #align dfinsupp.lex.acc_of_single_erase DFinsupp.Lex.acc_of_single_erase
 -/
 
@@ -101,6 +126,12 @@ theorem Lex.acc_of_single [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠
   by
   generalize ht : x.support = t; revert x
   classical
+  induction' t using Finset.induction with b t hb ih
+  · intro x ht; rw [support_eq_empty.1 ht]; exact fun _ => lex.acc_zero hbot
+  refine' fun x ht h => lex.acc_of_single_erase b (h b <| t.mem_insert_self b) _
+  refine' ih _ (by rw [support_erase, ht, Finset.erase_insert hb]) fun a ha => _
+  rw [erase_ne (ha.ne_of_not_mem hb)]
+  exact h a (Finset.mem_insert_of_mem ha)
 #align dfinsupp.lex.acc_of_single DFinsupp.Lex.acc_of_single
 -/
 
@@ -115,6 +146,17 @@ theorem Lex.acc_single [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)
   refine' Acc.intro _ fun x => _
   rintro ⟨k, hr, hs⟩
   classical
+  rw [single_apply] at hs 
+  split_ifs at hs  with hik
+  swap
+  · exact (hbot hs).elim
+  subst hik
+  refine' lex.acc_of_single hbot x fun j hj => _
+  obtain rfl | hij := eq_or_ne i j
+  · exact ha _ hs
+  by_cases r j i
+  · rw [hr j h, single_eq_of_ne hij, single_zero]; exact lex.acc_zero hbot
+  · exact ih _ ⟨h, hij.symm⟩ _
 #align dfinsupp.lex.acc_single DFinsupp.Lex.acc_single
 -/
 
@@ -127,7 +169,7 @@ theorem Lex.acc [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠ 0)] (x :
 
 #print DFinsupp.Lex.wellFounded /-
 theorem Lex.wellFounded (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded (DFinsupp.Lex r s) :=
-  ⟨fun x => by classical⟩
+  ⟨fun x => by classical exact lex.acc hbot hs x fun i _ => hr.apply i⟩
 #align dfinsupp.lex.well_founded DFinsupp.Lex.wellFounded
 -/

1dac236e

bump to nightly-2024-01-31-06

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

61100fe9

Diff

@@ -75,26 +75,6 @@ theorem lex_fibration [∀ (i) (s : Set ι), Decidable (i ∈ s)] :
   simp_rw [piecewise_apply] at hs hr 
   split_ifs at hs 
   classical
-  on_goal 1 =>
-    refine' ⟨⟨{j | r j i → j ∈ p}, piecewise x₁ x {j | r j i}, x₂⟩, game_add.fst ⟨i, _⟩, _⟩
-  on_goal 3 =>
-    refine' ⟨⟨{j | r j i ∧ j ∈ p}, x₁, piecewise x₂ x {j | r j i}⟩, game_add.snd ⟨i, _⟩, _⟩
-  pick_goal 3
-  iterate 2 
-    simp_rw [piecewise_apply]
-    refine' ⟨fun j h => if_pos h, _⟩
-    convert hs
-    refine' ite_eq_right_iff.2 fun h' => (hr i h').symm ▸ _
-    first
-    | rw [if_neg h]
-    | rw [if_pos h]
-  all_goals ext j; simp_rw [piecewise_apply]; split_ifs with h₁ h₂
-  · rw [hr j h₂, if_pos (h₁ h₂)]
-  · rfl
-  · rw [Set.mem_setOf, not_imp] at h₁ ; rw [hr j h₁.1, if_neg h₁.2]
-  · rw [hr j h₁.1, if_pos h₁.2]
-  · rw [hr j h₂, if_neg fun h' => h₁ ⟨h₂, h'⟩]
-  · rfl
 #align dfinsupp.lex_fibration DFinsupp.lex_fibration
 -/
 
@@ -103,12 +83,7 @@ variable {r s}
 #print DFinsupp.Lex.acc_of_single_erase /-
 theorem Lex.acc_of_single_erase [DecidableEq ι] {x : Π₀ i, α i} (i : ι)
     (hs : Acc (DFinsupp.Lex r s) <| single i (x i)) (hu : Acc (DFinsupp.Lex r s) <| x.eraseₓ i) :
-    Acc (DFinsupp.Lex r s) x := by
-  classical
-  convert ←
-    @Acc.of_fibration _ _ _ _ _ (lex_fibration r s) ⟨{i}, _⟩
-      (InvImage.accessible snd <| hs.prod_game_add hu)
-  convert piecewise_single_erase x i
+    Acc (DFinsupp.Lex r s) x := by classical
 #align dfinsupp.lex.acc_of_single_erase DFinsupp.Lex.acc_of_single_erase
 -/
 
@@ -126,12 +101,6 @@ theorem Lex.acc_of_single [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠
   by
   generalize ht : x.support = t; revert x
   classical
-  induction' t using Finset.induction with b t hb ih
-  · intro x ht; rw [support_eq_empty.1 ht]; exact fun _ => lex.acc_zero hbot
-  refine' fun x ht h => lex.acc_of_single_erase b (h b <| t.mem_insert_self b) _
-  refine' ih _ (by rw [support_erase, ht, Finset.erase_insert hb]) fun a ha => _
-  rw [erase_ne (ha.ne_of_not_mem hb)]
-  exact h a (Finset.mem_insert_of_mem ha)
 #align dfinsupp.lex.acc_of_single DFinsupp.Lex.acc_of_single
 -/
 
@@ -146,17 +115,6 @@ theorem Lex.acc_single [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)
   refine' Acc.intro _ fun x => _
   rintro ⟨k, hr, hs⟩
   classical
-  rw [single_apply] at hs 
-  split_ifs at hs  with hik
-  swap
-  · exact (hbot hs).elim
-  subst hik
-  refine' lex.acc_of_single hbot x fun j hj => _
-  obtain rfl | hij := eq_or_ne i j
-  · exact ha _ hs
-  by_cases r j i
-  · rw [hr j h, single_eq_of_ne hij, single_zero]; exact lex.acc_zero hbot
-  · exact ih _ ⟨h, hij.symm⟩ _
 #align dfinsupp.lex.acc_single DFinsupp.Lex.acc_single
 -/
 
@@ -169,7 +127,7 @@ theorem Lex.acc [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠ 0)] (x :
 
 #print DFinsupp.Lex.wellFounded /-
 theorem Lex.wellFounded (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded (DFinsupp.Lex r s) :=
-  ⟨fun x => by classical exact lex.acc hbot hs x fun i _ => hr.apply i⟩
+  ⟨fun x => by classical⟩
 #align dfinsupp.lex.well_founded DFinsupp.Lex.wellFounded
 -/

1dac236e

bump to nightly-2023-10-07-06

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

d191b687

Diff

@@ -184,7 +184,7 @@ theorem Lex.wellFounded' [IsTrichotomous ι r] (hr : WellFounded r.symm) :
 
 #print DFinsupp.Lex.wellFoundedLT /-
 instance Lex.wellFoundedLT [LT ι] [IsTrichotomous ι (· < ·)] [hι : WellFoundedGT ι]
-    [∀ i, CanonicallyOrderedAddMonoid (α i)] [hα : ∀ i, WellFoundedLT (α i)] :
+    [∀ i, CanonicallyOrderedAddCommMonoid (α i)] [hα : ∀ i, WellFoundedLT (α i)] :
     WellFoundedLT (Lex (Π₀ i, α i)) :=
   ⟨Lex.wellFounded' (fun i a => (zero_le a).not_lt) (fun i => (hα i).wf) hι.wf⟩
 #align dfinsupp.lex.well_founded_lt DFinsupp.Lex.wellFoundedLT
@@ -255,7 +255,7 @@ protected theorem DFinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (
 -/
 
 #print DFinsupp.wellFoundedLT' /-
-instance DFinsupp.wellFoundedLT' [∀ i, CanonicallyOrderedAddMonoid (α i)]
+instance DFinsupp.wellFoundedLT' [∀ i, CanonicallyOrderedAddCommMonoid (α i)]
     [∀ i, WellFoundedLT (α i)] : WellFoundedLT (Π₀ i, α i) :=
   DFinsupp.wellFoundedLT fun i a => (zero_le a).not_lt
 #align dfinsupp.well_founded_lt' DFinsupp.wellFoundedLT'

1dac236e

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,10 +3,10 @@ Copyright (c) 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.Lex
-import Mathbin.Order.GameAdd
-import Mathbin.Order.Antisymmetrization
-import Mathbin.SetTheory.Ordinal.Basic
+import Data.Dfinsupp.Lex
+import Order.GameAdd
+import Order.Antisymmetrization
+import SetTheory.Ordinal.Basic
 
 #align_import data.dfinsupp.well_founded from "leanprover-community/mathlib"@"1dac236edca9b4b6f5f00b1ad831e35f89472837"

1dac236e

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 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.dfinsupp.well_founded
-! leanprover-community/mathlib commit 1dac236edca9b4b6f5f00b1ad831e35f89472837
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Dfinsupp.Lex
 import Mathbin.Order.GameAdd
 import Mathbin.Order.Antisymmetrization
 import Mathbin.SetTheory.Ordinal.Basic
 
+#align_import data.dfinsupp.well_founded from "leanprover-community/mathlib"@"1dac236edca9b4b6f5f00b1ad831e35f89472837"
+
 /-!
 # Well-foundedness of the lexicographic and product orders on `dfinsupp` and `pi`

1dac236e

bump to nightly-2023-07-19-09

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

960516e2

Diff

@@ -257,11 +257,11 @@ protected theorem DFinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (
 #align dfinsupp.well_founded_lt DFinsupp.wellFoundedLT
 -/
 
-#print DFinsupp.well_founded_lt' /-
-instance DFinsupp.well_founded_lt' [∀ i, CanonicallyOrderedAddMonoid (α i)]
+#print DFinsupp.wellFoundedLT' /-
+instance DFinsupp.wellFoundedLT' [∀ i, CanonicallyOrderedAddMonoid (α i)]
     [∀ i, WellFoundedLT (α i)] : WellFoundedLT (Π₀ i, α i) :=
   DFinsupp.wellFoundedLT fun i a => (zero_le a).not_lt
-#align dfinsupp.well_founded_lt' DFinsupp.well_founded_lt'
+#align dfinsupp.well_founded_lt' DFinsupp.wellFoundedLT'
 -/
 
 #print Pi.wellFoundedLT /-

1dac236e

bump to nightly-2023-07-12-07

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

9849f9d1

Diff

@@ -55,13 +55,13 @@ to be well-founded.
 
 variable {ι : Type _} {α : ι → Type _}
 
-namespace Dfinsupp
+namespace DFinsupp
 
 variable [hz : ∀ i, Zero (α i)] (r : ι → ι → Prop) (s : ∀ i, α i → α i → Prop)
 
 open Relation Prod
 
-#print Dfinsupp.lex_fibration /-
+#print DFinsupp.lex_fibration /-
 /-- This key lemma says that if a finitely supported dependent function `x₀` is obtained by merging
   two such functions `x₁` and `x₂`, and if we evolve `x₀` down the `dfinsupp.lex` relation one
   step and get `x`, we can always evolve one of `x₁` and `x₂` down the `dfinsupp.lex` relation
@@ -71,7 +71,7 @@ open Relation Prod
   `dfinsupp.single i (x i)` is accessible for each `i` in the (finite) support of `x`
   (`dfinsupp.lex.acc_of_single`). -/
 theorem lex_fibration [∀ (i) (s : Set ι), Decidable (i ∈ s)] :
-    Fibration (InvImage (GameAdd (Dfinsupp.Lex r s) (Dfinsupp.Lex r s)) snd) (Dfinsupp.Lex r s)
+    Fibration (InvImage (GameAdd (DFinsupp.Lex r s) (DFinsupp.Lex r s)) snd) (DFinsupp.Lex r s)
       fun x => piecewise x.2.1 x.2.2 x.1 :=
   by
   rintro ⟨p, x₁, x₂⟩ x ⟨i, hr, hs⟩
@@ -98,34 +98,34 @@ theorem lex_fibration [∀ (i) (s : Set ι), Decidable (i ∈ s)] :
   · rw [hr j h₁.1, if_pos h₁.2]
   · rw [hr j h₂, if_neg fun h' => h₁ ⟨h₂, h'⟩]
   · rfl
-#align dfinsupp.lex_fibration Dfinsupp.lex_fibration
+#align dfinsupp.lex_fibration DFinsupp.lex_fibration
 -/
 
 variable {r s}
 
-#print Dfinsupp.Lex.acc_of_single_erase /-
+#print DFinsupp.Lex.acc_of_single_erase /-
 theorem Lex.acc_of_single_erase [DecidableEq ι] {x : Π₀ i, α i} (i : ι)
-    (hs : Acc (Dfinsupp.Lex r s) <| single i (x i)) (hu : Acc (Dfinsupp.Lex r s) <| x.eraseₓ i) :
-    Acc (Dfinsupp.Lex r s) x := by
+    (hs : Acc (DFinsupp.Lex r s) <| single i (x i)) (hu : Acc (DFinsupp.Lex r s) <| x.eraseₓ i) :
+    Acc (DFinsupp.Lex r s) x := by
   classical
   convert ←
     @Acc.of_fibration _ _ _ _ _ (lex_fibration r s) ⟨{i}, _⟩
       (InvImage.accessible snd <| hs.prod_game_add hu)
   convert piecewise_single_erase x i
-#align dfinsupp.lex.acc_of_single_erase Dfinsupp.Lex.acc_of_single_erase
+#align dfinsupp.lex.acc_of_single_erase DFinsupp.Lex.acc_of_single_erase
 -/
 
 variable (hbot : ∀ ⦃i a⦄, ¬s i a 0)
 
-#print Dfinsupp.Lex.acc_zero /-
-theorem Lex.acc_zero : Acc (Dfinsupp.Lex r s) 0 :=
+#print DFinsupp.Lex.acc_zero /-
+theorem Lex.acc_zero : Acc (DFinsupp.Lex r s) 0 :=
   Acc.intro 0 fun x ⟨_, _, h⟩ => (hbot h).elim
-#align dfinsupp.lex.acc_zero Dfinsupp.Lex.acc_zero
+#align dfinsupp.lex.acc_zero DFinsupp.Lex.acc_zero
 -/
 
-#print Dfinsupp.Lex.acc_of_single /-
+#print DFinsupp.Lex.acc_of_single /-
 theorem Lex.acc_of_single [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠ 0)] (x : Π₀ i, α i) :
-    (∀ i ∈ x.support, Acc (Dfinsupp.Lex r s) <| single i (x i)) → Acc (Dfinsupp.Lex r s) x :=
+    (∀ i ∈ x.support, Acc (DFinsupp.Lex r s) <| single i (x i)) → Acc (DFinsupp.Lex r s) x :=
   by
   generalize ht : x.support = t; revert x
   classical
@@ -135,14 +135,14 @@ theorem Lex.acc_of_single [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠
   refine' ih _ (by rw [support_erase, ht, Finset.erase_insert hb]) fun a ha => _
   rw [erase_ne (ha.ne_of_not_mem hb)]
   exact h a (Finset.mem_insert_of_mem ha)
-#align dfinsupp.lex.acc_of_single Dfinsupp.Lex.acc_of_single
+#align dfinsupp.lex.acc_of_single DFinsupp.Lex.acc_of_single
 -/
 
 variable (hs : ∀ i, WellFounded (s i))
 
-#print Dfinsupp.Lex.acc_single /-
+#print DFinsupp.Lex.acc_single /-
 theorem Lex.acc_single [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)) i) :
-    ∀ a, Acc (Dfinsupp.Lex r s) (single i a) :=
+    ∀ a, Acc (DFinsupp.Lex r s) (single i a) :=
   by
   induction' hi with i hi ih
   refine' fun a => (hs i).induction a fun a ha => _
@@ -160,42 +160,42 @@ theorem Lex.acc_single [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)
   by_cases r j i
   · rw [hr j h, single_eq_of_ne hij, single_zero]; exact lex.acc_zero hbot
   · exact ih _ ⟨h, hij.symm⟩ _
-#align dfinsupp.lex.acc_single Dfinsupp.Lex.acc_single
+#align dfinsupp.lex.acc_single DFinsupp.Lex.acc_single
 -/
 
-#print Dfinsupp.Lex.acc /-
+#print DFinsupp.Lex.acc /-
 theorem Lex.acc [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠ 0)] (x : Π₀ i, α i)
-    (h : ∀ i ∈ x.support, Acc (rᶜ ⊓ (· ≠ ·)) i) : Acc (Dfinsupp.Lex r s) x :=
+    (h : ∀ i ∈ x.support, Acc (rᶜ ⊓ (· ≠ ·)) i) : Acc (DFinsupp.Lex r s) x :=
   Lex.acc_of_single hbot x fun i hi => Lex.acc_single hbot hs (h i hi) _
-#align dfinsupp.lex.acc Dfinsupp.Lex.acc
+#align dfinsupp.lex.acc DFinsupp.Lex.acc
 -/
 
-#print Dfinsupp.Lex.wellFounded /-
-theorem Lex.wellFounded (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded (Dfinsupp.Lex r s) :=
+#print DFinsupp.Lex.wellFounded /-
+theorem Lex.wellFounded (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded (DFinsupp.Lex r s) :=
   ⟨fun x => by classical exact lex.acc hbot hs x fun i _ => hr.apply i⟩
-#align dfinsupp.lex.well_founded Dfinsupp.Lex.wellFounded
+#align dfinsupp.lex.well_founded DFinsupp.Lex.wellFounded
 -/
 
-#print Dfinsupp.Lex.wellFounded' /-
+#print DFinsupp.Lex.wellFounded' /-
 theorem Lex.wellFounded' [IsTrichotomous ι r] (hr : WellFounded r.symm) :
-    WellFounded (Dfinsupp.Lex r s) :=
+    WellFounded (DFinsupp.Lex r s) :=
   Lex.wellFounded hbot hs <|
     Subrelation.wf
       (fun i j h => ((@IsTrichotomous.trichotomous ι r _ i j).resolve_left h.1).resolve_left h.2) hr
-#align dfinsupp.lex.well_founded' Dfinsupp.Lex.wellFounded'
+#align dfinsupp.lex.well_founded' DFinsupp.Lex.wellFounded'
 -/
 
-#print Dfinsupp.Lex.wellFoundedLT /-
+#print DFinsupp.Lex.wellFoundedLT /-
 instance Lex.wellFoundedLT [LT ι] [IsTrichotomous ι (· < ·)] [hι : WellFoundedGT ι]
     [∀ i, CanonicallyOrderedAddMonoid (α i)] [hα : ∀ i, WellFoundedLT (α i)] :
     WellFoundedLT (Lex (Π₀ i, α i)) :=
   ⟨Lex.wellFounded' (fun i a => (zero_le a).not_lt) (fun i => (hα i).wf) hι.wf⟩
-#align dfinsupp.lex.well_founded_lt Dfinsupp.Lex.wellFoundedLT
+#align dfinsupp.lex.well_founded_lt DFinsupp.Lex.wellFoundedLT
 -/
 
-end Dfinsupp
+end DFinsupp
 
-open Dfinsupp
+open DFinsupp
 
 variable (r : ι → ι → Prop) {s : ∀ i, α i → α i → Prop}
 
@@ -226,23 +226,23 @@ instance Function.Lex.wellFoundedLT {α} [LinearOrder ι] [Finite ι] [LT α] [W
 #align function.lex.well_founded_lt Function.Lex.wellFoundedLT
 -/
 
-#print Dfinsupp.Lex.wellFounded_of_finite /-
-theorem Dfinsupp.Lex.wellFounded_of_finite [IsStrictTotalOrder ι r] [Finite ι] [∀ i, Zero (α i)]
-    (hs : ∀ i, WellFounded (s i)) : WellFounded (Dfinsupp.Lex r s) :=
+#print DFinsupp.Lex.wellFounded_of_finite /-
+theorem DFinsupp.Lex.wellFounded_of_finite [IsStrictTotalOrder ι r] [Finite ι] [∀ i, Zero (α i)]
+    (hs : ∀ i, WellFounded (s i)) : WellFounded (DFinsupp.Lex r s) :=
   have := Fintype.ofFinite ι
   InvImage.wf equiv_fun_on_fintype (Pi.Lex.wellFounded r hs)
-#align dfinsupp.lex.well_founded_of_finite Dfinsupp.Lex.wellFounded_of_finite
+#align dfinsupp.lex.well_founded_of_finite DFinsupp.Lex.wellFounded_of_finite
 -/
 
-#print Dfinsupp.Lex.wellFoundedLT_of_finite /-
-instance Dfinsupp.Lex.wellFoundedLT_of_finite [LinearOrder ι] [Finite ι] [∀ i, Zero (α i)]
+#print DFinsupp.Lex.wellFoundedLT_of_finite /-
+instance DFinsupp.Lex.wellFoundedLT_of_finite [LinearOrder ι] [Finite ι] [∀ i, Zero (α i)]
     [∀ i, LT (α i)] [hwf : ∀ i, WellFoundedLT (α i)] : WellFoundedLT (Lex (Π₀ i, α i)) :=
-  ⟨Dfinsupp.Lex.wellFounded_of_finite (· < ·) fun i => (hwf i).1⟩
-#align dfinsupp.lex.well_founded_lt_of_finite Dfinsupp.Lex.wellFoundedLT_of_finite
+  ⟨DFinsupp.Lex.wellFounded_of_finite (· < ·) fun i => (hwf i).1⟩
+#align dfinsupp.lex.well_founded_lt_of_finite DFinsupp.Lex.wellFoundedLT_of_finite
 -/
 
-#print Dfinsupp.wellFoundedLT /-
-protected theorem Dfinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (α i)]
+#print DFinsupp.wellFoundedLT /-
+protected theorem DFinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (α i)]
     [∀ i, WellFoundedLT (α i)] (hbot : ∀ ⦃i⦄ ⦃a : α i⦄, ¬a < 0) : WellFoundedLT (Π₀ i, α i) :=
   ⟨by
     letI : ∀ i, Zero (Antisymmetrization (α i) (· ≤ ·)) := fun i => ⟨toAntisymmetrization (· ≤ ·) 0⟩
@@ -254,14 +254,14 @@ protected theorem Dfinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (
       exact ⟨i, fun j hj => Quot.sound (he j hj), hl⟩
     · rintro i ⟨a⟩; apply hbot
     exacts [IsWellFounded.wf, IsTrichotomous.swap _, IsWellFounded.wf]⟩
-#align dfinsupp.well_founded_lt Dfinsupp.wellFoundedLT
+#align dfinsupp.well_founded_lt DFinsupp.wellFoundedLT
 -/
 
-#print Dfinsupp.well_founded_lt' /-
-instance Dfinsupp.well_founded_lt' [∀ i, CanonicallyOrderedAddMonoid (α i)]
+#print DFinsupp.well_founded_lt' /-
+instance DFinsupp.well_founded_lt' [∀ i, CanonicallyOrderedAddMonoid (α i)]
     [∀ i, WellFoundedLT (α i)] : WellFoundedLT (Π₀ i, α i) :=
-  Dfinsupp.wellFoundedLT fun i a => (zero_le a).not_lt
-#align dfinsupp.well_founded_lt' Dfinsupp.well_founded_lt'
+  DFinsupp.wellFoundedLT fun i a => (zero_le a).not_lt
+#align dfinsupp.well_founded_lt' DFinsupp.well_founded_lt'
 -/
 
 #print Pi.wellFoundedLT /-
@@ -272,7 +272,7 @@ instance Pi.wellFoundedLT [Finite ι] [∀ i, Preorder (α i)] [hw : ∀ i, Well
     · convert empty_wf; ext1 x; exact (h.1 x).elim
     letI : ∀ i, Zero (α i) := fun i => ⟨(hw i).wf.min ⊤ ⟨x i, trivial⟩⟩
     haveI := Fintype.ofFinite ι
-    refine' InvImage.wf equiv_fun_on_fintype.symm (Dfinsupp.wellFoundedLT fun i a => _).wf
+    refine' InvImage.wf equiv_fun_on_fintype.symm (DFinsupp.wellFoundedLT fun i a => _).wf
     exact (hw i).wf.not_lt_min ⊤ _ trivial⟩
 #align pi.well_founded_lt Pi.wellFoundedLT
 -/
@@ -284,11 +284,11 @@ instance Function.wellFoundedLT {α} [Finite ι] [Preorder α] [WellFoundedLT α
 #align function.well_founded_lt Function.wellFoundedLT
 -/
 
-#print Dfinsupp.wellFoundedLT_of_finite /-
-instance Dfinsupp.wellFoundedLT_of_finite [Finite ι] [∀ i, Zero (α i)] [∀ i, Preorder (α i)]
+#print DFinsupp.wellFoundedLT_of_finite /-
+instance DFinsupp.wellFoundedLT_of_finite [Finite ι] [∀ i, Zero (α i)] [∀ i, Preorder (α i)]
     [∀ i, WellFoundedLT (α i)] : WellFoundedLT (Π₀ i, α i) :=
   have := Fintype.ofFinite ι
   ⟨InvImage.wf equiv_fun_on_fintype pi.well_founded_lt.wf⟩
-#align dfinsupp.well_founded_lt_of_finite Dfinsupp.wellFoundedLT_of_finite
+#align dfinsupp.well_founded_lt_of_finite DFinsupp.wellFoundedLT_of_finite
 -/

1dac236e

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -59,10 +59,9 @@ namespace Dfinsupp
 
 variable [hz : ∀ i, Zero (α i)] (r : ι → ι → Prop) (s : ∀ i, α i → α i → Prop)
 
-include hz
-
 open Relation Prod
 
+#print Dfinsupp.lex_fibration /-
 /-- This key lemma says that if a finitely supported dependent function `x₀` is obtained by merging
   two such functions `x₁` and `x₂`, and if we evolve `x₀` down the `dfinsupp.lex` relation one
   step and get `x`, we can always evolve one of `x₁` and `x₂` down the `dfinsupp.lex` relation
@@ -100,9 +99,11 @@ theorem lex_fibration [∀ (i) (s : Set ι), Decidable (i ∈ s)] :
   · rw [hr j h₂, if_neg fun h' => h₁ ⟨h₂, h'⟩]
   · rfl
 #align dfinsupp.lex_fibration Dfinsupp.lex_fibration
+-/
 
 variable {r s}
 
+#print Dfinsupp.Lex.acc_of_single_erase /-
 theorem Lex.acc_of_single_erase [DecidableEq ι] {x : Π₀ i, α i} (i : ι)
     (hs : Acc (Dfinsupp.Lex r s) <| single i (x i)) (hu : Acc (Dfinsupp.Lex r s) <| x.eraseₓ i) :
     Acc (Dfinsupp.Lex r s) x := by
@@ -112,17 +113,17 @@ theorem Lex.acc_of_single_erase [DecidableEq ι] {x : Π₀ i, α i} (i : ι)
       (InvImage.accessible snd <| hs.prod_game_add hu)
   convert piecewise_single_erase x i
 #align dfinsupp.lex.acc_of_single_erase Dfinsupp.Lex.acc_of_single_erase
+-/
 
 variable (hbot : ∀ ⦃i a⦄, ¬s i a 0)
 
-include hbot
-
 #print Dfinsupp.Lex.acc_zero /-
 theorem Lex.acc_zero : Acc (Dfinsupp.Lex r s) 0 :=
   Acc.intro 0 fun x ⟨_, _, h⟩ => (hbot h).elim
 #align dfinsupp.lex.acc_zero Dfinsupp.Lex.acc_zero
 -/
 
+#print Dfinsupp.Lex.acc_of_single /-
 theorem Lex.acc_of_single [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠ 0)] (x : Π₀ i, α i) :
     (∀ i ∈ x.support, Acc (Dfinsupp.Lex r s) <| single i (x i)) → Acc (Dfinsupp.Lex r s) x :=
   by
@@ -135,11 +136,11 @@ theorem Lex.acc_of_single [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠
   rw [erase_ne (ha.ne_of_not_mem hb)]
   exact h a (Finset.mem_insert_of_mem ha)
 #align dfinsupp.lex.acc_of_single Dfinsupp.Lex.acc_of_single
+-/
 
 variable (hs : ∀ i, WellFounded (s i))
 
-include hs
-
+#print Dfinsupp.Lex.acc_single /-
 theorem Lex.acc_single [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)) i) :
     ∀ a, Acc (Dfinsupp.Lex r s) (single i a) :=
   by
@@ -160,30 +161,37 @@ theorem Lex.acc_single [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)
   · rw [hr j h, single_eq_of_ne hij, single_zero]; exact lex.acc_zero hbot
   · exact ih _ ⟨h, hij.symm⟩ _
 #align dfinsupp.lex.acc_single Dfinsupp.Lex.acc_single
+-/
 
+#print Dfinsupp.Lex.acc /-
 theorem Lex.acc [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠ 0)] (x : Π₀ i, α i)
     (h : ∀ i ∈ x.support, Acc (rᶜ ⊓ (· ≠ ·)) i) : Acc (Dfinsupp.Lex r s) x :=
   Lex.acc_of_single hbot x fun i hi => Lex.acc_single hbot hs (h i hi) _
 #align dfinsupp.lex.acc Dfinsupp.Lex.acc
+-/
 
+#print Dfinsupp.Lex.wellFounded /-
 theorem Lex.wellFounded (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded (Dfinsupp.Lex r s) :=
   ⟨fun x => by classical exact lex.acc hbot hs x fun i _ => hr.apply i⟩
 #align dfinsupp.lex.well_founded Dfinsupp.Lex.wellFounded
+-/
 
+#print Dfinsupp.Lex.wellFounded' /-
 theorem Lex.wellFounded' [IsTrichotomous ι r] (hr : WellFounded r.symm) :
     WellFounded (Dfinsupp.Lex r s) :=
   Lex.wellFounded hbot hs <|
     Subrelation.wf
       (fun i j h => ((@IsTrichotomous.trichotomous ι r _ i j).resolve_left h.1).resolve_left h.2) hr
 #align dfinsupp.lex.well_founded' Dfinsupp.Lex.wellFounded'
+-/
 
-omit hz hbot hs
-
+#print Dfinsupp.Lex.wellFoundedLT /-
 instance Lex.wellFoundedLT [LT ι] [IsTrichotomous ι (· < ·)] [hι : WellFoundedGT ι]
     [∀ i, CanonicallyOrderedAddMonoid (α i)] [hα : ∀ i, WellFoundedLT (α i)] :
     WellFoundedLT (Lex (Π₀ i, α i)) :=
   ⟨Lex.wellFounded' (fun i a => (zero_le a).not_lt) (fun i => (hα i).wf) hι.wf⟩
 #align dfinsupp.lex.well_founded_lt Dfinsupp.Lex.wellFoundedLT
+-/
 
 end Dfinsupp
 
@@ -191,6 +199,7 @@ open Dfinsupp
 
 variable (r : ι → ι → Prop) {s : ∀ i, α i → α i → Prop}
 
+#print Pi.Lex.wellFounded /-
 theorem Pi.Lex.wellFounded [IsStrictTotalOrder ι r] [Finite ι] (hs : ∀ i, WellFounded (s i)) :
     WellFounded (Pi.Lex r s) :=
   by
@@ -201,6 +210,7 @@ theorem Pi.Lex.wellFounded [IsStrictTotalOrder ι r] [Finite ι] (hs : ∀ i, We
   refine' InvImage.wf equiv_fun_on_fintype.symm (lex.well_founded' (fun i a => _) hs _)
   exacts [(hs i).not_lt_min ⊤ _ trivial, Finite.wellFounded_of_trans_of_irrefl r.swap]
 #align pi.lex.well_founded Pi.Lex.wellFounded
+-/
 
 #print Pi.Lex.wellFoundedLT /-
 instance Pi.Lex.wellFoundedLT [LinearOrder ι] [Finite ι] [∀ i, LT (α i)]
@@ -216,17 +226,22 @@ instance Function.Lex.wellFoundedLT {α} [LinearOrder ι] [Finite ι] [LT α] [W
 #align function.lex.well_founded_lt Function.Lex.wellFoundedLT
 -/
 
+#print Dfinsupp.Lex.wellFounded_of_finite /-
 theorem Dfinsupp.Lex.wellFounded_of_finite [IsStrictTotalOrder ι r] [Finite ι] [∀ i, Zero (α i)]
     (hs : ∀ i, WellFounded (s i)) : WellFounded (Dfinsupp.Lex r s) :=
   have := Fintype.ofFinite ι
   InvImage.wf equiv_fun_on_fintype (Pi.Lex.wellFounded r hs)
 #align dfinsupp.lex.well_founded_of_finite Dfinsupp.Lex.wellFounded_of_finite
+-/
 
+#print Dfinsupp.Lex.wellFoundedLT_of_finite /-
 instance Dfinsupp.Lex.wellFoundedLT_of_finite [LinearOrder ι] [Finite ι] [∀ i, Zero (α i)]
     [∀ i, LT (α i)] [hwf : ∀ i, WellFoundedLT (α i)] : WellFoundedLT (Lex (Π₀ i, α i)) :=
   ⟨Dfinsupp.Lex.wellFounded_of_finite (· < ·) fun i => (hwf i).1⟩
 #align dfinsupp.lex.well_founded_lt_of_finite Dfinsupp.Lex.wellFoundedLT_of_finite
+-/
 
+#print Dfinsupp.wellFoundedLT /-
 protected theorem Dfinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (α i)]
     [∀ i, WellFoundedLT (α i)] (hbot : ∀ ⦃i⦄ ⦃a : α i⦄, ¬a < 0) : WellFoundedLT (Π₀ i, α i) :=
   ⟨by
@@ -240,11 +255,14 @@ protected theorem Dfinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (
     · rintro i ⟨a⟩; apply hbot
     exacts [IsWellFounded.wf, IsTrichotomous.swap _, IsWellFounded.wf]⟩
 #align dfinsupp.well_founded_lt Dfinsupp.wellFoundedLT
+-/
 
+#print Dfinsupp.well_founded_lt' /-
 instance Dfinsupp.well_founded_lt' [∀ i, CanonicallyOrderedAddMonoid (α i)]
     [∀ i, WellFoundedLT (α i)] : WellFoundedLT (Π₀ i, α i) :=
   Dfinsupp.wellFoundedLT fun i a => (zero_le a).not_lt
 #align dfinsupp.well_founded_lt' Dfinsupp.well_founded_lt'
+-/
 
 #print Pi.wellFoundedLT /-
 instance Pi.wellFoundedLT [Finite ι] [∀ i, Preorder (α i)] [hw : ∀ i, WellFoundedLT (α i)] :
@@ -266,9 +284,11 @@ instance Function.wellFoundedLT {α} [Finite ι] [Preorder α] [WellFoundedLT α
 #align function.well_founded_lt Function.wellFoundedLT
 -/
 
+#print Dfinsupp.wellFoundedLT_of_finite /-
 instance Dfinsupp.wellFoundedLT_of_finite [Finite ι] [∀ i, Zero (α i)] [∀ i, Preorder (α i)]
     [∀ i, WellFoundedLT (α i)] : WellFoundedLT (Π₀ i, α i) :=
   have := Fintype.ofFinite ι
   ⟨InvImage.wf equiv_fun_on_fintype pi.well_founded_lt.wf⟩
 #align dfinsupp.well_founded_lt_of_finite Dfinsupp.wellFoundedLT_of_finite
+-/

1dac236e

bump to nightly-2023-06-04-18

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

3fb4268b

Diff

@@ -77,28 +77,28 @@ theorem lex_fibration [∀ (i) (s : Set ι), Decidable (i ∈ s)] :
   by
   rintro ⟨p, x₁, x₂⟩ x ⟨i, hr, hs⟩
   simp_rw [piecewise_apply] at hs hr 
-  split_ifs  at hs 
+  split_ifs at hs 
   classical
-    on_goal 1 =>
-      refine' ⟨⟨{ j | r j i → j ∈ p }, piecewise x₁ x { j | r j i }, x₂⟩, game_add.fst ⟨i, _⟩, _⟩
-    on_goal 3 =>
-      refine' ⟨⟨{ j | r j i ∧ j ∈ p }, x₁, piecewise x₂ x { j | r j i }⟩, game_add.snd ⟨i, _⟩, _⟩
-    pick_goal 3
-    iterate 2 
-      simp_rw [piecewise_apply]
-      refine' ⟨fun j h => if_pos h, _⟩
-      convert hs
-      refine' ite_eq_right_iff.2 fun h' => (hr i h').symm ▸ _
-      first
-      | rw [if_neg h]
-      | rw [if_pos h]
-    all_goals ext j; simp_rw [piecewise_apply]; split_ifs with h₁ h₂
-    · rw [hr j h₂, if_pos (h₁ h₂)]
-    · rfl
-    · rw [Set.mem_setOf, not_imp] at h₁ ; rw [hr j h₁.1, if_neg h₁.2]
-    · rw [hr j h₁.1, if_pos h₁.2]
-    · rw [hr j h₂, if_neg fun h' => h₁ ⟨h₂, h'⟩]
-    · rfl
+  on_goal 1 =>
+    refine' ⟨⟨{j | r j i → j ∈ p}, piecewise x₁ x {j | r j i}, x₂⟩, game_add.fst ⟨i, _⟩, _⟩
+  on_goal 3 =>
+    refine' ⟨⟨{j | r j i ∧ j ∈ p}, x₁, piecewise x₂ x {j | r j i}⟩, game_add.snd ⟨i, _⟩, _⟩
+  pick_goal 3
+  iterate 2 
+    simp_rw [piecewise_apply]
+    refine' ⟨fun j h => if_pos h, _⟩
+    convert hs
+    refine' ite_eq_right_iff.2 fun h' => (hr i h').symm ▸ _
+    first
+    | rw [if_neg h]
+    | rw [if_pos h]
+  all_goals ext j; simp_rw [piecewise_apply]; split_ifs with h₁ h₂
+  · rw [hr j h₂, if_pos (h₁ h₂)]
+  · rfl
+  · rw [Set.mem_setOf, not_imp] at h₁ ; rw [hr j h₁.1, if_neg h₁.2]
+  · rw [hr j h₁.1, if_pos h₁.2]
+  · rw [hr j h₂, if_neg fun h' => h₁ ⟨h₂, h'⟩]
+  · rfl
 #align dfinsupp.lex_fibration Dfinsupp.lex_fibration
 
 variable {r s}
@@ -107,10 +107,10 @@ theorem Lex.acc_of_single_erase [DecidableEq ι] {x : Π₀ i, α i} (i : ι)
     (hs : Acc (Dfinsupp.Lex r s) <| single i (x i)) (hu : Acc (Dfinsupp.Lex r s) <| x.eraseₓ i) :
     Acc (Dfinsupp.Lex r s) x := by
   classical
-    convert←
-      @Acc.of_fibration _ _ _ _ _ (lex_fibration r s) ⟨{i}, _⟩
-        (InvImage.accessible snd <| hs.prod_game_add hu)
-    convert piecewise_single_erase x i
+  convert ←
+    @Acc.of_fibration _ _ _ _ _ (lex_fibration r s) ⟨{i}, _⟩
+      (InvImage.accessible snd <| hs.prod_game_add hu)
+  convert piecewise_single_erase x i
 #align dfinsupp.lex.acc_of_single_erase Dfinsupp.Lex.acc_of_single_erase
 
 variable (hbot : ∀ ⦃i a⦄, ¬s i a 0)
@@ -128,12 +128,12 @@ theorem Lex.acc_of_single [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠
   by
   generalize ht : x.support = t; revert x
   classical
-    induction' t using Finset.induction with b t hb ih
-    · intro x ht; rw [support_eq_empty.1 ht]; exact fun _ => lex.acc_zero hbot
-    refine' fun x ht h => lex.acc_of_single_erase b (h b <| t.mem_insert_self b) _
-    refine' ih _ (by rw [support_erase, ht, Finset.erase_insert hb]) fun a ha => _
-    rw [erase_ne (ha.ne_of_not_mem hb)]
-    exact h a (Finset.mem_insert_of_mem ha)
+  induction' t using Finset.induction with b t hb ih
+  · intro x ht; rw [support_eq_empty.1 ht]; exact fun _ => lex.acc_zero hbot
+  refine' fun x ht h => lex.acc_of_single_erase b (h b <| t.mem_insert_self b) _
+  refine' ih _ (by rw [support_erase, ht, Finset.erase_insert hb]) fun a ha => _
+  rw [erase_ne (ha.ne_of_not_mem hb)]
+  exact h a (Finset.mem_insert_of_mem ha)
 #align dfinsupp.lex.acc_of_single Dfinsupp.Lex.acc_of_single
 
 variable (hs : ∀ i, WellFounded (s i))
@@ -148,17 +148,17 @@ theorem Lex.acc_single [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)
   refine' Acc.intro _ fun x => _
   rintro ⟨k, hr, hs⟩
   classical
-    rw [single_apply] at hs 
-    split_ifs  at hs  with hik
-    swap
-    · exact (hbot hs).elim
-    subst hik
-    refine' lex.acc_of_single hbot x fun j hj => _
-    obtain rfl | hij := eq_or_ne i j
-    · exact ha _ hs
-    by_cases r j i
-    · rw [hr j h, single_eq_of_ne hij, single_zero]; exact lex.acc_zero hbot
-    · exact ih _ ⟨h, hij.symm⟩ _
+  rw [single_apply] at hs 
+  split_ifs at hs  with hik
+  swap
+  · exact (hbot hs).elim
+  subst hik
+  refine' lex.acc_of_single hbot x fun j hj => _
+  obtain rfl | hij := eq_or_ne i j
+  · exact ha _ hs
+  by_cases r j i
+  · rw [hr j h, single_eq_of_ne hij, single_zero]; exact lex.acc_zero hbot
+  · exact ih _ ⟨h, hij.symm⟩ _
 #align dfinsupp.lex.acc_single Dfinsupp.Lex.acc_single
 
 theorem Lex.acc [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠ 0)] (x : Π₀ i, α i)

1dac236e

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -76,8 +76,8 @@ theorem lex_fibration [∀ (i) (s : Set ι), Decidable (i ∈ s)] :
       fun x => piecewise x.2.1 x.2.2 x.1 :=
   by
   rintro ⟨p, x₁, x₂⟩ x ⟨i, hr, hs⟩
-  simp_rw [piecewise_apply] at hs hr
-  split_ifs  at hs
+  simp_rw [piecewise_apply] at hs hr 
+  split_ifs  at hs 
   classical
     on_goal 1 =>
       refine' ⟨⟨{ j | r j i → j ∈ p }, piecewise x₁ x { j | r j i }, x₂⟩, game_add.fst ⟨i, _⟩, _⟩
@@ -89,11 +89,13 @@ theorem lex_fibration [∀ (i) (s : Set ι), Decidable (i ∈ s)] :
       refine' ⟨fun j h => if_pos h, _⟩
       convert hs
       refine' ite_eq_right_iff.2 fun h' => (hr i h').symm ▸ _
-      first |rw [if_neg h]|rw [if_pos h]
+      first
+      | rw [if_neg h]
+      | rw [if_pos h]
     all_goals ext j; simp_rw [piecewise_apply]; split_ifs with h₁ h₂
     · rw [hr j h₂, if_pos (h₁ h₂)]
     · rfl
-    · rw [Set.mem_setOf, not_imp] at h₁; rw [hr j h₁.1, if_neg h₁.2]
+    · rw [Set.mem_setOf, not_imp] at h₁ ; rw [hr j h₁.1, if_neg h₁.2]
     · rw [hr j h₁.1, if_pos h₁.2]
     · rw [hr j h₂, if_neg fun h' => h₁ ⟨h₂, h'⟩]
     · rfl
@@ -146,8 +148,8 @@ theorem Lex.acc_single [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)
   refine' Acc.intro _ fun x => _
   rintro ⟨k, hr, hs⟩
   classical
-    rw [single_apply] at hs
-    split_ifs  at hs with hik
+    rw [single_apply] at hs 
+    split_ifs  at hs  with hik
     swap
     · exact (hbot hs).elim
     subst hik
@@ -197,7 +199,7 @@ theorem Pi.Lex.wellFounded [IsStrictTotalOrder ι r] [Finite ι] (hs : ∀ i, We
   letI : ∀ i, Zero (α i) := fun i => ⟨(hs i).min ⊤ ⟨x i, trivial⟩⟩
   haveI := IsTrans.swap r; haveI := IsIrrefl.swap r; haveI := Fintype.ofFinite ι
   refine' InvImage.wf equiv_fun_on_fintype.symm (lex.well_founded' (fun i a => _) hs _)
-  exacts[(hs i).not_lt_min ⊤ _ trivial, Finite.wellFounded_of_trans_of_irrefl r.swap]
+  exacts [(hs i).not_lt_min ⊤ _ trivial, Finite.wellFounded_of_trans_of_irrefl r.swap]
 #align pi.lex.well_founded Pi.Lex.wellFounded
 
 #print Pi.Lex.wellFoundedLT /-
@@ -236,7 +238,7 @@ protected theorem Dfinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (
       obtain ⟨i, he, hl⟩ := lex_lt_of_lt_of_preorder well_ordering_rel.swap h
       exact ⟨i, fun j hj => Quot.sound (he j hj), hl⟩
     · rintro i ⟨a⟩; apply hbot
-    exacts[IsWellFounded.wf, IsTrichotomous.swap _, IsWellFounded.wf]⟩
+    exacts [IsWellFounded.wf, IsTrichotomous.swap _, IsWellFounded.wf]⟩
 #align dfinsupp.well_founded_lt Dfinsupp.wellFoundedLT
 
 instance Dfinsupp.well_founded_lt' [∀ i, CanonicallyOrderedAddMonoid (α i)]

1dac236e

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -200,15 +200,19 @@ theorem Pi.Lex.wellFounded [IsStrictTotalOrder ι r] [Finite ι] (hs : ∀ i, We
   exacts[(hs i).not_lt_min ⊤ _ trivial, Finite.wellFounded_of_trans_of_irrefl r.swap]
 #align pi.lex.well_founded Pi.Lex.wellFounded
 
+#print Pi.Lex.wellFoundedLT /-
 instance Pi.Lex.wellFoundedLT [LinearOrder ι] [Finite ι] [∀ i, LT (α i)]
     [hwf : ∀ i, WellFoundedLT (α i)] : WellFoundedLT (Lex (∀ i, α i)) :=
   ⟨Pi.Lex.wellFounded (· < ·) fun i => (hwf i).1⟩
 #align pi.lex.well_founded_lt Pi.Lex.wellFoundedLT
+-/
 
+#print Function.Lex.wellFoundedLT /-
 instance Function.Lex.wellFoundedLT {α} [LinearOrder ι] [Finite ι] [LT α] [WellFoundedLT α] :
     WellFoundedLT (Lex (ι → α)) :=
   Pi.Lex.wellFoundedLT
 #align function.lex.well_founded_lt Function.Lex.wellFoundedLT
+-/
 
 theorem Dfinsupp.Lex.wellFounded_of_finite [IsStrictTotalOrder ι r] [Finite ι] [∀ i, Zero (α i)]
     (hs : ∀ i, WellFounded (s i)) : WellFounded (Dfinsupp.Lex r s) :=
@@ -240,6 +244,7 @@ instance Dfinsupp.well_founded_lt' [∀ i, CanonicallyOrderedAddMonoid (α i)]
   Dfinsupp.wellFoundedLT fun i a => (zero_le a).not_lt
 #align dfinsupp.well_founded_lt' Dfinsupp.well_founded_lt'
 
+#print Pi.wellFoundedLT /-
 instance Pi.wellFoundedLT [Finite ι] [∀ i, Preorder (α i)] [hw : ∀ i, WellFoundedLT (α i)] :
     WellFoundedLT (∀ i, α i) :=
   ⟨by
@@ -250,11 +255,14 @@ instance Pi.wellFoundedLT [Finite ι] [∀ i, Preorder (α i)] [hw : ∀ i, Well
     refine' InvImage.wf equiv_fun_on_fintype.symm (Dfinsupp.wellFoundedLT fun i a => _).wf
     exact (hw i).wf.not_lt_min ⊤ _ trivial⟩
 #align pi.well_founded_lt Pi.wellFoundedLT
+-/
 
+#print Function.wellFoundedLT /-
 instance Function.wellFoundedLT {α} [Finite ι] [Preorder α] [WellFoundedLT α] :
     WellFoundedLT (ι → α) :=
   Pi.wellFoundedLT
 #align function.well_founded_lt Function.wellFoundedLT
+-/
 
 instance Dfinsupp.wellFoundedLT_of_finite [Finite ι] [∀ i, Zero (α i)] [∀ i, Preorder (α i)]
     [∀ i, WellFoundedLT (α i)] : WellFoundedLT (Π₀ i, α i) :=

1dac236e

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -63,12 +63,6 @@ include hz
 
 open Relation Prod
 
-/- warning: dfinsupp.lex_fibration -> Dfinsupp.lex_fibration is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [hz : forall (i : ι), Zero.{u2} (α i)] (r : ι -> ι -> Prop) (s : forall (i : ι), (α i) -> (α i) -> Prop) [_inst_1 : forall (i : ι) (s : Set.{u1} ι), Decidable (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s)], Relation.Fibration.{max u1 u2, max u1 u2} (Prod.{u1, max u1 u2} (Set.{u1} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)))) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (InvImage.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, max u1 u2} (Set.{u1} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)))) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) (Prod.GameAdd.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s)) (Prod.snd.{u1, max u1 u2} (Set.{u1} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))))) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (fun (x : Prod.{u1, max u1 u2} (Set.{u1} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)))) => Dfinsupp.piecewise.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) (Prod.fst.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Prod.snd.{u1, max u1 u2} (Set.{u1} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) x)) (Prod.snd.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Prod.snd.{u1, max u1 u2} (Set.{u1} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) x)) (Prod.fst.{u1, max u1 u2} (Set.{u1} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) x) (fun (i : ι) => _inst_1 i (Prod.fst.{u1, max u1 u2} (Set.{u1} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) x)))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] (r : ι -> ι -> Prop) (s : forall (i : ι), (α i) -> (α i) -> Prop) [_inst_1 : forall (i : ι) (s : Set.{u2} ι), Decidable (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s)], Relation.Fibration.{max u2 u1, max u1 u2} (Prod.{u2, max u2 u1} (Set.{u2} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)))) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (InvImage.{succ (max u2 u1), succ (max u1 u2)} (Prod.{u2, max u2 u1} (Set.{u2} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)))) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) (Prod.GameAdd.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s)) (Prod.snd.{u2, max u2 u1} (Set.{u2} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))))) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (fun (x : Prod.{u2, max u2 u1} (Set.{u2} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)))) => Dfinsupp.piecewise.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) (Prod.fst.{max u2 u1, max u2 u1} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Prod.snd.{u2, max u2 u1} (Set.{u2} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) x)) (Prod.snd.{max u2 u1, max u2 u1} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Prod.snd.{u2, max u2 u1} (Set.{u2} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) x)) (Prod.fst.{u2, max u2 u1} (Set.{u2} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) x) (fun (i : ι) => _inst_1 i (Prod.fst.{u2, max u2 u1} (Set.{u2} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) x)))
-Case conversion may be inaccurate. Consider using '#align dfinsupp.lex_fibration Dfinsupp.lex_fibrationₓ'. -/
 /-- This key lemma says that if a finitely supported dependent function `x₀` is obtained by merging
   two such functions `x₁` and `x₂`, and if we evolve `x₀` down the `dfinsupp.lex` relation one
   step and get `x`, we can always evolve one of `x₁` and `x₂` down the `dfinsupp.lex` relation
@@ -107,12 +101,6 @@ theorem lex_fibration [∀ (i) (s : Set ι), Decidable (i ∈ s)] :
 
 variable {r s}
 
-/- warning: dfinsupp.lex.acc_of_single_erase -> Dfinsupp.Lex.acc_of_single_erase is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [hz : forall (i : ι), Zero.{u2} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop} [_inst_1 : DecidableEq.{succ u1} ι] {x : Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)} (i : ι), (Acc.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.single.{u1, u2} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) i (coeFn.{succ (max u1 u2), max (succ u1) (succ u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (fun (_x : Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) => forall (i : ι), α i) (Dfinsupp.hasCoeToFun.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) x i))) -> (Acc.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.erase.{u1, u2} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) i x)) -> (Acc.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) x)
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop} [_inst_1 : DecidableEq.{succ u2} ι] {x : Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)} (i : ι), (Acc.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.single.{u2, u1} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) i (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Dfinsupp.{u2, u1} ι (fun (i : ι) => (fun (i : ι) => α i) i) (fun (i : ι) => (fun (i : ι) => hz i) i)) ι (fun (_x : ι) => (fun (i : ι) => (fun (i : ι) => α i) i) _x) (Dfinsupp.funLike.{u2, u1} ι (fun (i : ι) => (fun (i : ι) => α i) i) (fun (i : ι) => (fun (i : ι) => hz i) i)) x i))) -> (Acc.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.erase.{u2, u1} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) i x)) -> (Acc.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) x)
-Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.acc_of_single_erase Dfinsupp.Lex.acc_of_single_eraseₓ'. -/
 theorem Lex.acc_of_single_erase [DecidableEq ι] {x : Π₀ i, α i} (i : ι)
     (hs : Acc (Dfinsupp.Lex r s) <| single i (x i)) (hu : Acc (Dfinsupp.Lex r s) <| x.eraseₓ i) :
     Acc (Dfinsupp.Lex r s) x := by
@@ -133,12 +121,6 @@ theorem Lex.acc_zero : Acc (Dfinsupp.Lex r s) 0 :=
 #align dfinsupp.lex.acc_zero Dfinsupp.Lex.acc_zero
 -/
 
-/- warning: dfinsupp.lex.acc_of_single -> Dfinsupp.Lex.acc_of_single is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [hz : forall (i : ι), Zero.{u2} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (hz i)))))) -> (forall [_inst_1 : DecidableEq.{succ u1} ι] [_inst_2 : forall (i : ι) (x : α i), Decidable (Ne.{succ u2} (α i) x (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (hz i)))))] (x : Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)), (forall (i : ι), (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i (Dfinsupp.support.{u1, u2} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) (fun (i : ι) (x : α i) => _inst_2 i x) x)) -> (Acc.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.single.{u1, u2} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) i (coeFn.{succ (max u1 u2), max (succ u1) (succ u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (fun (_x : Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) => forall (i : ι), α i) (Dfinsupp.hasCoeToFun.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) x i)))) -> (Acc.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) x))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))) -> (forall [_inst_1 : DecidableEq.{succ u2} ι] [_inst_2 : forall (i : ι) (x : α i), Decidable (Ne.{succ u1} (α i) x (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))] (x : Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)), (forall (i : ι), (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i (Dfinsupp.support.{u2, u1} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) (fun (i : ι) (x : α i) => _inst_2 i x) x)) -> (Acc.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.single.{u2, u1} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) i (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Dfinsupp.{u2, u1} ι (fun (i : ι) => (fun (i : ι) => α i) i) (fun (i : ι) => (fun (i : ι) => hz i) i)) ι (fun (_x : ι) => (fun (i : ι) => (fun (i : ι) => α i) i) _x) (Dfinsupp.funLike.{u2, u1} ι (fun (i : ι) => (fun (i : ι) => α i) i) (fun (i : ι) => (fun (i : ι) => hz i) i)) x i)))) -> (Acc.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) x))
-Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.acc_of_single Dfinsupp.Lex.acc_of_singleₓ'. -/
 theorem Lex.acc_of_single [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠ 0)] (x : Π₀ i, α i) :
     (∀ i ∈ x.support, Acc (Dfinsupp.Lex r s) <| single i (x i)) → Acc (Dfinsupp.Lex r s) x :=
   by
@@ -156,12 +138,6 @@ variable (hs : ∀ i, WellFounded (s i))
 
 include hs
 
-/- warning: dfinsupp.lex.acc_single -> Dfinsupp.Lex.acc_single is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [hz : forall (i : ι), Zero.{u2} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (hz i)))))) -> (forall (i : ι), WellFounded.{succ u2} (α i) (s i)) -> (forall [_inst_1 : DecidableEq.{succ u1} ι] {i : ι}, (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} ι)) i) -> (forall (a : α i), Acc.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.single.{u1, u2} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) i a)))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))) -> (forall (i : ι), WellFounded.{succ u1} (α i) (s i)) -> (forall [_inst_1 : DecidableEq.{succ u2} ι] {i : ι}, (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.Dfinsupp.WellFounded._hyg.1464 : ι) (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1466 : ι) => Ne.{succ u2} ι x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1464 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1466)) i) -> (forall (a : α i), Acc.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.single.{u2, u1} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) i a)))
-Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.acc_single Dfinsupp.Lex.acc_singleₓ'. -/
 theorem Lex.acc_single [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)) i) :
     ∀ a, Acc (Dfinsupp.Lex r s) (single i a) :=
   by
@@ -183,33 +159,15 @@ theorem Lex.acc_single [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)
     · exact ih _ ⟨h, hij.symm⟩ _
 #align dfinsupp.lex.acc_single Dfinsupp.Lex.acc_single
 
-/- warning: dfinsupp.lex.acc -> Dfinsupp.Lex.acc is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [hz : forall (i : ι), Zero.{u2} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (hz i)))))) -> (forall (i : ι), WellFounded.{succ u2} (α i) (s i)) -> (forall [_inst_1 : DecidableEq.{succ u1} ι] [_inst_2 : forall (i : ι) (x : α i), Decidable (Ne.{succ u2} (α i) x (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (hz i)))))] (x : Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)), (forall (i : ι), (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i (Dfinsupp.support.{u1, u2} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) (fun (i : ι) (x : α i) => _inst_2 i x) 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} ι)) i)) -> (Acc.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) x))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))) -> (forall (i : ι), WellFounded.{succ u1} (α i) (s i)) -> (forall [_inst_1 : DecidableEq.{succ u2} ι] [_inst_2 : forall (i : ι) (x : α i), Decidable (Ne.{succ u1} (α i) x (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))] (x : Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)), (forall (i : ι), (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i (Dfinsupp.support.{u2, u1} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) (fun (i : ι) (x : α i) => _inst_2 i x) 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.Dfinsupp.WellFounded._hyg.1793 : ι) (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1795 : ι) => Ne.{succ u2} ι x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1793 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1795)) i)) -> (Acc.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) x))
-Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.acc Dfinsupp.Lex.accₓ'. -/
 theorem Lex.acc [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠ 0)] (x : Π₀ i, α i)
     (h : ∀ i ∈ x.support, Acc (rᶜ ⊓ (· ≠ ·)) i) : Acc (Dfinsupp.Lex r s) x :=
   Lex.acc_of_single hbot x fun i hi => Lex.acc_single hbot hs (h i hi) _
 #align dfinsupp.lex.acc Dfinsupp.Lex.acc
 
-/- warning: dfinsupp.lex.well_founded -> Dfinsupp.Lex.wellFounded is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [hz : forall (i : ι), Zero.{u2} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (hz i)))))) -> (forall (i : ι), WellFounded.{succ u2} (α i) (s i)) -> (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.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))) -> (forall (i : ι), WellFounded.{succ u1} (α i) (s i)) -> (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.Dfinsupp.WellFounded._hyg.1895 : ι) (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1897 : ι) => Ne.{succ u2} ι x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1895 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1897))) -> (WellFounded.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s))
-Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.well_founded Dfinsupp.Lex.wellFoundedₓ'. -/
 theorem Lex.wellFounded (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded (Dfinsupp.Lex r s) :=
   ⟨fun x => by classical exact lex.acc hbot hs x fun i _ => hr.apply i⟩
 #align dfinsupp.lex.well_founded Dfinsupp.Lex.wellFounded
 
-/- warning: dfinsupp.lex.well_founded' -> Dfinsupp.Lex.wellFounded' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [hz : forall (i : ι), Zero.{u2} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (hz i)))))) -> (forall (i : ι), WellFounded.{succ u2} (α i) (s i)) -> (forall [_inst_1 : IsTrichotomous.{u1} ι r], (WellFounded.{succ u1} ι (Function.swap.{succ u1, succ u1, 1} ι ι (fun (ᾰ : ι) (ᾰ : ι) => Prop) r)) -> (WellFounded.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s)))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))) -> (forall (i : ι), WellFounded.{succ u1} (α i) (s i)) -> (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)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s)))
-Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.well_founded' Dfinsupp.Lex.wellFounded'ₓ'. -/
 theorem Lex.wellFounded' [IsTrichotomous ι r] (hr : WellFounded r.symm) :
     WellFounded (Dfinsupp.Lex r s) :=
   Lex.wellFounded hbot hs <|
@@ -219,12 +177,6 @@ theorem Lex.wellFounded' [IsTrichotomous ι r] (hr : WellFounded r.symm) :
 
 omit hz hbot hs
 
-/- warning: dfinsupp.lex.well_founded_lt -> Dfinsupp.Lex.wellFoundedLT is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LT.{u1} ι] [_inst_2 : IsTrichotomous.{u1} ι (LT.lt.{u1} ι _inst_1)] [hι : WellFoundedGT.{u1} ι _inst_1] [_inst_3 : forall (i : ι), CanonicallyOrderedAddMonoid.{u2} (α i)] [hα : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))))) (Dfinsupp.Lex.hasLt.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))) _inst_1 (fun (i : ι) => Preorder.toHasLt.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i))))))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LT.{u1} ι] [_inst_2 : IsTrichotomous.{u1} ι (fun (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2052 : ι) (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2054 : ι) => LT.lt.{u1} ι _inst_1 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2052 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2054)] [hι : WellFoundedGT.{u1} ι _inst_1] [_inst_3 : forall (i : ι), CanonicallyOrderedAddMonoid.{u2} (α i)] [hα : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))], WellFoundedLT.{max u2 u1} (Lex.{max u2 u1} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddMonoid.toZero.{u2} ((fun (i : ι) => α i) i) (AddCommMonoid.toAddMonoid.{u2} ((fun (i : ι) => α i) i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (_inst_3 i))))))) (Dfinsupp.instLTLexDfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddMonoid.toZero.{u2} ((fun (i : ι) => α i) i) (AddCommMonoid.toAddMonoid.{u2} ((fun (i : ι) => α i) i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (_inst_3 i))))) _inst_1 (fun (i : ι) => Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i))))))
-Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.well_founded_lt Dfinsupp.Lex.wellFoundedLTₓ'. -/
 instance Lex.wellFoundedLT [LT ι] [IsTrichotomous ι (· < ·)] [hι : WellFoundedGT ι]
     [∀ i, CanonicallyOrderedAddMonoid (α i)] [hα : ∀ i, WellFoundedLT (α i)] :
     WellFoundedLT (Lex (Π₀ i, α i)) :=
@@ -237,12 +189,6 @@ open Dfinsupp
 
 variable (r : ι → ι → Prop) {s : ∀ i, α i → α i → Prop}
 
-/- warning: pi.lex.well_founded -> Pi.Lex.wellFounded is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} (r : ι -> ι -> Prop) {s : forall (i : ι), (α i) -> (α i) -> Prop} [_inst_1 : IsStrictTotalOrder.{u1} ι r] [_inst_2 : Finite.{succ u1} ι], (forall (i : ι), WellFounded.{succ u2} (α i) (s i)) -> (WellFounded.{max (succ u1) (succ u2)} (forall (i : ι), α i) (Pi.Lex.{u1, u2} ι (fun (i : ι) => α i) r s))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} (r : ι -> ι -> Prop) {s : forall (i : ι), (α i) -> (α i) -> Prop} [_inst_1 : IsStrictTotalOrder.{u2} ι r] [_inst_2 : Finite.{succ u2} ι], (forall (i : ι), WellFounded.{succ u1} (α i) (s i)) -> (WellFounded.{max (succ u1) (succ u2)} (forall (i : ι), α i) (Pi.Lex.{u2, u1} ι (fun {i : ι} => α i) r (fun {i : ι} => s i)))
-Case conversion may be inaccurate. Consider using '#align pi.lex.well_founded Pi.Lex.wellFoundedₓ'. -/
 theorem Pi.Lex.wellFounded [IsStrictTotalOrder ι r] [Finite ι] (hs : ∀ i, WellFounded (s i)) :
     WellFounded (Pi.Lex r s) :=
   by
@@ -254,57 +200,27 @@ theorem Pi.Lex.wellFounded [IsStrictTotalOrder ι r] [Finite ι] (hs : ∀ i, We
   exacts[(hs i).not_lt_min ⊤ _ trivial, Finite.wellFounded_of_trans_of_irrefl r.swap]
 #align pi.lex.well_founded Pi.Lex.wellFounded
 
-/- warning: pi.lex.well_founded_lt -> Pi.Lex.wellFoundedLT is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : Finite.{succ u1} ι] [_inst_3 : forall (i : ι), LT.{u2} (α i)] [hwf : forall (i : ι), WellFoundedLT.{u2} (α i) (_inst_3 i)], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), α i)) (Pi.Lex.hasLt.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))) (fun (a : ι) => _inst_3 a))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : Finite.{succ u1} ι] [_inst_3 : forall (i : ι), LT.{u2} (α i)] [hwf : forall (i : ι), WellFoundedLT.{u2} (α i) (_inst_3 i)], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), α i)) (Pi.instLTLexForAll.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (DistribLattice.toLattice.{u1} ι (instDistribLattice.{u1} ι _inst_1)))))) (fun (a : ι) => _inst_3 a))
-Case conversion may be inaccurate. Consider using '#align pi.lex.well_founded_lt Pi.Lex.wellFoundedLTₓ'. -/
 instance Pi.Lex.wellFoundedLT [LinearOrder ι] [Finite ι] [∀ i, LT (α i)]
     [hwf : ∀ i, WellFoundedLT (α i)] : WellFoundedLT (Lex (∀ i, α i)) :=
   ⟨Pi.Lex.wellFounded (· < ·) fun i => (hwf i).1⟩
 #align pi.lex.well_founded_lt Pi.Lex.wellFoundedLT
 
-/- warning: function.lex.well_founded_lt -> Function.Lex.wellFoundedLT is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : Finite.{succ u1} ι] [_inst_3 : LT.{u2} α] [_inst_4 : WellFoundedLT.{u2} α _inst_3], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (ι -> α)) (Pi.Lex.hasLt.{u1, u2} ι (fun (ᾰ : ι) => α) (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))) (fun (a : ι) => _inst_3))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : Finite.{succ u1} ι] [_inst_3 : LT.{u2} α] [_inst_4 : WellFoundedLT.{u2} α _inst_3], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (ι -> α)) (Pi.instLTLexForAll.{u1, u2} ι (fun (ᾰ : ι) => α) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (DistribLattice.toLattice.{u1} ι (instDistribLattice.{u1} ι _inst_1)))))) (fun (a : ι) => _inst_3))
-Case conversion may be inaccurate. Consider using '#align function.lex.well_founded_lt Function.Lex.wellFoundedLTₓ'. -/
 instance Function.Lex.wellFoundedLT {α} [LinearOrder ι] [Finite ι] [LT α] [WellFoundedLT α] :
     WellFoundedLT (Lex (ι → α)) :=
   Pi.Lex.wellFoundedLT
 #align function.lex.well_founded_lt Function.Lex.wellFoundedLT
 
-/- warning: dfinsupp.lex.well_founded_of_finite -> Dfinsupp.Lex.wellFounded_of_finite is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} (r : ι -> ι -> Prop) {s : forall (i : ι), (α i) -> (α i) -> Prop} [_inst_1 : IsStrictTotalOrder.{u1} ι r] [_inst_2 : Finite.{succ u1} ι] [_inst_3 : forall (i : ι), Zero.{u2} (α i)], (forall (i : ι), WellFounded.{succ u2} (α i) (s i)) -> (WellFounded.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i) r s))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} (r : ι -> ι -> Prop) {s : forall (i : ι), (α i) -> (α i) -> Prop} [_inst_1 : IsStrictTotalOrder.{u2} ι r] [_inst_2 : Finite.{succ u2} ι] [_inst_3 : forall (i : ι), Zero.{u1} (α i)], (forall (i : ι), WellFounded.{succ u1} (α i) (s i)) -> (WellFounded.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i) r s))
-Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.well_founded_of_finite Dfinsupp.Lex.wellFounded_of_finiteₓ'. -/
 theorem Dfinsupp.Lex.wellFounded_of_finite [IsStrictTotalOrder ι r] [Finite ι] [∀ i, Zero (α i)]
     (hs : ∀ i, WellFounded (s i)) : WellFounded (Dfinsupp.Lex r s) :=
   have := Fintype.ofFinite ι
   InvImage.wf equiv_fun_on_fintype (Pi.Lex.wellFounded r hs)
 #align dfinsupp.lex.well_founded_of_finite Dfinsupp.Lex.wellFounded_of_finite
 
-/- warning: dfinsupp.lex.well_founded_lt_of_finite -> Dfinsupp.Lex.wellFoundedLT_of_finite is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : Finite.{succ u1} ι] [_inst_3 : forall (i : ι), Zero.{u2} (α i)] [_inst_4 : forall (i : ι), LT.{u2} (α i)] [hwf : forall (i : ι), WellFoundedLT.{u2} (α i) (_inst_4 i)], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i))) (Dfinsupp.Lex.hasLt.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i) (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))) (fun (i : ι) => _inst_4 i))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : Finite.{succ u1} ι] [_inst_3 : forall (i : ι), Zero.{u2} (α i)] [_inst_4 : forall (i : ι), LT.{u2} (α i)] [hwf : forall (i : ι), WellFoundedLT.{u2} (α i) (_inst_4 i)], WellFoundedLT.{max u2 u1} (Lex.{max u2 u1} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i))) (Dfinsupp.instLTLexDfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (DistribLattice.toLattice.{u1} ι (instDistribLattice.{u1} ι _inst_1)))))) (fun (i : ι) => _inst_4 i))
-Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.well_founded_lt_of_finite Dfinsupp.Lex.wellFoundedLT_of_finiteₓ'. -/
 instance Dfinsupp.Lex.wellFoundedLT_of_finite [LinearOrder ι] [Finite ι] [∀ i, Zero (α i)]
     [∀ i, LT (α i)] [hwf : ∀ i, WellFoundedLT (α i)] : WellFoundedLT (Lex (Π₀ i, α i)) :=
   ⟨Dfinsupp.Lex.wellFounded_of_finite (· < ·) fun i => (hwf i).1⟩
 #align dfinsupp.lex.well_founded_lt_of_finite Dfinsupp.Lex.wellFoundedLT_of_finite
 
-/- warning: dfinsupp.well_founded_lt -> Dfinsupp.wellFoundedLT is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : forall (i : ι), Zero.{u2} (α i)] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_2 i))], (forall {{i : ι}} {{a : α i}}, Not (LT.lt.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_2 i)) a (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (_inst_1 i)))))) -> (WellFoundedLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i)) (Preorder.toHasLt.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i)) (Dfinsupp.preorder.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i) (fun (i : ι) => _inst_2 i))))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : forall (i : ι), Zero.{u2} (α i)] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i))], (forall {{i : ι}} {{a : α i}}, Not (LT.lt.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i)) a (OfNat.ofNat.{u2} (α i) 0 (Zero.toOfNat0.{u2} (α i) (_inst_1 i))))) -> (WellFoundedLT.{max u2 u1} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i)) (Preorder.toLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i)) (Dfinsupp.instPreorderDfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i) (fun (i : ι) => _inst_2 i))))
-Case conversion may be inaccurate. Consider using '#align dfinsupp.well_founded_lt Dfinsupp.wellFoundedLTₓ'. -/
 protected theorem Dfinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (α i)]
     [∀ i, WellFoundedLT (α i)] (hbot : ∀ ⦃i⦄ ⦃a : α i⦄, ¬a < 0) : WellFoundedLT (Π₀ i, α i) :=
   ⟨by
@@ -319,23 +235,11 @@ protected theorem Dfinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (
     exacts[IsWellFounded.wf, IsTrichotomous.swap _, IsWellFounded.wf]⟩
 #align dfinsupp.well_founded_lt Dfinsupp.wellFoundedLT
 
-/- warning: dfinsupp.well_founded_lt' -> Dfinsupp.well_founded_lt' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : forall (i : ι), CanonicallyOrderedAddMonoid.{u2} (α i)] [_inst_2 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i)))))], WellFoundedLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i))))))) (Preorder.toHasLt.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i))))))) (Dfinsupp.preorder.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i)))))) (fun (i : ι) => PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i))))))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : forall (i : ι), CanonicallyOrderedAddMonoid.{u2} (α i)] [_inst_2 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i)))))], WellFoundedLT.{max u2 u1} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddMonoid.toZero.{u2} ((fun (i : ι) => α i) i) (AddCommMonoid.toAddMonoid.{u2} ((fun (i : ι) => α i) i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (_inst_1 i)))))) (Preorder.toLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddMonoid.toZero.{u2} ((fun (i : ι) => α i) i) (AddCommMonoid.toAddMonoid.{u2} ((fun (i : ι) => α i) i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (_inst_1 i)))))) (Dfinsupp.instPreorderDfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddMonoid.toZero.{u2} ((fun (i : ι) => α i) i) (AddCommMonoid.toAddMonoid.{u2} ((fun (i : ι) => α i) i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (_inst_1 i))))) (fun (i : ι) => PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i))))))
-Case conversion may be inaccurate. Consider using '#align dfinsupp.well_founded_lt' Dfinsupp.well_founded_lt'ₓ'. -/
 instance Dfinsupp.well_founded_lt' [∀ i, CanonicallyOrderedAddMonoid (α i)]
     [∀ i, WellFoundedLT (α i)] : WellFoundedLT (Π₀ i, α i) :=
   Dfinsupp.wellFoundedLT fun i a => (zero_le a).not_lt
 #align dfinsupp.well_founded_lt' Dfinsupp.well_founded_lt'
 
-/- warning: pi.well_founded_lt -> Pi.wellFoundedLT is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Finite.{succ u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [hw : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_2 i))], WellFoundedLT.{max u1 u2} (forall (i : ι), α i) (Preorder.toHasLt.{max u1 u2} (forall (i : ι), α i) (Pi.preorder.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i)))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Finite.{succ u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [hw : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i))], WellFoundedLT.{max u1 u2} (forall (i : ι), α i) (Preorder.toLT.{max u1 u2} (forall (i : ι), α i) (Pi.preorder.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i)))
-Case conversion may be inaccurate. Consider using '#align pi.well_founded_lt Pi.wellFoundedLTₓ'. -/
 instance Pi.wellFoundedLT [Finite ι] [∀ i, Preorder (α i)] [hw : ∀ i, WellFoundedLT (α i)] :
     WellFoundedLT (∀ i, α i) :=
   ⟨by
@@ -347,23 +251,11 @@ instance Pi.wellFoundedLT [Finite ι] [∀ i, Preorder (α i)] [hw : ∀ i, Well
     exact (hw i).wf.not_lt_min ⊤ _ trivial⟩
 #align pi.well_founded_lt Pi.wellFoundedLT
 
-/- warning: function.well_founded_lt -> Function.wellFoundedLT is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Finite.{succ u1} ι] [_inst_2 : Preorder.{u2} α] [_inst_3 : WellFoundedLT.{u2} α (Preorder.toHasLt.{u2} α _inst_2)], WellFoundedLT.{max u1 u2} (ι -> α) (Preorder.toHasLt.{max u1 u2} (ι -> α) (Pi.preorder.{u1, u2} ι (fun (ᾰ : ι) => α) (fun (i : ι) => _inst_2)))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Finite.{succ u1} ι] [_inst_2 : Preorder.{u2} α] [_inst_3 : WellFoundedLT.{u2} α (Preorder.toLT.{u2} α _inst_2)], WellFoundedLT.{max u1 u2} (ι -> α) (Preorder.toLT.{max u1 u2} (ι -> α) (Pi.preorder.{u1, u2} ι (fun (ᾰ : ι) => α) (fun (i : ι) => _inst_2)))
-Case conversion may be inaccurate. Consider using '#align function.well_founded_lt Function.wellFoundedLTₓ'. -/
 instance Function.wellFoundedLT {α} [Finite ι] [Preorder α] [WellFoundedLT α] :
     WellFoundedLT (ι → α) :=
   Pi.wellFoundedLT
 #align function.well_founded_lt Function.wellFoundedLT
 
-/- warning: dfinsupp.well_founded_lt_of_finite -> Dfinsupp.wellFoundedLT_of_finite is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Finite.{succ u1} ι] [_inst_2 : forall (i : ι), Zero.{u2} (α i)] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_3 i))], WellFoundedLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i)) (Preorder.toHasLt.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i)) (Dfinsupp.preorder.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i) (fun (i : ι) => _inst_3 i)))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Finite.{succ u1} ι] [_inst_2 : forall (i : ι), Zero.{u2} (α i)] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_3 i))], WellFoundedLT.{max u2 u1} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i)) (Preorder.toLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i)) (Dfinsupp.instPreorderDfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i) (fun (i : ι) => _inst_3 i)))
-Case conversion may be inaccurate. Consider using '#align dfinsupp.well_founded_lt_of_finite Dfinsupp.wellFoundedLT_of_finiteₓ'. -/
 instance Dfinsupp.wellFoundedLT_of_finite [Finite ι] [∀ i, Zero (α i)] [∀ i, Preorder (α i)]
     [∀ i, WellFoundedLT (α i)] : WellFoundedLT (Π₀ i, α i) :=
   have := Fintype.ofFinite ι

1dac236e

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -99,8 +99,7 @@ theorem lex_fibration [∀ (i) (s : Set ι), Decidable (i ∈ s)] :
     all_goals ext j; simp_rw [piecewise_apply]; split_ifs with h₁ h₂
     · rw [hr j h₂, if_pos (h₁ h₂)]
     · rfl
-    · rw [Set.mem_setOf, not_imp] at h₁
-      rw [hr j h₁.1, if_neg h₁.2]
+    · rw [Set.mem_setOf, not_imp] at h₁; rw [hr j h₁.1, if_neg h₁.2]
     · rw [hr j h₁.1, if_pos h₁.2]
     · rw [hr j h₂, if_neg fun h' => h₁ ⟨h₂, h'⟩]
     · rfl
@@ -146,9 +145,7 @@ theorem Lex.acc_of_single [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠
   generalize ht : x.support = t; revert x
   classical
     induction' t using Finset.induction with b t hb ih
-    · intro x ht
-      rw [support_eq_empty.1 ht]
-      exact fun _ => lex.acc_zero hbot
+    · intro x ht; rw [support_eq_empty.1 ht]; exact fun _ => lex.acc_zero hbot
     refine' fun x ht h => lex.acc_of_single_erase b (h b <| t.mem_insert_self b) _
     refine' ih _ (by rw [support_erase, ht, Finset.erase_insert hb]) fun a ha => _
     rw [erase_ne (ha.ne_of_not_mem hb)]
@@ -182,8 +179,7 @@ theorem Lex.acc_single [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)
     obtain rfl | hij := eq_or_ne i j
     · exact ha _ hs
     by_cases r j i
-    · rw [hr j h, single_eq_of_ne hij, single_zero]
-      exact lex.acc_zero hbot
+    · rw [hr j h, single_eq_of_ne hij, single_zero]; exact lex.acc_zero hbot
     · exact ih _ ⟨h, hij.symm⟩ _
 #align dfinsupp.lex.acc_single Dfinsupp.Lex.acc_single
 
@@ -251,9 +247,7 @@ theorem Pi.Lex.wellFounded [IsStrictTotalOrder ι r] [Finite ι] (hs : ∀ i, We
     WellFounded (Pi.Lex r s) :=
   by
   obtain h | ⟨⟨x⟩⟩ := isEmpty_or_nonempty (∀ i, α i)
-  · convert empty_wf
-    ext1 x
-    exact (h.1 x).elim
+  · convert empty_wf; ext1 x; exact (h.1 x).elim
   letI : ∀ i, Zero (α i) := fun i => ⟨(hs i).min ⊤ ⟨x i, trivial⟩⟩
   haveI := IsTrans.swap r; haveI := IsIrrefl.swap r; haveI := Fintype.ofFinite ι
   refine' InvImage.wf equiv_fun_on_fintype.symm (lex.well_founded' (fun i a => _) hs _)
@@ -321,8 +315,7 @@ protected theorem Dfinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (
     · haveI := IsStrictOrder.swap (@WellOrderingRel ι)
       obtain ⟨i, he, hl⟩ := lex_lt_of_lt_of_preorder well_ordering_rel.swap h
       exact ⟨i, fun j hj => Quot.sound (he j hj), hl⟩
-    · rintro i ⟨a⟩
-      apply hbot
+    · rintro i ⟨a⟩; apply hbot
     exacts[IsWellFounded.wf, IsTrichotomous.swap _, IsWellFounded.wf]⟩
 #align dfinsupp.well_founded_lt Dfinsupp.wellFoundedLT
 
@@ -347,9 +340,7 @@ instance Pi.wellFoundedLT [Finite ι] [∀ i, Preorder (α i)] [hw : ∀ i, Well
     WellFoundedLT (∀ i, α i) :=
   ⟨by
     obtain h | ⟨⟨x⟩⟩ := isEmpty_or_nonempty (∀ i, α i)
-    · convert empty_wf
-      ext1 x
-      exact (h.1 x).elim
+    · convert empty_wf; ext1 x; exact (h.1 x).elim
     letI : ∀ i, Zero (α i) := fun i => ⟨(hw i).wf.min ⊤ ⟨x i, trivial⟩⟩
     haveI := Fintype.ofFinite ι
     refine' InvImage.wf equiv_fun_on_fintype.symm (Dfinsupp.wellFoundedLT fun i a => _).wf

1dac236e

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -225,7 +225,7 @@ omit hz hbot hs
 
 /- warning: dfinsupp.lex.well_founded_lt -> Dfinsupp.Lex.wellFoundedLT is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LT.{u1} ι] [_inst_2 : IsTrichotomous.{u1} ι (LT.lt.{u1} ι _inst_1)] [hι : WellFoundedGT.{u1} ι _inst_1] [_inst_3 : forall (i : ι), CanonicallyOrderedAddMonoid.{u2} (α i)] [hα : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))))) (Dfinsupp.Lex.hasLt.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))) _inst_1 (fun (i : ι) => Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i))))))
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LT.{u1} ι] [_inst_2 : IsTrichotomous.{u1} ι (LT.lt.{u1} ι _inst_1)] [hι : WellFoundedGT.{u1} ι _inst_1] [_inst_3 : forall (i : ι), CanonicallyOrderedAddMonoid.{u2} (α i)] [hα : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))))) (Dfinsupp.Lex.hasLt.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))) _inst_1 (fun (i : ι) => Preorder.toHasLt.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i))))))
 but is expected to have type
   forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LT.{u1} ι] [_inst_2 : IsTrichotomous.{u1} ι (fun (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2052 : ι) (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2054 : ι) => LT.lt.{u1} ι _inst_1 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2052 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2054)] [hι : WellFoundedGT.{u1} ι _inst_1] [_inst_3 : forall (i : ι), CanonicallyOrderedAddMonoid.{u2} (α i)] [hα : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))], WellFoundedLT.{max u2 u1} (Lex.{max u2 u1} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddMonoid.toZero.{u2} ((fun (i : ι) => α i) i) (AddCommMonoid.toAddMonoid.{u2} ((fun (i : ι) => α i) i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (_inst_3 i))))))) (Dfinsupp.instLTLexDfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddMonoid.toZero.{u2} ((fun (i : ι) => α i) i) (AddCommMonoid.toAddMonoid.{u2} ((fun (i : ι) => α i) i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (_inst_3 i))))) _inst_1 (fun (i : ι) => Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i))))))
 Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.well_founded_lt Dfinsupp.Lex.wellFoundedLTₓ'. -/
@@ -260,19 +260,27 @@ theorem Pi.Lex.wellFounded [IsStrictTotalOrder ι r] [Finite ι] (hs : ∀ i, We
   exacts[(hs i).not_lt_min ⊤ _ trivial, Finite.wellFounded_of_trans_of_irrefl r.swap]
 #align pi.lex.well_founded Pi.Lex.wellFounded
 
-#print Pi.Lex.wellFoundedLT /-
+/- warning: pi.lex.well_founded_lt -> Pi.Lex.wellFoundedLT is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : Finite.{succ u1} ι] [_inst_3 : forall (i : ι), LT.{u2} (α i)] [hwf : forall (i : ι), WellFoundedLT.{u2} (α i) (_inst_3 i)], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), α i)) (Pi.Lex.hasLt.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))) (fun (a : ι) => _inst_3 a))
+but is expected to have type
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : Finite.{succ u1} ι] [_inst_3 : forall (i : ι), LT.{u2} (α i)] [hwf : forall (i : ι), WellFoundedLT.{u2} (α i) (_inst_3 i)], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), α i)) (Pi.instLTLexForAll.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (DistribLattice.toLattice.{u1} ι (instDistribLattice.{u1} ι _inst_1)))))) (fun (a : ι) => _inst_3 a))
+Case conversion may be inaccurate. Consider using '#align pi.lex.well_founded_lt Pi.Lex.wellFoundedLTₓ'. -/
 instance Pi.Lex.wellFoundedLT [LinearOrder ι] [Finite ι] [∀ i, LT (α i)]
     [hwf : ∀ i, WellFoundedLT (α i)] : WellFoundedLT (Lex (∀ i, α i)) :=
   ⟨Pi.Lex.wellFounded (· < ·) fun i => (hwf i).1⟩
 #align pi.lex.well_founded_lt Pi.Lex.wellFoundedLT
--/
 
-#print Function.Lex.wellFoundedLT /-
+/- warning: function.lex.well_founded_lt -> Function.Lex.wellFoundedLT is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : Finite.{succ u1} ι] [_inst_3 : LT.{u2} α] [_inst_4 : WellFoundedLT.{u2} α _inst_3], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (ι -> α)) (Pi.Lex.hasLt.{u1, u2} ι (fun (ᾰ : ι) => α) (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))) (fun (a : ι) => _inst_3))
+but is expected to have type
+  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : Finite.{succ u1} ι] [_inst_3 : LT.{u2} α] [_inst_4 : WellFoundedLT.{u2} α _inst_3], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (ι -> α)) (Pi.instLTLexForAll.{u1, u2} ι (fun (ᾰ : ι) => α) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (DistribLattice.toLattice.{u1} ι (instDistribLattice.{u1} ι _inst_1)))))) (fun (a : ι) => _inst_3))
+Case conversion may be inaccurate. Consider using '#align function.lex.well_founded_lt Function.Lex.wellFoundedLTₓ'. -/
 instance Function.Lex.wellFoundedLT {α} [LinearOrder ι] [Finite ι] [LT α] [WellFoundedLT α] :
     WellFoundedLT (Lex (ι → α)) :=
   Pi.Lex.wellFoundedLT
 #align function.lex.well_founded_lt Function.Lex.wellFoundedLT
--/
 
 /- warning: dfinsupp.lex.well_founded_of_finite -> Dfinsupp.Lex.wellFounded_of_finite is a dubious translation:
 lean 3 declaration is
@@ -288,7 +296,7 @@ theorem Dfinsupp.Lex.wellFounded_of_finite [IsStrictTotalOrder ι r] [Finite ι]
 
 /- warning: dfinsupp.lex.well_founded_lt_of_finite -> Dfinsupp.Lex.wellFoundedLT_of_finite is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : Finite.{succ u1} ι] [_inst_3 : forall (i : ι), Zero.{u2} (α i)] [_inst_4 : forall (i : ι), LT.{u2} (α i)] [hwf : forall (i : ι), WellFoundedLT.{u2} (α i) (_inst_4 i)], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i))) (Dfinsupp.Lex.hasLt.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))) (fun (i : ι) => _inst_4 i))
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : Finite.{succ u1} ι] [_inst_3 : forall (i : ι), Zero.{u2} (α i)] [_inst_4 : forall (i : ι), LT.{u2} (α i)] [hwf : forall (i : ι), WellFoundedLT.{u2} (α i) (_inst_4 i)], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i))) (Dfinsupp.Lex.hasLt.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i) (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))) (fun (i : ι) => _inst_4 i))
 but is expected to have type
   forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : Finite.{succ u1} ι] [_inst_3 : forall (i : ι), Zero.{u2} (α i)] [_inst_4 : forall (i : ι), LT.{u2} (α i)] [hwf : forall (i : ι), WellFoundedLT.{u2} (α i) (_inst_4 i)], WellFoundedLT.{max u2 u1} (Lex.{max u2 u1} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i))) (Dfinsupp.instLTLexDfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (DistribLattice.toLattice.{u1} ι (instDistribLattice.{u1} ι _inst_1)))))) (fun (i : ι) => _inst_4 i))
 Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.well_founded_lt_of_finite Dfinsupp.Lex.wellFoundedLT_of_finiteₓ'. -/
@@ -299,7 +307,7 @@ instance Dfinsupp.Lex.wellFoundedLT_of_finite [LinearOrder ι] [Finite ι] [∀
 
 /- warning: dfinsupp.well_founded_lt -> Dfinsupp.wellFoundedLT is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : forall (i : ι), Zero.{u2} (α i)] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i))], (forall {{i : ι}} {{a : α i}}, Not (LT.lt.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i)) a (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (_inst_1 i)))))) -> (WellFoundedLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i)) (Preorder.toLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i)) (Dfinsupp.preorder.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i) (fun (i : ι) => _inst_2 i))))
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : forall (i : ι), Zero.{u2} (α i)] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_2 i))], (forall {{i : ι}} {{a : α i}}, Not (LT.lt.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_2 i)) a (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (_inst_1 i)))))) -> (WellFoundedLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i)) (Preorder.toHasLt.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i)) (Dfinsupp.preorder.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i) (fun (i : ι) => _inst_2 i))))
 but is expected to have type
   forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : forall (i : ι), Zero.{u2} (α i)] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i))], (forall {{i : ι}} {{a : α i}}, Not (LT.lt.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i)) a (OfNat.ofNat.{u2} (α i) 0 (Zero.toOfNat0.{u2} (α i) (_inst_1 i))))) -> (WellFoundedLT.{max u2 u1} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i)) (Preorder.toLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i)) (Dfinsupp.instPreorderDfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i) (fun (i : ι) => _inst_2 i))))
 Case conversion may be inaccurate. Consider using '#align dfinsupp.well_founded_lt Dfinsupp.wellFoundedLTₓ'. -/
@@ -320,7 +328,7 @@ protected theorem Dfinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (
 
 /- warning: dfinsupp.well_founded_lt' -> Dfinsupp.well_founded_lt' is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : forall (i : ι), CanonicallyOrderedAddMonoid.{u2} (α i)] [_inst_2 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i)))))], WellFoundedLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i))))))) (Preorder.toLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i))))))) (Dfinsupp.preorder.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i)))))) (fun (i : ι) => PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i))))))
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : forall (i : ι), CanonicallyOrderedAddMonoid.{u2} (α i)] [_inst_2 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i)))))], WellFoundedLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i))))))) (Preorder.toHasLt.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i))))))) (Dfinsupp.preorder.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i)))))) (fun (i : ι) => PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i))))))
 but is expected to have type
   forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : forall (i : ι), CanonicallyOrderedAddMonoid.{u2} (α i)] [_inst_2 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i)))))], WellFoundedLT.{max u2 u1} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddMonoid.toZero.{u2} ((fun (i : ι) => α i) i) (AddCommMonoid.toAddMonoid.{u2} ((fun (i : ι) => α i) i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (_inst_1 i)))))) (Preorder.toLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddMonoid.toZero.{u2} ((fun (i : ι) => α i) i) (AddCommMonoid.toAddMonoid.{u2} ((fun (i : ι) => α i) i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (_inst_1 i)))))) (Dfinsupp.instPreorderDfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddMonoid.toZero.{u2} ((fun (i : ι) => α i) i) (AddCommMonoid.toAddMonoid.{u2} ((fun (i : ι) => α i) i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (_inst_1 i))))) (fun (i : ι) => PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i))))))
 Case conversion may be inaccurate. Consider using '#align dfinsupp.well_founded_lt' Dfinsupp.well_founded_lt'ₓ'. -/
@@ -329,7 +337,12 @@ instance Dfinsupp.well_founded_lt' [∀ i, CanonicallyOrderedAddMonoid (α i)]
   Dfinsupp.wellFoundedLT fun i a => (zero_le a).not_lt
 #align dfinsupp.well_founded_lt' Dfinsupp.well_founded_lt'
 
-#print Pi.wellFoundedLT /-
+/- warning: pi.well_founded_lt -> Pi.wellFoundedLT is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Finite.{succ u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [hw : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_2 i))], WellFoundedLT.{max u1 u2} (forall (i : ι), α i) (Preorder.toHasLt.{max u1 u2} (forall (i : ι), α i) (Pi.preorder.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i)))
+but is expected to have type
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Finite.{succ u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [hw : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i))], WellFoundedLT.{max u1 u2} (forall (i : ι), α i) (Preorder.toLT.{max u1 u2} (forall (i : ι), α i) (Pi.preorder.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i)))
+Case conversion may be inaccurate. Consider using '#align pi.well_founded_lt Pi.wellFoundedLTₓ'. -/
 instance Pi.wellFoundedLT [Finite ι] [∀ i, Preorder (α i)] [hw : ∀ i, WellFoundedLT (α i)] :
     WellFoundedLT (∀ i, α i) :=
   ⟨by
@@ -342,18 +355,21 @@ instance Pi.wellFoundedLT [Finite ι] [∀ i, Preorder (α i)] [hw : ∀ i, Well
     refine' InvImage.wf equiv_fun_on_fintype.symm (Dfinsupp.wellFoundedLT fun i a => _).wf
     exact (hw i).wf.not_lt_min ⊤ _ trivial⟩
 #align pi.well_founded_lt Pi.wellFoundedLT
--/
 
-#print Function.wellFoundedLT /-
+/- warning: function.well_founded_lt -> Function.wellFoundedLT is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Finite.{succ u1} ι] [_inst_2 : Preorder.{u2} α] [_inst_3 : WellFoundedLT.{u2} α (Preorder.toHasLt.{u2} α _inst_2)], WellFoundedLT.{max u1 u2} (ι -> α) (Preorder.toHasLt.{max u1 u2} (ι -> α) (Pi.preorder.{u1, u2} ι (fun (ᾰ : ι) => α) (fun (i : ι) => _inst_2)))
+but is expected to have type
+  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Finite.{succ u1} ι] [_inst_2 : Preorder.{u2} α] [_inst_3 : WellFoundedLT.{u2} α (Preorder.toLT.{u2} α _inst_2)], WellFoundedLT.{max u1 u2} (ι -> α) (Preorder.toLT.{max u1 u2} (ι -> α) (Pi.preorder.{u1, u2} ι (fun (ᾰ : ι) => α) (fun (i : ι) => _inst_2)))
+Case conversion may be inaccurate. Consider using '#align function.well_founded_lt Function.wellFoundedLTₓ'. -/
 instance Function.wellFoundedLT {α} [Finite ι] [Preorder α] [WellFoundedLT α] :
     WellFoundedLT (ι → α) :=
   Pi.wellFoundedLT
 #align function.well_founded_lt Function.wellFoundedLT
--/
 
 /- warning: dfinsupp.well_founded_lt_of_finite -> Dfinsupp.wellFoundedLT_of_finite is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Finite.{succ u1} ι] [_inst_2 : forall (i : ι), Zero.{u2} (α i)] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_3 i))], WellFoundedLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i)) (Preorder.toLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i)) (Dfinsupp.preorder.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i) (fun (i : ι) => _inst_3 i)))
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Finite.{succ u1} ι] [_inst_2 : forall (i : ι), Zero.{u2} (α i)] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_3 i))], WellFoundedLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i)) (Preorder.toHasLt.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i)) (Dfinsupp.preorder.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i) (fun (i : ι) => _inst_3 i)))
 but is expected to have type
   forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Finite.{succ u1} ι] [_inst_2 : forall (i : ι), Zero.{u2} (α i)] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_3 i))], WellFoundedLT.{max u2 u1} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i)) (Preorder.toLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i)) (Dfinsupp.instPreorderDfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i) (fun (i : ι) => _inst_3 i)))
 Case conversion may be inaccurate. Consider using '#align dfinsupp.well_founded_lt_of_finite Dfinsupp.wellFoundedLT_of_finiteₓ'. -/

1dac236e

bump to nightly-2023-05-03-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/36b8aa61ea7c05727161f96a0532897bd72aedab

aa7b8e08

Diff

@@ -163,7 +163,7 @@ include hs
 lean 3 declaration is
   forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [hz : forall (i : ι), Zero.{u2} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (hz i)))))) -> (forall (i : ι), WellFounded.{succ u2} (α i) (s i)) -> (forall [_inst_1 : DecidableEq.{succ u1} ι] {i : ι}, (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} ι)) i) -> (forall (a : α i), Acc.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.single.{u1, u2} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) i a)))
 but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))) -> (forall (i : ι), WellFounded.{succ u1} (α i) (s i)) -> (forall [_inst_1 : DecidableEq.{succ u2} ι] {i : ι}, (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.Dfinsupp.WellFounded._hyg.1466 : ι) (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1468 : ι) => Ne.{succ u2} ι x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1466 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1468)) i) -> (forall (a : α i), Acc.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.single.{u2, u1} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) i a)))
+  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))) -> (forall (i : ι), WellFounded.{succ u1} (α i) (s i)) -> (forall [_inst_1 : DecidableEq.{succ u2} ι] {i : ι}, (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.Dfinsupp.WellFounded._hyg.1464 : ι) (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1466 : ι) => Ne.{succ u2} ι x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1464 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1466)) i) -> (forall (a : α i), Acc.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.single.{u2, u1} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) i a)))
 Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.acc_single Dfinsupp.Lex.acc_singleₓ'. -/
 theorem Lex.acc_single [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)) i) :
     ∀ a, Acc (Dfinsupp.Lex r s) (single i a) :=
@@ -191,7 +191,7 @@ theorem Lex.acc_single [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)
 lean 3 declaration is
   forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [hz : forall (i : ι), Zero.{u2} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (hz i)))))) -> (forall (i : ι), WellFounded.{succ u2} (α i) (s i)) -> (forall [_inst_1 : DecidableEq.{succ u1} ι] [_inst_2 : forall (i : ι) (x : α i), Decidable (Ne.{succ u2} (α i) x (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (hz i)))))] (x : Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)), (forall (i : ι), (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i (Dfinsupp.support.{u1, u2} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) (fun (i : ι) (x : α i) => _inst_2 i x) 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} ι)) i)) -> (Acc.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) x))
 but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))) -> (forall (i : ι), WellFounded.{succ u1} (α i) (s i)) -> (forall [_inst_1 : DecidableEq.{succ u2} ι] [_inst_2 : forall (i : ι) (x : α i), Decidable (Ne.{succ u1} (α i) x (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))] (x : Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)), (forall (i : ι), (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i (Dfinsupp.support.{u2, u1} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) (fun (i : ι) (x : α i) => _inst_2 i x) 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.Dfinsupp.WellFounded._hyg.1795 : ι) (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1797 : ι) => Ne.{succ u2} ι x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1795 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1797)) i)) -> (Acc.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) x))
+  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))) -> (forall (i : ι), WellFounded.{succ u1} (α i) (s i)) -> (forall [_inst_1 : DecidableEq.{succ u2} ι] [_inst_2 : forall (i : ι) (x : α i), Decidable (Ne.{succ u1} (α i) x (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))] (x : Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)), (forall (i : ι), (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i (Dfinsupp.support.{u2, u1} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) (fun (i : ι) (x : α i) => _inst_2 i x) 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.Dfinsupp.WellFounded._hyg.1793 : ι) (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1795 : ι) => Ne.{succ u2} ι x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1793 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1795)) i)) -> (Acc.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) x))
 Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.acc Dfinsupp.Lex.accₓ'. -/
 theorem Lex.acc [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠ 0)] (x : Π₀ i, α i)
     (h : ∀ i ∈ x.support, Acc (rᶜ ⊓ (· ≠ ·)) i) : Acc (Dfinsupp.Lex r s) x :=
@@ -202,7 +202,7 @@ theorem Lex.acc [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠ 0)] (x :
 lean 3 declaration is
   forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [hz : forall (i : ι), Zero.{u2} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (hz i)))))) -> (forall (i : ι), WellFounded.{succ u2} (α i) (s i)) -> (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.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s))
 but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))) -> (forall (i : ι), WellFounded.{succ u1} (α i) (s i)) -> (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.Dfinsupp.WellFounded._hyg.1897 : ι) (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1899 : ι) => Ne.{succ u2} ι x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1897 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1899))) -> (WellFounded.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s))
+  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))) -> (forall (i : ι), WellFounded.{succ u1} (α i) (s i)) -> (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.Dfinsupp.WellFounded._hyg.1895 : ι) (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1897 : ι) => Ne.{succ u2} ι x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1895 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1897))) -> (WellFounded.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s))
 Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.well_founded Dfinsupp.Lex.wellFoundedₓ'. -/
 theorem Lex.wellFounded (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded (Dfinsupp.Lex r s) :=
   ⟨fun x => by classical exact lex.acc hbot hs x fun i _ => hr.apply i⟩
@@ -227,7 +227,7 @@ omit hz hbot hs
 lean 3 declaration is
   forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LT.{u1} ι] [_inst_2 : IsTrichotomous.{u1} ι (LT.lt.{u1} ι _inst_1)] [hι : WellFoundedGT.{u1} ι _inst_1] [_inst_3 : forall (i : ι), CanonicallyOrderedAddMonoid.{u2} (α i)] [hα : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))))) (Dfinsupp.Lex.hasLt.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))) _inst_1 (fun (i : ι) => Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i))))))
 but is expected to have type
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LT.{u1} ι] [_inst_2 : IsTrichotomous.{u1} ι (fun (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2054 : ι) (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2056 : ι) => LT.lt.{u1} ι _inst_1 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2054 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2056)] [hι : WellFoundedGT.{u1} ι _inst_1] [_inst_3 : forall (i : ι), CanonicallyOrderedAddMonoid.{u2} (α i)] [hα : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))], WellFoundedLT.{max u2 u1} (Lex.{max u2 u1} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddMonoid.toZero.{u2} ((fun (i : ι) => α i) i) (AddCommMonoid.toAddMonoid.{u2} ((fun (i : ι) => α i) i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (_inst_3 i))))))) (Dfinsupp.instLTLexDfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddMonoid.toZero.{u2} ((fun (i : ι) => α i) i) (AddCommMonoid.toAddMonoid.{u2} ((fun (i : ι) => α i) i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (_inst_3 i))))) _inst_1 (fun (i : ι) => Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i))))))
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LT.{u1} ι] [_inst_2 : IsTrichotomous.{u1} ι (fun (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2052 : ι) (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2054 : ι) => LT.lt.{u1} ι _inst_1 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2052 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2054)] [hι : WellFoundedGT.{u1} ι _inst_1] [_inst_3 : forall (i : ι), CanonicallyOrderedAddMonoid.{u2} (α i)] [hα : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))], WellFoundedLT.{max u2 u1} (Lex.{max u2 u1} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddMonoid.toZero.{u2} ((fun (i : ι) => α i) i) (AddCommMonoid.toAddMonoid.{u2} ((fun (i : ι) => α i) i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (_inst_3 i))))))) (Dfinsupp.instLTLexDfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddMonoid.toZero.{u2} ((fun (i : ι) => α i) i) (AddCommMonoid.toAddMonoid.{u2} ((fun (i : ι) => α i) i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (_inst_3 i))))) _inst_1 (fun (i : ι) => Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i))))))
 Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.well_founded_lt Dfinsupp.Lex.wellFoundedLTₓ'. -/
 instance Lex.wellFoundedLT [LT ι] [IsTrichotomous ι (· < ·)] [hι : WellFoundedGT ι]
     [∀ i, CanonicallyOrderedAddMonoid (α i)] [hα : ∀ i, WellFoundedLT (α i)] :

1dac236e

bump to nightly-2023-03-20-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/7ec294687917cbc5c73620b4414ae9b5dd9ae1b4

2e1f2c13

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.dfinsupp.well_founded
-! leanprover-community/mathlib commit e9b8651eb1ad354f4de6be35a38ef31efcd2cfaa
+! leanprover-community/mathlib commit 1dac236edca9b4b6f5f00b1ad831e35f89472837
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -16,6 +16,9 @@ import Mathbin.SetTheory.Ordinal.Basic
 /-!
 # Well-foundedness of the lexicographic and product orders on `dfinsupp` and `pi`
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 The primary results are `dfinsupp.lex.well_founded` and the two variants that follow it,
 which essentially say that if `(>)` is a well order on `ι`, `(<)` is well-founded on each
 `α i`, and `0` is a bottom element in `α i`, then the lexicographic `(<)` is well-founded

e9b8651e

bump to nightly-2023-03-18-18

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

eb7660d5

Diff

@@ -60,6 +60,12 @@ include hz
 
 open Relation Prod
 
+/- warning: dfinsupp.lex_fibration -> Dfinsupp.lex_fibration is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [hz : forall (i : ι), Zero.{u2} (α i)] (r : ι -> ι -> Prop) (s : forall (i : ι), (α i) -> (α i) -> Prop) [_inst_1 : forall (i : ι) (s : Set.{u1} ι), Decidable (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s)], Relation.Fibration.{max u1 u2, max u1 u2} (Prod.{u1, max u1 u2} (Set.{u1} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)))) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (InvImage.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, max u1 u2} (Set.{u1} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)))) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) (Prod.GameAdd.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s)) (Prod.snd.{u1, max u1 u2} (Set.{u1} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))))) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (fun (x : Prod.{u1, max u1 u2} (Set.{u1} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)))) => Dfinsupp.piecewise.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) (Prod.fst.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Prod.snd.{u1, max u1 u2} (Set.{u1} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) x)) (Prod.snd.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Prod.snd.{u1, max u1 u2} (Set.{u1} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) x)) (Prod.fst.{u1, max u1 u2} (Set.{u1} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) x) (fun (i : ι) => _inst_1 i (Prod.fst.{u1, max u1 u2} (Set.{u1} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) x)))
+but is expected to have type
+  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] (r : ι -> ι -> Prop) (s : forall (i : ι), (α i) -> (α i) -> Prop) [_inst_1 : forall (i : ι) (s : Set.{u2} ι), Decidable (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s)], Relation.Fibration.{max u2 u1, max u1 u2} (Prod.{u2, max u2 u1} (Set.{u2} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)))) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (InvImage.{succ (max u2 u1), succ (max u1 u2)} (Prod.{u2, max u2 u1} (Set.{u2} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)))) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) (Prod.GameAdd.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s)) (Prod.snd.{u2, max u2 u1} (Set.{u2} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))))) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (fun (x : Prod.{u2, max u2 u1} (Set.{u2} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)))) => Dfinsupp.piecewise.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) (Prod.fst.{max u2 u1, max u2 u1} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Prod.snd.{u2, max u2 u1} (Set.{u2} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) x)) (Prod.snd.{max u2 u1, max u2 u1} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Prod.snd.{u2, max u2 u1} (Set.{u2} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) x)) (Prod.fst.{u2, max u2 u1} (Set.{u2} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) x) (fun (i : ι) => _inst_1 i (Prod.fst.{u2, max u2 u1} (Set.{u2} ι) (Prod.{max u1 u2, max u1 u2} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i))) x)))
+Case conversion may be inaccurate. Consider using '#align dfinsupp.lex_fibration Dfinsupp.lex_fibrationₓ'. -/
 /-- This key lemma says that if a finitely supported dependent function `x₀` is obtained by merging
   two such functions `x₁` and `x₂`, and if we evolve `x₀` down the `dfinsupp.lex` relation one
   step and get `x`, we can always evolve one of `x₁` and `x₂` down the `dfinsupp.lex` relation
@@ -99,6 +105,12 @@ theorem lex_fibration [∀ (i) (s : Set ι), Decidable (i ∈ s)] :
 
 variable {r s}
 
+/- warning: dfinsupp.lex.acc_of_single_erase -> Dfinsupp.Lex.acc_of_single_erase is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [hz : forall (i : ι), Zero.{u2} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop} [_inst_1 : DecidableEq.{succ u1} ι] {x : Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)} (i : ι), (Acc.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.single.{u1, u2} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) i (coeFn.{succ (max u1 u2), max (succ u1) (succ u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (fun (_x : Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) => forall (i : ι), α i) (Dfinsupp.hasCoeToFun.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) x i))) -> (Acc.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.erase.{u1, u2} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) i x)) -> (Acc.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) x)
+but is expected to have type
+  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop} [_inst_1 : DecidableEq.{succ u2} ι] {x : Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)} (i : ι), (Acc.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.single.{u2, u1} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) i (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Dfinsupp.{u2, u1} ι (fun (i : ι) => (fun (i : ι) => α i) i) (fun (i : ι) => (fun (i : ι) => hz i) i)) ι (fun (_x : ι) => (fun (i : ι) => (fun (i : ι) => α i) i) _x) (Dfinsupp.funLike.{u2, u1} ι (fun (i : ι) => (fun (i : ι) => α i) i) (fun (i : ι) => (fun (i : ι) => hz i) i)) x i))) -> (Acc.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.erase.{u2, u1} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) i x)) -> (Acc.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) x)
+Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.acc_of_single_erase Dfinsupp.Lex.acc_of_single_eraseₓ'. -/
 theorem Lex.acc_of_single_erase [DecidableEq ι] {x : Π₀ i, α i} (i : ι)
     (hs : Acc (Dfinsupp.Lex r s) <| single i (x i)) (hu : Acc (Dfinsupp.Lex r s) <| x.eraseₓ i) :
     Acc (Dfinsupp.Lex r s) x := by
@@ -113,10 +125,18 @@ variable (hbot : ∀ ⦃i a⦄, ¬s i a 0)
 
 include hbot
 
+#print Dfinsupp.Lex.acc_zero /-
 theorem Lex.acc_zero : Acc (Dfinsupp.Lex r s) 0 :=
   Acc.intro 0 fun x ⟨_, _, h⟩ => (hbot h).elim
 #align dfinsupp.lex.acc_zero Dfinsupp.Lex.acc_zero
+-/
 
+/- warning: dfinsupp.lex.acc_of_single -> Dfinsupp.Lex.acc_of_single is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [hz : forall (i : ι), Zero.{u2} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (hz i)))))) -> (forall [_inst_1 : DecidableEq.{succ u1} ι] [_inst_2 : forall (i : ι) (x : α i), Decidable (Ne.{succ u2} (α i) x (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (hz i)))))] (x : Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)), (forall (i : ι), (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i (Dfinsupp.support.{u1, u2} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) (fun (i : ι) (x : α i) => _inst_2 i x) x)) -> (Acc.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.single.{u1, u2} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) i (coeFn.{succ (max u1 u2), max (succ u1) (succ u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (fun (_x : Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) => forall (i : ι), α i) (Dfinsupp.hasCoeToFun.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) x i)))) -> (Acc.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) x))
+but is expected to have type
+  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))) -> (forall [_inst_1 : DecidableEq.{succ u2} ι] [_inst_2 : forall (i : ι) (x : α i), Decidable (Ne.{succ u1} (α i) x (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))] (x : Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)), (forall (i : ι), (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i (Dfinsupp.support.{u2, u1} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) (fun (i : ι) (x : α i) => _inst_2 i x) x)) -> (Acc.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.single.{u2, u1} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) i (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Dfinsupp.{u2, u1} ι (fun (i : ι) => (fun (i : ι) => α i) i) (fun (i : ι) => (fun (i : ι) => hz i) i)) ι (fun (_x : ι) => (fun (i : ι) => (fun (i : ι) => α i) i) _x) (Dfinsupp.funLike.{u2, u1} ι (fun (i : ι) => (fun (i : ι) => α i) i) (fun (i : ι) => (fun (i : ι) => hz i) i)) x i)))) -> (Acc.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) x))
+Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.acc_of_single Dfinsupp.Lex.acc_of_singleₓ'. -/
 theorem Lex.acc_of_single [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠ 0)] (x : Π₀ i, α i) :
     (∀ i ∈ x.support, Acc (Dfinsupp.Lex r s) <| single i (x i)) → Acc (Dfinsupp.Lex r s) x :=
   by
@@ -136,6 +156,12 @@ variable (hs : ∀ i, WellFounded (s i))
 
 include hs
 
+/- warning: dfinsupp.lex.acc_single -> Dfinsupp.Lex.acc_single is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [hz : forall (i : ι), Zero.{u2} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (hz i)))))) -> (forall (i : ι), WellFounded.{succ u2} (α i) (s i)) -> (forall [_inst_1 : DecidableEq.{succ u1} ι] {i : ι}, (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} ι)) i) -> (forall (a : α i), Acc.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.single.{u1, u2} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) i a)))
+but is expected to have type
+  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))) -> (forall (i : ι), WellFounded.{succ u1} (α i) (s i)) -> (forall [_inst_1 : DecidableEq.{succ u2} ι] {i : ι}, (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.Dfinsupp.WellFounded._hyg.1466 : ι) (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1468 : ι) => Ne.{succ u2} ι x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1466 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1468)) i) -> (forall (a : α i), Acc.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) (Dfinsupp.single.{u2, u1} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) i a)))
+Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.acc_single Dfinsupp.Lex.acc_singleₓ'. -/
 theorem Lex.acc_single [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)) i) :
     ∀ a, Acc (Dfinsupp.Lex r s) (single i a) :=
   by
@@ -158,28 +184,52 @@ theorem Lex.acc_single [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)
     · exact ih _ ⟨h, hij.symm⟩ _
 #align dfinsupp.lex.acc_single Dfinsupp.Lex.acc_single
 
+/- warning: dfinsupp.lex.acc -> Dfinsupp.Lex.acc is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [hz : forall (i : ι), Zero.{u2} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (hz i)))))) -> (forall (i : ι), WellFounded.{succ u2} (α i) (s i)) -> (forall [_inst_1 : DecidableEq.{succ u1} ι] [_inst_2 : forall (i : ι) (x : α i), Decidable (Ne.{succ u2} (α i) x (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (hz i)))))] (x : Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)), (forall (i : ι), (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) i (Dfinsupp.support.{u1, u2} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) (fun (i : ι) (x : α i) => _inst_2 i x) 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} ι)) i)) -> (Acc.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) x))
+but is expected to have type
+  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))) -> (forall (i : ι), WellFounded.{succ u1} (α i) (s i)) -> (forall [_inst_1 : DecidableEq.{succ u2} ι] [_inst_2 : forall (i : ι) (x : α i), Decidable (Ne.{succ u1} (α i) x (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))] (x : Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)), (forall (i : ι), (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i (Dfinsupp.support.{u2, u1} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => hz i) (fun (i : ι) (x : α i) => _inst_2 i x) 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.Dfinsupp.WellFounded._hyg.1795 : ι) (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1797 : ι) => Ne.{succ u2} ι x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1795 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1797)) i)) -> (Acc.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s) x))
+Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.acc Dfinsupp.Lex.accₓ'. -/
 theorem Lex.acc [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠ 0)] (x : Π₀ i, α i)
     (h : ∀ i ∈ x.support, Acc (rᶜ ⊓ (· ≠ ·)) i) : Acc (Dfinsupp.Lex r s) x :=
   Lex.acc_of_single hbot x fun i hi => Lex.acc_single hbot hs (h i hi) _
 #align dfinsupp.lex.acc Dfinsupp.Lex.acc
 
+/- warning: dfinsupp.lex.well_founded -> Dfinsupp.Lex.wellFounded is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [hz : forall (i : ι), Zero.{u2} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (hz i)))))) -> (forall (i : ι), WellFounded.{succ u2} (α i) (s i)) -> (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.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s))
+but is expected to have type
+  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))) -> (forall (i : ι), WellFounded.{succ u1} (α i) (s i)) -> (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.Dfinsupp.WellFounded._hyg.1897 : ι) (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1899 : ι) => Ne.{succ u2} ι x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1897 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.1899))) -> (WellFounded.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s))
+Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.well_founded Dfinsupp.Lex.wellFoundedₓ'. -/
 theorem Lex.wellFounded (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded (Dfinsupp.Lex r s) :=
   ⟨fun x => by classical exact lex.acc hbot hs x fun i _ => hr.apply i⟩
 #align dfinsupp.lex.well_founded Dfinsupp.Lex.wellFounded
 
-theorem Lex.well_founded' [IsTrichotomous ι r] (hr : WellFounded r.symm) :
+/- warning: dfinsupp.lex.well_founded' -> Dfinsupp.Lex.wellFounded' is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [hz : forall (i : ι), Zero.{u2} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (hz i)))))) -> (forall (i : ι), WellFounded.{succ u2} (α i) (s i)) -> (forall [_inst_1 : IsTrichotomous.{u1} ι r], (WellFounded.{succ u1} ι (Function.swap.{succ u1, succ u1, 1} ι ι (fun (ᾰ : ι) (ᾰ : ι) => Prop) r)) -> (WellFounded.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s)))
+but is expected to have type
+  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [hz : forall (i : ι), Zero.{u1} (α i)] {r : ι -> ι -> Prop} {s : forall (i : ι), (α i) -> (α i) -> Prop}, (forall {{i : ι}} {{a : α i}}, Not (s i a (OfNat.ofNat.{u1} (α i) 0 (Zero.toOfNat0.{u1} (α i) (hz i))))) -> (forall (i : ι), WellFounded.{succ u1} (α i) (s i)) -> (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)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => hz i) r s)))
+Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.well_founded' Dfinsupp.Lex.wellFounded'ₓ'. -/
+theorem Lex.wellFounded' [IsTrichotomous ι r] (hr : WellFounded r.symm) :
     WellFounded (Dfinsupp.Lex r s) :=
   Lex.wellFounded hbot hs <|
     Subrelation.wf
       (fun i j h => ((@IsTrichotomous.trichotomous ι r _ i j).resolve_left h.1).resolve_left h.2) hr
-#align dfinsupp.lex.well_founded' Dfinsupp.Lex.well_founded'
+#align dfinsupp.lex.well_founded' Dfinsupp.Lex.wellFounded'
 
 omit hz hbot hs
 
+/- warning: dfinsupp.lex.well_founded_lt -> Dfinsupp.Lex.wellFoundedLT is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LT.{u1} ι] [_inst_2 : IsTrichotomous.{u1} ι (LT.lt.{u1} ι _inst_1)] [hι : WellFoundedGT.{u1} ι _inst_1] [_inst_3 : forall (i : ι), CanonicallyOrderedAddMonoid.{u2} (α i)] [hα : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))))) (Dfinsupp.Lex.hasLt.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))) _inst_1 (fun (i : ι) => Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i))))))
+but is expected to have type
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LT.{u1} ι] [_inst_2 : IsTrichotomous.{u1} ι (fun (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2054 : ι) (x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2056 : ι) => LT.lt.{u1} ι _inst_1 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2054 x._@.Mathlib.Data.Dfinsupp.WellFounded._hyg.2056)] [hι : WellFoundedGT.{u1} ι _inst_1] [_inst_3 : forall (i : ι), CanonicallyOrderedAddMonoid.{u2} (α i)] [hα : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i)))))], WellFoundedLT.{max u2 u1} (Lex.{max u2 u1} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddMonoid.toZero.{u2} ((fun (i : ι) => α i) i) (AddCommMonoid.toAddMonoid.{u2} ((fun (i : ι) => α i) i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (_inst_3 i))))))) (Dfinsupp.instLTLexDfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddMonoid.toZero.{u2} ((fun (i : ι) => α i) i) (AddCommMonoid.toAddMonoid.{u2} ((fun (i : ι) => α i) i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (_inst_3 i))))) _inst_1 (fun (i : ι) => Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_3 i))))))
+Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.well_founded_lt Dfinsupp.Lex.wellFoundedLTₓ'. -/
 instance Lex.wellFoundedLT [LT ι] [IsTrichotomous ι (· < ·)] [hι : WellFoundedGT ι]
     [∀ i, CanonicallyOrderedAddMonoid (α i)] [hα : ∀ i, WellFoundedLT (α i)] :
     WellFoundedLT (Lex (Π₀ i, α i)) :=
-  ⟨Lex.well_founded' (fun i a => (zero_le a).not_lt) (fun i => (hα i).wf) hι.wf⟩
+  ⟨Lex.wellFounded' (fun i a => (zero_le a).not_lt) (fun i => (hα i).wf) hι.wf⟩
 #align dfinsupp.lex.well_founded_lt Dfinsupp.Lex.wellFoundedLT
 
 end Dfinsupp
@@ -188,6 +238,12 @@ open Dfinsupp
 
 variable (r : ι → ι → Prop) {s : ∀ i, α i → α i → Prop}
 
+/- warning: pi.lex.well_founded -> Pi.Lex.wellFounded is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} (r : ι -> ι -> Prop) {s : forall (i : ι), (α i) -> (α i) -> Prop} [_inst_1 : IsStrictTotalOrder.{u1} ι r] [_inst_2 : Finite.{succ u1} ι], (forall (i : ι), WellFounded.{succ u2} (α i) (s i)) -> (WellFounded.{max (succ u1) (succ u2)} (forall (i : ι), α i) (Pi.Lex.{u1, u2} ι (fun (i : ι) => α i) r s))
+but is expected to have type
+  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} (r : ι -> ι -> Prop) {s : forall (i : ι), (α i) -> (α i) -> Prop} [_inst_1 : IsStrictTotalOrder.{u2} ι r] [_inst_2 : Finite.{succ u2} ι], (forall (i : ι), WellFounded.{succ u1} (α i) (s i)) -> (WellFounded.{max (succ u1) (succ u2)} (forall (i : ι), α i) (Pi.Lex.{u2, u1} ι (fun {i : ι} => α i) r (fun {i : ι} => s i)))
+Case conversion may be inaccurate. Consider using '#align pi.lex.well_founded Pi.Lex.wellFoundedₓ'. -/
 theorem Pi.Lex.wellFounded [IsStrictTotalOrder ι r] [Finite ι] (hs : ∀ i, WellFounded (s i)) :
     WellFounded (Pi.Lex r s) :=
   by
@@ -201,27 +257,49 @@ theorem Pi.Lex.wellFounded [IsStrictTotalOrder ι r] [Finite ι] (hs : ∀ i, We
   exacts[(hs i).not_lt_min ⊤ _ trivial, Finite.wellFounded_of_trans_of_irrefl r.swap]
 #align pi.lex.well_founded Pi.Lex.wellFounded
 
+#print Pi.Lex.wellFoundedLT /-
 instance Pi.Lex.wellFoundedLT [LinearOrder ι] [Finite ι] [∀ i, LT (α i)]
     [hwf : ∀ i, WellFoundedLT (α i)] : WellFoundedLT (Lex (∀ i, α i)) :=
   ⟨Pi.Lex.wellFounded (· < ·) fun i => (hwf i).1⟩
 #align pi.lex.well_founded_lt Pi.Lex.wellFoundedLT
+-/
 
+#print Function.Lex.wellFoundedLT /-
 instance Function.Lex.wellFoundedLT {α} [LinearOrder ι] [Finite ι] [LT α] [WellFoundedLT α] :
     WellFoundedLT (Lex (ι → α)) :=
   Pi.Lex.wellFoundedLT
 #align function.lex.well_founded_lt Function.Lex.wellFoundedLT
+-/
 
+/- warning: dfinsupp.lex.well_founded_of_finite -> Dfinsupp.Lex.wellFounded_of_finite is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} (r : ι -> ι -> Prop) {s : forall (i : ι), (α i) -> (α i) -> Prop} [_inst_1 : IsStrictTotalOrder.{u1} ι r] [_inst_2 : Finite.{succ u1} ι] [_inst_3 : forall (i : ι), Zero.{u2} (α i)], (forall (i : ι), WellFounded.{succ u2} (α i) (s i)) -> (WellFounded.{succ (max u1 u2)} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i)) (Dfinsupp.Lex.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i) r s))
+but is expected to have type
+  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} (r : ι -> ι -> Prop) {s : forall (i : ι), (α i) -> (α i) -> Prop} [_inst_1 : IsStrictTotalOrder.{u2} ι r] [_inst_2 : Finite.{succ u2} ι] [_inst_3 : forall (i : ι), Zero.{u1} (α i)], (forall (i : ι), WellFounded.{succ u1} (α i) (s i)) -> (WellFounded.{max (succ u1) (succ u2)} (Dfinsupp.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i)) (Dfinsupp.Lex.{u2, u1} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i) r s))
+Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.well_founded_of_finite Dfinsupp.Lex.wellFounded_of_finiteₓ'. -/
 theorem Dfinsupp.Lex.wellFounded_of_finite [IsStrictTotalOrder ι r] [Finite ι] [∀ i, Zero (α i)]
     (hs : ∀ i, WellFounded (s i)) : WellFounded (Dfinsupp.Lex r s) :=
   have := Fintype.ofFinite ι
   InvImage.wf equiv_fun_on_fintype (Pi.Lex.wellFounded r hs)
 #align dfinsupp.lex.well_founded_of_finite Dfinsupp.Lex.wellFounded_of_finite
 
+/- warning: dfinsupp.lex.well_founded_lt_of_finite -> Dfinsupp.Lex.wellFoundedLT_of_finite is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : Finite.{succ u1} ι] [_inst_3 : forall (i : ι), Zero.{u2} (α i)] [_inst_4 : forall (i : ι), LT.{u2} (α i)] [hwf : forall (i : ι), WellFoundedLT.{u2} (α i) (_inst_4 i)], WellFoundedLT.{max u1 u2} (Lex.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i))) (Dfinsupp.Lex.hasLt.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))) (fun (i : ι) => _inst_4 i))
+but is expected to have type
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : Finite.{succ u1} ι] [_inst_3 : forall (i : ι), Zero.{u2} (α i)] [_inst_4 : forall (i : ι), LT.{u2} (α i)] [hwf : forall (i : ι), WellFoundedLT.{u2} (α i) (_inst_4 i)], WellFoundedLT.{max u2 u1} (Lex.{max u2 u1} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i))) (Dfinsupp.instLTLexDfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_3 i) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (DistribLattice.toLattice.{u1} ι (instDistribLattice.{u1} ι _inst_1)))))) (fun (i : ι) => _inst_4 i))
+Case conversion may be inaccurate. Consider using '#align dfinsupp.lex.well_founded_lt_of_finite Dfinsupp.Lex.wellFoundedLT_of_finiteₓ'. -/
 instance Dfinsupp.Lex.wellFoundedLT_of_finite [LinearOrder ι] [Finite ι] [∀ i, Zero (α i)]
     [∀ i, LT (α i)] [hwf : ∀ i, WellFoundedLT (α i)] : WellFoundedLT (Lex (Π₀ i, α i)) :=
   ⟨Dfinsupp.Lex.wellFounded_of_finite (· < ·) fun i => (hwf i).1⟩
 #align dfinsupp.lex.well_founded_lt_of_finite Dfinsupp.Lex.wellFoundedLT_of_finite
 
+/- warning: dfinsupp.well_founded_lt -> Dfinsupp.wellFoundedLT is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : forall (i : ι), Zero.{u2} (α i)] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i))], (forall {{i : ι}} {{a : α i}}, Not (LT.lt.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i)) a (OfNat.ofNat.{u2} (α i) 0 (OfNat.mk.{u2} (α i) 0 (Zero.zero.{u2} (α i) (_inst_1 i)))))) -> (WellFoundedLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i)) (Preorder.toLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i)) (Dfinsupp.preorder.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i) (fun (i : ι) => _inst_2 i))))
+but is expected to have type
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : forall (i : ι), Zero.{u2} (α i)] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i))], (forall {{i : ι}} {{a : α i}}, Not (LT.lt.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i)) a (OfNat.ofNat.{u2} (α i) 0 (Zero.toOfNat0.{u2} (α i) (_inst_1 i))))) -> (WellFoundedLT.{max u2 u1} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i)) (Preorder.toLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i)) (Dfinsupp.instPreorderDfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_1 i) (fun (i : ι) => _inst_2 i))))
+Case conversion may be inaccurate. Consider using '#align dfinsupp.well_founded_lt Dfinsupp.wellFoundedLTₓ'. -/
 protected theorem Dfinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (α i)]
     [∀ i, WellFoundedLT (α i)] (hbot : ∀ ⦃i⦄ ⦃a : α i⦄, ¬a < 0) : WellFoundedLT (Π₀ i, α i) :=
   ⟨by
@@ -237,11 +315,18 @@ protected theorem Dfinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (
     exacts[IsWellFounded.wf, IsTrichotomous.swap _, IsWellFounded.wf]⟩
 #align dfinsupp.well_founded_lt Dfinsupp.wellFoundedLT
 
+/- warning: dfinsupp.well_founded_lt' -> Dfinsupp.well_founded_lt' is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : forall (i : ι), CanonicallyOrderedAddMonoid.{u2} (α i)] [_inst_2 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i)))))], WellFoundedLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i))))))) (Preorder.toLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i))))))) (Dfinsupp.preorder.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddZeroClass.toHasZero.{u2} (α i) (AddMonoid.toAddZeroClass.{u2} (α i) (AddCommMonoid.toAddMonoid.{u2} (α i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i)))))) (fun (i : ι) => PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i))))))
+but is expected to have type
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : forall (i : ι), CanonicallyOrderedAddMonoid.{u2} (α i)] [_inst_2 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i)))))], WellFoundedLT.{max u2 u1} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddMonoid.toZero.{u2} ((fun (i : ι) => α i) i) (AddCommMonoid.toAddMonoid.{u2} ((fun (i : ι) => α i) i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (_inst_1 i)))))) (Preorder.toLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddMonoid.toZero.{u2} ((fun (i : ι) => α i) i) (AddCommMonoid.toAddMonoid.{u2} ((fun (i : ι) => α i) i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (_inst_1 i)))))) (Dfinsupp.instPreorderDfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => AddMonoid.toZero.{u2} ((fun (i : ι) => α i) i) (AddCommMonoid.toAddMonoid.{u2} ((fun (i : ι) => α i) i) (OrderedAddCommMonoid.toAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} ((fun (i : ι) => α i) i) (_inst_1 i))))) (fun (i : ι) => PartialOrder.toPreorder.{u2} (α i) (OrderedAddCommMonoid.toPartialOrder.{u2} (α i) (CanonicallyOrderedAddMonoid.toOrderedAddCommMonoid.{u2} (α i) (_inst_1 i))))))
+Case conversion may be inaccurate. Consider using '#align dfinsupp.well_founded_lt' Dfinsupp.well_founded_lt'ₓ'. -/
 instance Dfinsupp.well_founded_lt' [∀ i, CanonicallyOrderedAddMonoid (α i)]
     [∀ i, WellFoundedLT (α i)] : WellFoundedLT (Π₀ i, α i) :=
   Dfinsupp.wellFoundedLT fun i a => (zero_le a).not_lt
 #align dfinsupp.well_founded_lt' Dfinsupp.well_founded_lt'
 
+#print Pi.wellFoundedLT /-
 instance Pi.wellFoundedLT [Finite ι] [∀ i, Preorder (α i)] [hw : ∀ i, WellFoundedLT (α i)] :
     WellFoundedLT (∀ i, α i) :=
   ⟨by
@@ -254,12 +339,21 @@ instance Pi.wellFoundedLT [Finite ι] [∀ i, Preorder (α i)] [hw : ∀ i, Well
     refine' InvImage.wf equiv_fun_on_fintype.symm (Dfinsupp.wellFoundedLT fun i a => _).wf
     exact (hw i).wf.not_lt_min ⊤ _ trivial⟩
 #align pi.well_founded_lt Pi.wellFoundedLT
+-/
 
+#print Function.wellFoundedLT /-
 instance Function.wellFoundedLT {α} [Finite ι] [Preorder α] [WellFoundedLT α] :
     WellFoundedLT (ι → α) :=
   Pi.wellFoundedLT
 #align function.well_founded_lt Function.wellFoundedLT
+-/
 
+/- warning: dfinsupp.well_founded_lt_of_finite -> Dfinsupp.wellFoundedLT_of_finite is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Finite.{succ u1} ι] [_inst_2 : forall (i : ι), Zero.{u2} (α i)] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_3 i))], WellFoundedLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i)) (Preorder.toLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i)) (Dfinsupp.preorder.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i) (fun (i : ι) => _inst_3 i)))
+but is expected to have type
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Finite.{succ u1} ι] [_inst_2 : forall (i : ι), Zero.{u2} (α i)] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : forall (i : ι), WellFoundedLT.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_3 i))], WellFoundedLT.{max u2 u1} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i)) (Preorder.toLT.{max u1 u2} (Dfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i)) (Dfinsupp.instPreorderDfinsupp.{u1, u2} ι (fun (i : ι) => α i) (fun (i : ι) => _inst_2 i) (fun (i : ι) => _inst_3 i)))
+Case conversion may be inaccurate. Consider using '#align dfinsupp.well_founded_lt_of_finite Dfinsupp.wellFoundedLT_of_finiteₓ'. -/
 instance Dfinsupp.wellFoundedLT_of_finite [Finite ι] [∀ i, Zero (α i)] [∀ i, Preorder (α i)]
     [∀ i, WellFoundedLT (α i)] : WellFoundedLT (Π₀ i, α i) :=
   have := Fintype.ofFinite ι

e9b8651e

bump to nightly-2023-03-17-00

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

c85864d4

Diff

@@ -103,7 +103,7 @@ theorem Lex.acc_of_single_erase [DecidableEq ι] {x : Π₀ i, α i} (i : ι)
     (hs : Acc (Dfinsupp.Lex r s) <| single i (x i)) (hu : Acc (Dfinsupp.Lex r s) <| x.eraseₓ i) :
     Acc (Dfinsupp.Lex r s) x := by
   classical
-    convert ←
+    convert←
       @Acc.of_fibration _ _ _ _ _ (lex_fibration r s) ⟨{i}, _⟩
         (InvImage.accessible snd <| hs.prod_game_add hu)
     convert piecewise_single_erase x i

e9b8651e

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

e9b8651e

chore: work around simp issues in future nightlies (#11546)

8a8d3883

Diff

@@ -224,7 +224,9 @@ protected theorem DFinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (
       refine Lex.wellFounded' ?_ (fun i ↦ IsWellFounded.wf) ?_
       · rintro i ⟨a⟩
         apply hbot
-      · simp (config := { unfoldPartialApp := true }) only [Function.swap]
+      · -- Adaptation note: nightly-2024-03-16: simp was
+        -- simp (config := { unfoldPartialApp := true }) only [Function.swap]
+        simp only [Function.swap_def]
         exact IsWellFounded.wf
     refine Subrelation.wf (fun h => ?_) <| InvImage.wf (mapRange (fun i ↦ e i) fun _ ↦ rfl) this
     have := IsStrictOrder.swap (@WellOrderingRel ι)

e9b8651e

chore: remove stream-of-consciousness uses of have, replace and suffices (#10640)

No changes to tactic file, it's just boring fixes throughout the library.

This follows on from #6964.

Co-authored-by: sgouezel <sebastien.gouezel@univ-rennes1.fr> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

a13e8040

Diff

@@ -219,8 +219,8 @@ protected theorem DFinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (
     set e : (i : ι) → α i → β i := fun i ↦ toAntisymmetrization (· ≤ ·)
     let _ : ∀ i, Zero (β i) := fun i ↦ ⟨e i 0⟩
     have : WellFounded (DFinsupp.Lex (Function.swap <| @WellOrderingRel ι)
-      (fun _ ↦ (· < ·) : (i : ι) → β i → β i → Prop))
-    · have := IsTrichotomous.swap (@WellOrderingRel ι)
+        (fun _ ↦ (· < ·) : (i : ι) → β i → β i → Prop)) := by
+      have := IsTrichotomous.swap (@WellOrderingRel ι)
       refine Lex.wellFounded' ?_ (fun i ↦ IsWellFounded.wf) ?_
       · rintro i ⟨a⟩
         apply hbot

e9b8651e

chore: add missing hypothesis names to by_cases (#8533)

I've also got a change to make this required, but I'd like to land this first.

2009db69

Diff

@@ -146,7 +146,7 @@ theorem Lex.acc_single [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)
     refine Lex.acc_of_single hbot x fun j hj ↦ ?_
     obtain rfl | hij := eq_or_ne i j
     · exact ha _ hs
-    by_cases r j i
+    by_cases h : r j i
     · rw [hr j h, single_eq_of_ne hij, single_zero]
       exact Lex.acc_zero hbot
     · exact ih _ ⟨h, hij.symm⟩ _

e9b8651e

chore: bump to v4.3.0-rc2 (#8366)

PR contents

This is the supremum of

#8284
#8056
#8023
#8332
#8226 (already approved)
#7834 (already approved)

along with some minor fixes from failures on nightly-testing as Mathlib master is merged into it.

Note that some PRs for changes that are already compatible with the current toolchain and will be necessary have already been split out: #8380.

I am hopeful that in future we will be able to progressively merge adaptation PRs into a bump/v4.X.0 branch, so we never end up with a "big merge" like this. However one of these adaptation PRs (#8056) predates my new scheme for combined CI, and it wasn't possible to keep that PR viable in the meantime.

Lean PRs involved in this bump

In particular this includes adjustments for the Lean PRs

leanprover/lean4#2778

We can get rid of all the

local macro_rules | `($x ^ $y) => `(HPow.hPow $x $y) -- Porting note: See issue [lean4#2220](https://github.com/leanprover/lean4/pull/2220)

macros across Mathlib (and in any projects that want to write natural number powers of reals).

leanprover/lean4#2722

Changes the default behaviour of simp to (config := {decide := false}). This makes simp (and consequentially norm_num) less powerful, but also more consistent, and less likely to blow up in long failures. This requires a variety of changes: changing some previously by simp or norm_num to decide or rfl, or adding (config := {decide := true}).

leanprover/lean4#2783

This changed the behaviour of simp so that simp [f] will only unfold "fully applied" occurrences of f. The old behaviour can be recovered with simp (config := { unfoldPartialApp := true }). We may in future add a syntax for this, e.g. simp [!f]; please provide feedback! In the meantime, we have made the following changes:

switching to using explicit lemmas that have the intended level of application
(config := { unfoldPartialApp := true }) in some places, to recover the old behaviour
Using @[eqns] to manually adjust the equation lemmas for a particular definition, recovering the old behaviour just for that definition. See #8371, where we do this for Function.comp and Function.flip.

This change in Lean may require further changes down the line (e.g. adding the !f syntax, and/or upstreaming the special treatment for Function.comp and Function.flip, and/or removing this special treatment). Please keep an open and skeptical mind about these changes!

Co-authored-by: leanprover-community-mathlib4-bot <leanprover-community-mathlib4-bot@users.noreply.github.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Mauricio Collares <mauricio@collares.org>

40b64f79

Diff

@@ -224,7 +224,7 @@ protected theorem DFinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (
       refine Lex.wellFounded' ?_ (fun i ↦ IsWellFounded.wf) ?_
       · rintro i ⟨a⟩
         apply hbot
-      · simp only [Function.swap]
+      · simp (config := { unfoldPartialApp := true }) only [Function.swap]
         exact IsWellFounded.wf
     refine Subrelation.wf (fun h => ?_) <| InvImage.wf (mapRange (fun i ↦ e i) fun _ ↦ rfl) this
     have := IsStrictOrder.swap (@WellOrderingRel ι)

e9b8651e

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

Renames:

CanonicallyOrderedMonoid -> CanonicallyOrderedCommMonoid

CanonicallyOrderedAddMonoid -> CanonicallyOrderedAddCommMonoid

CanonicallyLinearOrderedMonoid -> CanonicallyLinearOrderedCommMonoid

CanonicallyLinearOrderedAddMonoid -> CanonicallyLinearOrderedAddCommMonoid

f3bc24c3

Diff

@@ -170,7 +170,7 @@ theorem Lex.wellFounded' [IsTrichotomous ι r] (hr : WellFounded (Function.swap
 end Zero
 
 instance Lex.wellFoundedLT [LT ι] [IsTrichotomous ι (· < ·)] [hι : WellFoundedGT ι]
-    [∀ i, CanonicallyOrderedAddMonoid (α i)] [hα : ∀ i, WellFoundedLT (α i)] :
+    [∀ i, CanonicallyOrderedAddCommMonoid (α i)] [hα : ∀ i, WellFoundedLT (α i)] :
     WellFoundedLT (Lex (Π₀ i, α i)) :=
   ⟨Lex.wellFounded' (fun _ a => (zero_le a).not_lt) (fun i => (hα i).wf) hι.wf⟩
 #align dfinsupp.lex.well_founded_lt DFinsupp.Lex.wellFoundedLT
@@ -232,7 +232,7 @@ protected theorem DFinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (
     exact ⟨i, fun j hj ↦ Quot.sound (he j hj), hl⟩⟩
 #align dfinsupp.well_founded_lt DFinsupp.wellFoundedLT
 
-instance DFinsupp.wellFoundedLT' [∀ i, CanonicallyOrderedAddMonoid (α i)]
+instance DFinsupp.wellFoundedLT' [∀ i, CanonicallyOrderedAddCommMonoid (α i)]
     [∀ i, WellFoundedLT (α i)] : WellFoundedLT (Π₀ i, α i) :=
   DFinsupp.wellFoundedLT fun _i a => (zero_le a).not_lt
 #align dfinsupp.well_founded_lt' DFinsupp.wellFoundedLT'

e9b8651e

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

@@ -47,7 +47,7 @@ to be well-founded.
 -/
 
 
-variable {ι : Type _} {α : ι → Type _}
+variable {ι : Type*} {α : ι → Type*}
 
 namespace DFinsupp

e9b8651e

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 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.dfinsupp.well_founded
-! leanprover-community/mathlib commit e9b8651eb1ad354f4de6be35a38ef31efcd2cfaa
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.DFinsupp.Lex
 import Mathlib.Order.GameAdd
 import Mathlib.Order.Antisymmetrization
 import Mathlib.SetTheory.Ordinal.Basic
 
+#align_import data.dfinsupp.well_founded from "leanprover-community/mathlib"@"e9b8651eb1ad354f4de6be35a38ef31efcd2cfaa"
+
 /-!
 # Well-foundedness of the lexicographic and product orders on `DFinsupp` and `Pi`

e9b8651e

feat: missing WellFoundedLT instances (#5899)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

1c8e7900

Diff

@@ -235,10 +235,10 @@ protected theorem DFinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (
     exact ⟨i, fun j hj ↦ Quot.sound (he j hj), hl⟩⟩
 #align dfinsupp.well_founded_lt DFinsupp.wellFoundedLT
 
-instance DFinsupp.well_founded_lt' [∀ i, CanonicallyOrderedAddMonoid (α i)]
+instance DFinsupp.wellFoundedLT' [∀ i, CanonicallyOrderedAddMonoid (α i)]
     [∀ i, WellFoundedLT (α i)] : WellFoundedLT (Π₀ i, α i) :=
   DFinsupp.wellFoundedLT fun _i a => (zero_le a).not_lt
-#align dfinsupp.well_founded_lt' DFinsupp.well_founded_lt'
+#align dfinsupp.well_founded_lt' DFinsupp.wellFoundedLT'
 
 instance Pi.wellFoundedLT [Finite ι] [∀ i, Preorder (α i)] [hw : ∀ i, WellFoundedLT (α i)] :
     WellFoundedLT (∀ i, α i) :=
@@ -261,4 +261,3 @@ instance DFinsupp.wellFoundedLT_of_finite [Finite ι] [∀ i, Zero (α i)] [∀
   have := Fintype.ofFinite ι
   ⟨InvImage.wf equivFunOnFintype Pi.wellFoundedLT.wf⟩
 #align dfinsupp.well_founded_lt_of_finite DFinsupp.wellFoundedLT_of_finite
-

e9b8651e

chore: rename Dfinsupp to DFinsupp (#5822)

See #4354

268b7d43

Diff

@@ -8,15 +8,15 @@ 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.Lex
+import Mathlib.Data.DFinsupp.Lex
 import Mathlib.Order.GameAdd
 import Mathlib.Order.Antisymmetrization
 import Mathlib.SetTheory.Ordinal.Basic
 
 /-!
-# Well-foundedness of the lexicographic and product orders on `Dfinsupp` and `Pi`
+# Well-foundedness of the lexicographic and product orders on `DFinsupp` and `Pi`
 
-The primary results are `Dfinsupp.Lex.wellFounded` and the two variants that follow it,
+The primary results are `DFinsupp.Lex.wellFounded` and the two variants that follow it,
 which essentially say that if `(· > ·)` is a well order on `ι`, `(· < ·)` is well-founded on each
 `α i`, and `0` is a bottom element in `α i`, then the lexicographic `(· < ·)` is well-founded
 on `Π₀ i, α i`. The proof is modelled on the proof of `WellFounded.cutExpand`.
@@ -24,11 +24,11 @@ on `Π₀ i, α i`. The proof is modelled on the proof of `WellFounded.cutExpand
 The results are used to prove `Pi.Lex.wellFounded` and two variants, which say that if
 `ι` is finite and equipped with a linear order and `(· < ·)` is well-founded on each `α i`,
 then the lexicographic `(· < ·)` is well-founded on `Π i, α i`, and the same is true for
-`Π₀ i, α i` (`Dfinsupp.Lex.wellFounded_of_finite`), because `Dfinsupp` is order-isomorphic
+`Π₀ i, α i` (`DFinsupp.Lex.wellFounded_of_finite`), because `DFinsupp` is order-isomorphic
 to `pi` when `ι` is finite.
 
-Finally, we deduce `Dfinsupp.wellFoundedLT`, `Pi.wellFoundedLT`,
-`Dfinsupp.wellFoundedLT_of_finite` and variants, which concern the product order
+Finally, we deduce `DFinsupp.wellFoundedLT`, `Pi.wellFoundedLT`,
+`DFinsupp.wellFoundedLT_of_finite` and variants, which concern the product order
 rather than the lexicographic one. An order on `ι` is not required in these results,
 but we deduce them from the well-foundedness of the lexicographic order by choosing
 a well order on `ι` so that the product order `(· < ·)` becomes a subrelation
@@ -39,7 +39,7 @@ can be arbitrary (not the `(· < ·)` of a preorder, or not even transitive, etc
 form provided as `WellFoundedLT` instances where the `(d)Finsupp/pi` type (or their `Lex`
 type synonyms) carries a natural `(· < ·)`.
 
-Notice that the definition of `Dfinsupp.Lex` says that `x < y` according to `Dfinsupp.Lex r s`
+Notice that the definition of `DFinsupp.Lex` says that `x < y` according to `DFinsupp.Lex r s`
 iff there exists a coordinate `i : ι` such that `x i < y i` according to `s i`, and at all
 `r`-smaller coordinates `j` (i.e. satisfying `r j i`), `x` remains unchanged relative to `y`;
 in other words, coordinates `j` such that `¬ r j i` and `j ≠ i` are exactly where changes
@@ -52,7 +52,7 @@ to be well-founded.
 
 variable {ι : Type _} {α : ι → Type _}
 
-namespace Dfinsupp
+namespace DFinsupp
 
 open Relation Prod
 
@@ -61,15 +61,15 @@ section Zero
 variable [∀ i, Zero (α i)] (r : ι → ι → Prop) (s : ∀ i, α i → α i → Prop)
 
 /-- This key lemma says that if a finitely supported dependent function `x₀` is obtained by merging
-  two such functions `x₁` and `x₂`, and if we evolve `x₀` down the `Dfinsupp.Lex` relation one
-  step and get `x`, we can always evolve one of `x₁` and `x₂` down the `Dfinsupp.Lex` relation
+  two such functions `x₁` and `x₂`, and if we evolve `x₀` down the `DFinsupp.Lex` relation one
+  step and get `x`, we can always evolve one of `x₁` and `x₂` down the `DFinsupp.Lex` relation
   one step while keeping the other unchanged, and merge them back (possibly in a different way)
   to get back `x`. In other words, the two parts evolve essentially independently under
-  `Dfinsupp.Lex`. This is used to show that a function `x` is accessible if
-  `Dfinsupp.single i (x i)` is accessible for each `i` in the (finite) support of `x`
-  (`Dfinsupp.Lex.acc_of_single`). -/
+  `DFinsupp.Lex`. This is used to show that a function `x` is accessible if
+  `DFinsupp.single i (x i)` is accessible for each `i` in the (finite) support of `x`
+  (`DFinsupp.Lex.acc_of_single`). -/
 theorem lex_fibration [∀ (i) (s : Set ι), Decidable (i ∈ s)] :
-    Fibration (InvImage (GameAdd (Dfinsupp.Lex r s) (Dfinsupp.Lex r s)) snd) (Dfinsupp.Lex r s)
+    Fibration (InvImage (GameAdd (DFinsupp.Lex r s) (DFinsupp.Lex r s)) snd) (DFinsupp.Lex r s)
       fun x => piecewise x.2.1 x.2.2 x.1 := by
   rintro ⟨p, x₁, x₂⟩ x ⟨i, hr, hs⟩
   simp_rw [piecewise_apply] at hs hr
@@ -98,27 +98,27 @@ theorem lex_fibration [∀ (i) (s : Set ι), Decidable (i ∈ s)] :
       · rw [hr j h₁.1, if_pos h₁.2]
       · rw [hr j h₂, if_neg]
         simpa [h₂] using h₁
-#align dfinsupp.lex_fibration Dfinsupp.lex_fibration
+#align dfinsupp.lex_fibration DFinsupp.lex_fibration
 
 variable {r s}
 
 theorem Lex.acc_of_single_erase [DecidableEq ι] {x : Π₀ i, α i} (i : ι)
-    (hs : Acc (Dfinsupp.Lex r s) <| single i (x i)) (hu : Acc (Dfinsupp.Lex r s) <| x.erase i) :
-    Acc (Dfinsupp.Lex r s) x := by
+    (hs : Acc (DFinsupp.Lex r s) <| single i (x i)) (hu : Acc (DFinsupp.Lex r s) <| x.erase i) :
+    Acc (DFinsupp.Lex r s) x := by
   classical
     convert ← @Acc.of_fibration _ _ _ _ _ (lex_fibration r s) ⟨{i}, _⟩
       (InvImage.accessible snd <| hs.prod_gameAdd hu)
     convert piecewise_single_erase x i
-#align dfinsupp.lex.acc_of_single_erase Dfinsupp.Lex.acc_of_single_erase
+#align dfinsupp.lex.acc_of_single_erase DFinsupp.Lex.acc_of_single_erase
 
 variable (hbot : ∀ ⦃i a⦄, ¬s i a 0)
 
-theorem Lex.acc_zero : Acc (Dfinsupp.Lex r s) 0 :=
+theorem Lex.acc_zero : Acc (DFinsupp.Lex r s) 0 :=
   Acc.intro 0 fun _ ⟨_, _, h⟩ => (hbot h).elim
-#align dfinsupp.lex.acc_zero Dfinsupp.Lex.acc_zero
+#align dfinsupp.lex.acc_zero DFinsupp.Lex.acc_zero
 
 theorem Lex.acc_of_single [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠ 0)] (x : Π₀ i, α i) :
-    (∀ i ∈ x.support, Acc (Dfinsupp.Lex r s) <| single i (x i)) → Acc (Dfinsupp.Lex r s) x := by
+    (∀ i ∈ x.support, Acc (DFinsupp.Lex r s) <| single i (x i)) → Acc (DFinsupp.Lex r s) x := by
   generalize ht : x.support = t; revert x
   classical
     induction' t using Finset.induction with b t hb ih
@@ -129,15 +129,15 @@ theorem Lex.acc_of_single [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠
     refine' ih _ (by rw [support_erase, ht, Finset.erase_insert hb]) fun a ha => _
     rw [erase_ne (ha.ne_of_not_mem hb)]
     exact h a (Finset.mem_insert_of_mem ha)
-#align dfinsupp.lex.acc_of_single Dfinsupp.Lex.acc_of_single
+#align dfinsupp.lex.acc_of_single DFinsupp.Lex.acc_of_single
 
 variable (hs : ∀ i, WellFounded (s i))
 
 theorem Lex.acc_single [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)) i) :
-    ∀ a, Acc (Dfinsupp.Lex r s) (single i a) := by
+    ∀ a, Acc (DFinsupp.Lex r s) (single i a) := by
   induction' hi with i _ ih
   refine fun a => WellFounded.induction (hs i)
-    (C := fun x ↦ Acc (Dfinsupp.Lex r s) (single i x)) a fun a ha ↦ ?_
+    (C := fun x ↦ Acc (DFinsupp.Lex r s) (single i x)) a fun a ha ↦ ?_
   refine Acc.intro _ fun x ↦ ?_
   rintro ⟨k, hr, hs⟩
   rw [single_apply] at hs
@@ -153,22 +153,22 @@ theorem Lex.acc_single [DecidableEq ι] {i : ι} (hi : Acc (rᶜ ⊓ (· ≠ ·)
     · rw [hr j h, single_eq_of_ne hij, single_zero]
       exact Lex.acc_zero hbot
     · exact ih _ ⟨h, hij.symm⟩ _
-#align dfinsupp.lex.acc_single Dfinsupp.Lex.acc_single
+#align dfinsupp.lex.acc_single DFinsupp.Lex.acc_single
 
 theorem Lex.acc [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠ 0)] (x : Π₀ i, α i)
-    (h : ∀ i ∈ x.support, Acc (rᶜ ⊓ (· ≠ ·)) i) : Acc (Dfinsupp.Lex r s) x :=
+    (h : ∀ i ∈ x.support, Acc (rᶜ ⊓ (· ≠ ·)) i) : Acc (DFinsupp.Lex r s) x :=
   Lex.acc_of_single hbot x fun i hi => Lex.acc_single hbot hs (h i hi) _
-#align dfinsupp.lex.acc Dfinsupp.Lex.acc
+#align dfinsupp.lex.acc DFinsupp.Lex.acc
 
-theorem Lex.wellFounded (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded (Dfinsupp.Lex r s) :=
+theorem Lex.wellFounded (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded (DFinsupp.Lex r s) :=
   ⟨fun x => by classical exact Lex.acc hbot hs x fun i _ => hr.apply i⟩
-#align dfinsupp.lex.well_founded Dfinsupp.Lex.wellFounded
+#align dfinsupp.lex.well_founded DFinsupp.Lex.wellFounded
 
 theorem Lex.wellFounded' [IsTrichotomous ι r] (hr : WellFounded (Function.swap r)) :
-    WellFounded (Dfinsupp.Lex r s) :=
+    WellFounded (DFinsupp.Lex r s) :=
   Lex.wellFounded hbot hs <| Subrelation.wf
    (fun {i j} h => ((@IsTrichotomous.trichotomous ι r _ i j).resolve_left h.1).resolve_left h.2) hr
-#align dfinsupp.lex.well_founded' Dfinsupp.Lex.wellFounded'
+#align dfinsupp.lex.well_founded' DFinsupp.Lex.wellFounded'
 
 end Zero
 
@@ -176,11 +176,11 @@ instance Lex.wellFoundedLT [LT ι] [IsTrichotomous ι (· < ·)] [hι : WellFoun
     [∀ i, CanonicallyOrderedAddMonoid (α i)] [hα : ∀ i, WellFoundedLT (α i)] :
     WellFoundedLT (Lex (Π₀ i, α i)) :=
   ⟨Lex.wellFounded' (fun _ a => (zero_le a).not_lt) (fun i => (hα i).wf) hι.wf⟩
-#align dfinsupp.lex.well_founded_lt Dfinsupp.Lex.wellFoundedLT
+#align dfinsupp.lex.well_founded_lt DFinsupp.Lex.wellFoundedLT
 
-end Dfinsupp
+end DFinsupp
 
-open Dfinsupp
+open DFinsupp
 
 variable (r : ι → ι → Prop) {s : ∀ i, α i → α i → Prop}
 
@@ -204,24 +204,24 @@ instance Function.Lex.wellFoundedLT {α} [LinearOrder ι] [Finite ι] [LT α] [W
   Pi.Lex.wellFoundedLT
 #align function.lex.well_founded_lt Function.Lex.wellFoundedLT
 
-theorem Dfinsupp.Lex.wellFounded_of_finite [IsStrictTotalOrder ι r] [Finite ι] [∀ i, Zero (α i)]
-    (hs : ∀ i, WellFounded (s i)) : WellFounded (Dfinsupp.Lex r s) :=
+theorem DFinsupp.Lex.wellFounded_of_finite [IsStrictTotalOrder ι r] [Finite ι] [∀ i, Zero (α i)]
+    (hs : ∀ i, WellFounded (s i)) : WellFounded (DFinsupp.Lex r s) :=
   have := Fintype.ofFinite ι
   InvImage.wf equivFunOnFintype (Pi.Lex.wellFounded r hs)
-#align dfinsupp.lex.well_founded_of_finite Dfinsupp.Lex.wellFounded_of_finite
+#align dfinsupp.lex.well_founded_of_finite DFinsupp.Lex.wellFounded_of_finite
 
-instance Dfinsupp.Lex.wellFoundedLT_of_finite [LinearOrder ι] [Finite ι] [∀ i, Zero (α i)]
+instance DFinsupp.Lex.wellFoundedLT_of_finite [LinearOrder ι] [Finite ι] [∀ i, Zero (α i)]
     [∀ i, LT (α i)] [hwf : ∀ i, WellFoundedLT (α i)] : WellFoundedLT (Lex (Π₀ i, α i)) :=
-  ⟨Dfinsupp.Lex.wellFounded_of_finite (· < ·) fun i => (hwf i).1⟩
-#align dfinsupp.lex.well_founded_lt_of_finite Dfinsupp.Lex.wellFoundedLT_of_finite
+  ⟨DFinsupp.Lex.wellFounded_of_finite (· < ·) fun i => (hwf i).1⟩
+#align dfinsupp.lex.well_founded_lt_of_finite DFinsupp.Lex.wellFoundedLT_of_finite
 
-protected theorem Dfinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (α i)]
+protected theorem DFinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (α i)]
     [∀ i, WellFoundedLT (α i)] (hbot : ∀ ⦃i⦄ ⦃a : α i⦄, ¬a < 0) : WellFoundedLT (Π₀ i, α i) :=
   ⟨by
     set β := fun i ↦ Antisymmetrization (α i) (· ≤ ·)
     set e : (i : ι) → α i → β i := fun i ↦ toAntisymmetrization (· ≤ ·)
     let _ : ∀ i, Zero (β i) := fun i ↦ ⟨e i 0⟩
-    have : WellFounded (Dfinsupp.Lex (Function.swap <| @WellOrderingRel ι)
+    have : WellFounded (DFinsupp.Lex (Function.swap <| @WellOrderingRel ι)
       (fun _ ↦ (· < ·) : (i : ι) → β i → β i → Prop))
     · have := IsTrichotomous.swap (@WellOrderingRel ι)
       refine Lex.wellFounded' ?_ (fun i ↦ IsWellFounded.wf) ?_
@@ -233,12 +233,12 @@ protected theorem Dfinsupp.wellFoundedLT [∀ i, Zero (α i)] [∀ i, Preorder (
     have := IsStrictOrder.swap (@WellOrderingRel ι)
     obtain ⟨i, he, hl⟩ := lex_lt_of_lt_of_preorder (Function.swap WellOrderingRel) h
     exact ⟨i, fun j hj ↦ Quot.sound (he j hj), hl⟩⟩
-#align dfinsupp.well_founded_lt Dfinsupp.wellFoundedLT
+#align dfinsupp.well_founded_lt DFinsupp.wellFoundedLT
 
-instance Dfinsupp.well_founded_lt' [∀ i, CanonicallyOrderedAddMonoid (α i)]
+instance DFinsupp.well_founded_lt' [∀ i, CanonicallyOrderedAddMonoid (α i)]
     [∀ i, WellFoundedLT (α i)] : WellFoundedLT (Π₀ i, α i) :=
-  Dfinsupp.wellFoundedLT fun _i a => (zero_le a).not_lt
-#align dfinsupp.well_founded_lt' Dfinsupp.well_founded_lt'
+  DFinsupp.wellFoundedLT fun _i a => (zero_le a).not_lt
+#align dfinsupp.well_founded_lt' DFinsupp.well_founded_lt'
 
 instance Pi.wellFoundedLT [Finite ι] [∀ i, Preorder (α i)] [hw : ∀ i, WellFoundedLT (α i)] :
     WellFoundedLT (∀ i, α i) :=
@@ -247,7 +247,7 @@ instance Pi.wellFoundedLT [Finite ι] [∀ i, Preorder (α i)] [hw : ∀ i, Well
     · convert emptyWf.wf
     letI : ∀ i, Zero (α i) := fun i => ⟨(hw i).wf.min ⊤ ⟨x i, trivial⟩⟩
     haveI := Fintype.ofFinite ι
-    refine' InvImage.wf equivFunOnFintype.symm (Dfinsupp.wellFoundedLT fun i a => _).wf
+    refine' InvImage.wf equivFunOnFintype.symm (DFinsupp.wellFoundedLT fun i a => _).wf
     exact (hw i).wf.not_lt_min ⊤ _ trivial⟩
 #align pi.well_founded_lt Pi.wellFoundedLT
 
@@ -256,9 +256,9 @@ instance Function.wellFoundedLT {α} [Finite ι] [Preorder α] [WellFoundedLT α
   Pi.wellFoundedLT
 #align function.well_founded_lt Function.wellFoundedLT
 
-instance Dfinsupp.wellFoundedLT_of_finite [Finite ι] [∀ i, Zero (α i)] [∀ i, Preorder (α i)]
+instance DFinsupp.wellFoundedLT_of_finite [Finite ι] [∀ i, Zero (α i)] [∀ i, Preorder (α i)]
     [∀ i, WellFoundedLT (α i)] : WellFoundedLT (Π₀ i, α i) :=
   have := Fintype.ofFinite ι
   ⟨InvImage.wf equivFunOnFintype Pi.wellFoundedLT.wf⟩
-#align dfinsupp.well_founded_lt_of_finite Dfinsupp.wellFoundedLT_of_finite
+#align dfinsupp.well_founded_lt_of_finite DFinsupp.wellFoundedLT_of_finite

e9b8651e

feat: port Data.Dfinsupp.WellFounded (#2944)

Other changes:

modify Data/Dfinsupp/Lex to use explicit (i : ι);
fix 2 typos&align in Logic.Basic.

f5297896

`data.dfinsupp.well_founded` ⟷ `Mathlib.Data.DFinsupp.WellFounded`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

PR contents

Lean PRs involved in this bump

leanprover/lean4#2778

leanprover/lean4#2722

leanprover/lean4#2783

Dependencies 8 + 350

data.dfinsupp.well_founded ⟷ Mathlib.Data.DFinsupp.WellFounded

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

PR contents

Lean PRs involved in this bump

leanprover/lean4#2778

leanprover/lean4#2722

leanprover/lean4#2783

Dependencies 8 + 350

`data.dfinsupp.well_founded` ⟷ `Mathlib.Data.DFinsupp.WellFounded`