data.pi.lex ⟷ Mathlib.Data.Pi.Lex

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
 -/
 import Order.WellFounded
-import Algebra.Group.Pi
+import Algebra.Group.Pi.Lemmas
 import Algebra.Order.Group.Defs
 
 #align_import data.pi.lex from "leanprover-community/mathlib"@"6623e6af705e97002a9054c1c05a980180276fc1"

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

@@ -89,7 +89,7 @@ theorem isTrichotomous_lex [∀ i, IsTrichotomous (β i) s] (wf : WellFounded r)
     trichotomous := fun a b => by
       cases' eq_or_ne a b with hab hab
       · exact Or.inr (Or.inl hab)
-      · rw [Function.ne_iff] at hab 
+      · rw [Function.ne_iff] at hab
         let i := wf.min _ hab
         have hri : ∀ j, r j i → a j = b j := by
           intro j; rw [← not_imp_not]
@@ -155,12 +155,12 @@ theorem lt_toLex_update_self_iff : toLex x < toLex (update x i a) ↔ x i < a :=
   by
   refine' ⟨_, fun h => to_lex_strict_mono <| lt_update_self_iff.2 h⟩
   rintro ⟨j, hj, h⟩
-  dsimp at h 
+  dsimp at h
   obtain rfl : j = i := by
     by_contra H
-    rw [update_noteq H] at h 
+    rw [update_noteq H] at h
     exact h.false
-  · rwa [update_same] at h 
+  · rwa [update_same] at h
 #align pi.lt_to_lex_update_self_iff Pi.lt_toLex_update_self_iff
 -/
 
@@ -170,12 +170,12 @@ theorem toLex_update_lt_self_iff : toLex (update x i a) < toLex x ↔ a < x i :=
   by
   refine' ⟨_, fun h => to_lex_strict_mono <| update_lt_self_iff.2 h⟩
   rintro ⟨j, hj, h⟩
-  dsimp at h 
+  dsimp at h
   obtain rfl : j = i := by
     by_contra H
-    rw [update_noteq H] at h 
+    rw [update_noteq H] at h
     exact h.false
-  · rwa [update_same] at h 
+  · rwa [update_same] at h
 #align pi.to_lex_update_lt_self_iff Pi.toLex_update_lt_self_iff
 -/
 

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

@@ -214,12 +214,18 @@ instance [Preorder ι] [∀ i, LT (β i)] [∀ i, DenselyOrdered (β i)] :
   ⟨by
     rintro _ _ ⟨i, h, hi⟩
     obtain ⟨a, ha₁, ha₂⟩ := exists_between hi
-    classical⟩
+    classical
+    refine' ⟨a₂.update _ a, ⟨i, fun j hj => _, _⟩, i, fun j hj => _, _⟩
+    rw [h j hj]
+    iterate 2 · rw [a₂.update_noteq hj.ne a]; · rwa [a₂.update_same i a]⟩
 
 #print Pi.Lex.noMaxOrder' /-
 theorem Lex.noMaxOrder' [Preorder ι] [∀ i, LT (β i)] (i : ι) [NoMaxOrder (β i)] :
     NoMaxOrder (Lex (∀ i, β i)) :=
-  ⟨fun a => by classical⟩
+  ⟨fun a => by
+    classical
+    obtain ⟨b, hb⟩ := exists_gt (a i)
+    exact ⟨a.update i b, i, fun j hj => (a.update_noteq hj.Ne b).symm, by rwa [a.update_same i b]⟩⟩
 #align pi.lex.no_max_order' Pi.Lex.noMaxOrder'
 -/
 

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

@@ -214,18 +214,12 @@ instance [Preorder ι] [∀ i, LT (β i)] [∀ i, DenselyOrdered (β i)] :
   ⟨by
     rintro _ _ ⟨i, h, hi⟩
     obtain ⟨a, ha₁, ha₂⟩ := exists_between hi
-    classical
-    refine' ⟨a₂.update _ a, ⟨i, fun j hj => _, _⟩, i, fun j hj => _, _⟩
-    rw [h j hj]
-    iterate 2 · rw [a₂.update_noteq hj.ne a]; · rwa [a₂.update_same i a]⟩
+    classical⟩
 
 #print Pi.Lex.noMaxOrder' /-
 theorem Lex.noMaxOrder' [Preorder ι] [∀ i, LT (β i)] (i : ι) [NoMaxOrder (β i)] :
     NoMaxOrder (Lex (∀ i, β i)) :=
-  ⟨fun a => by
-    classical
-    obtain ⟨b, hb⟩ := exists_gt (a i)
-    exact ⟨a.update i b, i, fun j hj => (a.update_noteq hj.Ne b).symm, by rwa [a.update_same i b]⟩⟩
+  ⟨fun a => by classical⟩
 #align pi.lex.no_max_order' Pi.Lex.noMaxOrder'
 -/
 

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

@@ -136,7 +136,7 @@ open Function
 
 #print Pi.toLex_monotone /-
 theorem toLex_monotone : Monotone (@toLex (∀ i, β i)) := fun a b h =>
-  or_iff_not_imp_left.2 fun hne =>
+  Classical.or_iff_not_imp_left.2 fun hne =>
     let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min {i | a i ≠ b i} (Function.ne_iff.1 hne)
     ⟨i, fun j hj => by contrapose! hl; exact ⟨j, hl, hj⟩, (h i).lt_of_ne hi⟩
 #align pi.to_lex_monotone Pi.toLex_monotone

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

@@ -3,9 +3,9 @@ Copyright (c) 2019 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
 -/
-import Mathbin.Order.WellFounded
-import Mathbin.Algebra.Group.Pi
-import Mathbin.Algebra.Order.Group.Defs
+import Order.WellFounded
+import Algebra.Group.Pi
+import Algebra.Order.Group.Defs
 
 #align_import data.pi.lex from "leanprover-community/mathlib"@"6623e6af705e97002a9054c1c05a980180276fc1"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

@@ -255,15 +255,13 @@ instance Lex.orderedCommGroup [LinearOrder ι] [∀ a, OrderedCommGroup (β a)]
 #align pi.lex.ordered_add_comm_group Pi.Lex.orderedAddCommGroup
 -/
 
-#print Pi.lex_desc /-
 /-- If we swap two strictly decreasing values in a function, then the result is lexicographically
 smaller than the original function. -/
 theorem lex_desc {α} [Preorder ι] [DecidableEq ι] [Preorder α] {f : ι → α} {i j : ι} (h₁ : i < j)
     (h₂ : f j < f i) : toLex (f ∘ Equiv.swap i j) < toLex f :=
   ⟨i, fun k hik => congr_arg f (Equiv.swap_apply_of_ne_of_ne hik.Ne (hik.trans h₁).Ne), by
     simpa only [Pi.toLex_apply, Function.comp_apply, Equiv.swap_apply_left] using h₂⟩
-#align pi.lex_desc Pi.lex_desc
--/
+#align pi.lex_desc Pi.lex_descₓ
 
 end Pi
 

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

@@ -2,16 +2,13 @@
 Copyright (c) 2019 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
-
-! This file was ported from Lean 3 source module data.pi.lex
-! leanprover-community/mathlib commit 6623e6af705e97002a9054c1c05a980180276fc1
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.WellFounded
 import Mathbin.Algebra.Group.Pi
 import Mathbin.Algebra.Order.Group.Defs
 
+#align_import data.pi.lex from "leanprover-community/mathlib"@"6623e6af705e97002a9054c1c05a980180276fc1"
+
 /-!
 # Lexicographic order on Pi types
 

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

@@ -51,7 +51,6 @@ protected def Lex (x y : ∀ i, β i) : Prop :=
 #align pi.lex Pi.Lex
 -/
 
--- mathport name: «exprΠₗ , »
 notation3"Πₗ "/- This unfortunately results in a type that isn't delta-reduced, so we keep the notation out of the
 basic API, just in case -/
 (...)", "r:(scoped p => Lex ∀ i, p i) => r
@@ -63,10 +62,12 @@ theorem toLex_apply (x : ∀ i, β i) (i : ι) : toLex x i = x i :=
 #align pi.to_lex_apply Pi.toLex_apply
 -/
 
+#print Pi.ofLex_apply /-
 @[simp]
 theorem ofLex_apply (x : Lex (∀ i, β i)) (i : ι) : ofLex x i = x i :=
   rfl
 #align pi.of_lex_apply Pi.ofLex_apply
+-/
 
 #print Pi.lex_lt_of_lt_of_preorder /-
 theorem lex_lt_of_lt_of_preorder [∀ i, Preorder (β i)] {r} (hwf : WellFounded r) {x y : ∀ i, β i}
@@ -136,17 +137,22 @@ variable [LinearOrder ι] [IsWellOrder ι (· < ·)] [∀ i, PartialOrder (β i)
 
 open Function
 
+#print Pi.toLex_monotone /-
 theorem toLex_monotone : Monotone (@toLex (∀ i, β i)) := fun a b h =>
   or_iff_not_imp_left.2 fun hne =>
     let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min {i | a i ≠ b i} (Function.ne_iff.1 hne)
     ⟨i, fun j hj => by contrapose! hl; exact ⟨j, hl, hj⟩, (h i).lt_of_ne hi⟩
 #align pi.to_lex_monotone Pi.toLex_monotone
+-/
 
+#print Pi.toLex_strictMono /-
 theorem toLex_strictMono : StrictMono (@toLex (∀ i, β i)) := fun a b h =>
   let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min {i | a i ≠ b i} (Function.ne_iff.1 h.Ne)
   ⟨i, fun j hj => by contrapose! hl; exact ⟨j, hl, hj⟩, (h.le i).lt_of_ne hi⟩
 #align pi.to_lex_strict_mono Pi.toLex_strictMono
+-/
 
+#print Pi.lt_toLex_update_self_iff /-
 @[simp]
 theorem lt_toLex_update_self_iff : toLex x < toLex (update x i a) ↔ x i < a :=
   by
@@ -159,7 +165,9 @@ theorem lt_toLex_update_self_iff : toLex x < toLex (update x i a) ↔ x i < a :=
     exact h.false
   · rwa [update_same] at h 
 #align pi.lt_to_lex_update_self_iff Pi.lt_toLex_update_self_iff
+-/
 
+#print Pi.toLex_update_lt_self_iff /-
 @[simp]
 theorem toLex_update_lt_self_iff : toLex (update x i a) < toLex x ↔ a < x i :=
   by
@@ -172,16 +180,21 @@ theorem toLex_update_lt_self_iff : toLex (update x i a) < toLex x ↔ a < x i :=
     exact h.false
   · rwa [update_same] at h 
 #align pi.to_lex_update_lt_self_iff Pi.toLex_update_lt_self_iff
+-/
 
+#print Pi.le_toLex_update_self_iff /-
 @[simp]
 theorem le_toLex_update_self_iff : toLex x ≤ toLex (update x i a) ↔ x i ≤ a := by
   simp_rw [le_iff_lt_or_eq, lt_to_lex_update_self_iff, toLex_inj, eq_update_self_iff]
 #align pi.le_to_lex_update_self_iff Pi.le_toLex_update_self_iff
+-/
 
+#print Pi.toLex_update_le_self_iff /-
 @[simp]
 theorem toLex_update_le_self_iff : toLex (update x i a) ≤ toLex x ↔ a ≤ x i := by
   simp_rw [le_iff_lt_or_eq, to_lex_update_lt_self_iff, toLex_inj, update_eq_self_iff]
 #align pi.to_lex_update_le_self_iff Pi.toLex_update_le_self_iff
+-/
 
 end PartialOrder
 
@@ -209,6 +222,7 @@ instance [Preorder ι] [∀ i, LT (β i)] [∀ i, DenselyOrdered (β i)] :
     rw [h j hj]
     iterate 2 · rw [a₂.update_noteq hj.ne a]; · rwa [a₂.update_same i a]⟩
 
+#print Pi.Lex.noMaxOrder' /-
 theorem Lex.noMaxOrder' [Preorder ι] [∀ i, LT (β i)] (i : ι) [NoMaxOrder (β i)] :
     NoMaxOrder (Lex (∀ i, β i)) :=
   ⟨fun a => by
@@ -216,6 +230,7 @@ theorem Lex.noMaxOrder' [Preorder ι] [∀ i, LT (β i)] (i : ι) [NoMaxOrder (
     obtain ⟨b, hb⟩ := exists_gt (a i)
     exact ⟨a.update i b, i, fun j hj => (a.update_noteq hj.Ne b).symm, by rwa [a.update_same i b]⟩⟩
 #align pi.lex.no_max_order' Pi.Lex.noMaxOrder'
+-/
 
 instance [LinearOrder ι] [IsWellOrder ι (· < ·)] [Nonempty ι] [∀ i, PartialOrder (β i)]
     [∀ i, NoMaxOrder (β i)] : NoMaxOrder (Lex (∀ i, β i)) :=

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

@@ -138,12 +138,12 @@ open Function
 
 theorem toLex_monotone : Monotone (@toLex (∀ i, β i)) := fun a b h =>
   or_iff_not_imp_left.2 fun hne =>
-    let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min { i | a i ≠ b i } (Function.ne_iff.1 hne)
+    let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min {i | a i ≠ b i} (Function.ne_iff.1 hne)
     ⟨i, fun j hj => by contrapose! hl; exact ⟨j, hl, hj⟩, (h i).lt_of_ne hi⟩
 #align pi.to_lex_monotone Pi.toLex_monotone
 
 theorem toLex_strictMono : StrictMono (@toLex (∀ i, β i)) := fun a b h =>
-  let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min { i | a i ≠ b i } (Function.ne_iff.1 h.Ne)
+  let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min {i | a i ≠ b i} (Function.ne_iff.1 h.Ne)
   ⟨i, fun j hj => by contrapose! hl; exact ⟨j, hl, hj⟩, (h.le i).lt_of_ne hi⟩
 #align pi.to_lex_strict_mono Pi.toLex_strictMono
 
@@ -205,17 +205,16 @@ instance [Preorder ι] [∀ i, LT (β i)] [∀ i, DenselyOrdered (β i)] :
     rintro _ _ ⟨i, h, hi⟩
     obtain ⟨a, ha₁, ha₂⟩ := exists_between hi
     classical
-      refine' ⟨a₂.update _ a, ⟨i, fun j hj => _, _⟩, i, fun j hj => _, _⟩
-      rw [h j hj]
-      iterate 2 · rw [a₂.update_noteq hj.ne a]; · rwa [a₂.update_same i a]⟩
+    refine' ⟨a₂.update _ a, ⟨i, fun j hj => _, _⟩, i, fun j hj => _, _⟩
+    rw [h j hj]
+    iterate 2 · rw [a₂.update_noteq hj.ne a]; · rwa [a₂.update_same i a]⟩
 
 theorem Lex.noMaxOrder' [Preorder ι] [∀ i, LT (β i)] (i : ι) [NoMaxOrder (β i)] :
     NoMaxOrder (Lex (∀ i, β i)) :=
   ⟨fun a => by
     classical
-      obtain ⟨b, hb⟩ := exists_gt (a i)
-      exact
-        ⟨a.update i b, i, fun j hj => (a.update_noteq hj.Ne b).symm, by rwa [a.update_same i b]⟩⟩
+    obtain ⟨b, hb⟩ := exists_gt (a i)
+    exact ⟨a.update i b, i, fun j hj => (a.update_noteq hj.Ne b).symm, by rwa [a.update_same i b]⟩⟩
 #align pi.lex.no_max_order' Pi.Lex.noMaxOrder'
 
 instance [LinearOrder ι] [IsWellOrder ι (· < ·)] [Nonempty ι] [∀ i, PartialOrder (β i)]

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

@@ -91,14 +91,14 @@ theorem isTrichotomous_lex [∀ i, IsTrichotomous (β i) s] (wf : WellFounded r)
     trichotomous := fun a b => by
       cases' eq_or_ne a b with hab hab
       · exact Or.inr (Or.inl hab)
-      · rw [Function.ne_iff] at hab
+      · rw [Function.ne_iff] at hab 
         let i := wf.min _ hab
         have hri : ∀ j, r j i → a j = b j := by
           intro j; rw [← not_imp_not]
           exact fun h' => wf.not_lt_min _ _ h'
         have hne : a i ≠ b i := wf.min_mem _ hab
         cases' trichotomous_of s (a i) (b i) with hi hi
-        exacts[Or.inl ⟨i, hri, hi⟩,
+        exacts [Or.inl ⟨i, hri, hi⟩,
           Or.inr <| Or.inr <| ⟨i, fun j hj => (hri j hj).symm, hi.resolve_left hne⟩] }
 #align pi.is_trichotomous_lex Pi.isTrichotomous_lex
 -/
@@ -114,7 +114,7 @@ instance Lex.isStrictOrder [LinearOrder ι] [∀ a, PartialOrder (β a)] :
   trans := by
     rintro a b c ⟨N₁, lt_N₁, a_lt_b⟩ ⟨N₂, lt_N₂, b_lt_c⟩
     rcases lt_trichotomy N₁ N₂ with (H | rfl | H)
-    exacts[⟨N₁, fun j hj => (lt_N₁ _ hj).trans (lt_N₂ _ <| hj.trans H), lt_N₂ _ H ▸ a_lt_b⟩,
+    exacts [⟨N₁, fun j hj => (lt_N₁ _ hj).trans (lt_N₂ _ <| hj.trans H), lt_N₂ _ H ▸ a_lt_b⟩,
       ⟨N₁, fun j hj => (lt_N₁ _ hj).trans (lt_N₂ _ hj), a_lt_b.trans b_lt_c⟩,
       ⟨N₂, fun j hj => (lt_N₁ _ (hj.trans H)).trans (lt_N₂ _ hj), (lt_N₁ _ H).symm ▸ b_lt_c⟩]
 #align pi.lex.is_strict_order Pi.Lex.isStrictOrder
@@ -152,12 +152,12 @@ theorem lt_toLex_update_self_iff : toLex x < toLex (update x i a) ↔ x i < a :=
   by
   refine' ⟨_, fun h => to_lex_strict_mono <| lt_update_self_iff.2 h⟩
   rintro ⟨j, hj, h⟩
-  dsimp at h
+  dsimp at h 
   obtain rfl : j = i := by
     by_contra H
-    rw [update_noteq H] at h
+    rw [update_noteq H] at h 
     exact h.false
-  · rwa [update_same] at h
+  · rwa [update_same] at h 
 #align pi.lt_to_lex_update_self_iff Pi.lt_toLex_update_self_iff
 
 @[simp]
@@ -165,12 +165,12 @@ theorem toLex_update_lt_self_iff : toLex (update x i a) < toLex x ↔ a < x i :=
   by
   refine' ⟨_, fun h => to_lex_strict_mono <| update_lt_self_iff.2 h⟩
   rintro ⟨j, hj, h⟩
-  dsimp at h
+  dsimp at h 
   obtain rfl : j = i := by
     by_contra H
-    rw [update_noteq H] at h
+    rw [update_noteq H] at h 
     exact h.false
-  · rwa [update_same] at h
+  · rwa [update_same] at h 
 #align pi.to_lex_update_lt_self_iff Pi.toLex_update_lt_self_iff
 
 @[simp]

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

@@ -68,17 +68,21 @@ theorem ofLex_apply (x : Lex (∀ i, β i)) (i : ι) : ofLex x i = x i :=
   rfl
 #align pi.of_lex_apply Pi.ofLex_apply
 
+#print Pi.lex_lt_of_lt_of_preorder /-
 theorem lex_lt_of_lt_of_preorder [∀ i, Preorder (β i)] {r} (hwf : WellFounded r) {x y : ∀ i, β i}
     (hlt : x < y) : ∃ i, (∀ j, r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i :=
   let h' := Pi.lt_def.1 hlt
   let ⟨i, hi, hl⟩ := hwf.has_min _ h'.2
   ⟨i, fun j hj => ⟨h'.1 j, Classical.not_not.1 fun h => hl j (lt_of_le_not_le (h'.1 j) h) hj⟩, hi⟩
 #align pi.lex_lt_of_lt_of_preorder Pi.lex_lt_of_lt_of_preorder
+-/
 
+#print Pi.lex_lt_of_lt /-
 theorem lex_lt_of_lt [∀ i, PartialOrder (β i)] {r} (hwf : WellFounded r) {x y : ∀ i, β i}
     (hlt : x < y) : Pi.Lex r (fun i => (· < ·)) x y := by simp_rw [Pi.Lex, le_antisymm_iff];
   exact lex_lt_of_lt_of_preorder hwf hlt
 #align pi.lex_lt_of_lt Pi.lex_lt_of_lt
+-/
 
 #print Pi.isTrichotomous_lex /-
 theorem isTrichotomous_lex [∀ i, IsTrichotomous (β i) s] (wf : WellFounded r) :
@@ -102,6 +106,7 @@ theorem isTrichotomous_lex [∀ i, IsTrichotomous (β i) s] (wf : WellFounded r)
 instance [LT ι] [∀ a, LT (β a)] : LT (Lex (∀ i, β i)) :=
   ⟨Pi.Lex (· < ·) fun _ => (· < ·)⟩
 
+#print Pi.Lex.isStrictOrder /-
 instance Lex.isStrictOrder [LinearOrder ι] [∀ a, PartialOrder (β a)] :
     IsStrictOrder (Lex (∀ i, β i)) (· < ·)
     where
@@ -113,6 +118,7 @@ instance Lex.isStrictOrder [LinearOrder ι] [∀ a, PartialOrder (β a)] :
       ⟨N₁, fun j hj => (lt_N₁ _ hj).trans (lt_N₂ _ hj), a_lt_b.trans b_lt_c⟩,
       ⟨N₂, fun j hj => (lt_N₁ _ (hj.trans H)).trans (lt_N₂ _ hj), (lt_N₁ _ H).symm ▸ b_lt_c⟩]
 #align pi.lex.is_strict_order Pi.Lex.isStrictOrder
+-/
 
 instance [LinearOrder ι] [∀ a, PartialOrder (β a)] : PartialOrder (Lex (∀ i, β i)) :=
   partialOrderOfSO (· < ·)
@@ -238,6 +244,7 @@ instance Lex.orderedCommGroup [LinearOrder ι] [∀ a, OrderedCommGroup (β a)]
 #align pi.lex.ordered_add_comm_group Pi.Lex.orderedAddCommGroup
 -/
 
+#print Pi.lex_desc /-
 /-- If we swap two strictly decreasing values in a function, then the result is lexicographically
 smaller than the original function. -/
 theorem lex_desc {α} [Preorder ι] [DecidableEq ι] [Preorder α] {f : ι → α} {i j : ι} (h₁ : i < j)
@@ -245,6 +252,7 @@ theorem lex_desc {α} [Preorder ι] [DecidableEq ι] [Preorder α] {f : ι → 
   ⟨i, fun k hik => congr_arg f (Equiv.swap_apply_of_ne_of_ne hik.Ne (hik.trans h₁).Ne), by
     simpa only [Pi.toLex_apply, Function.comp_apply, Equiv.swap_apply_left] using h₂⟩
 #align pi.lex_desc Pi.lex_desc
+-/
 
 end Pi
 

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

@@ -63,23 +63,11 @@ theorem toLex_apply (x : ∀ i, β i) (i : ι) : toLex x i = x i :=
 #align pi.to_lex_apply Pi.toLex_apply
 -/
 
-/- warning: pi.of_lex_apply -> Pi.ofLex_apply is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} (x : Lex.{max u1 u2} (forall (i : ι), β i)) (i : ι), Eq.{succ u2} (β i) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (forall (i : ι), β i)) (forall (i : ι), β i)) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (forall (i : ι), β i)) (forall (i : ι), β i)) => (Lex.{max u1 u2} (forall (i : ι), β i)) -> (forall (i : ι), β i)) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (forall (i : ι), β i)) (forall (i : ι), β i)) (ofLex.{max u1 u2} (forall (i : ι), β i)) x i) (x i)
-but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} (x : Lex.{max u2 u1} (forall (i : ι), β i)) (i : ι), Eq.{succ u1} (β i) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Lex.{max u2 u1} (forall (i : ι), β i)) (forall (i : ι), β i)) (Lex.{max u2 u1} (forall (i : ι), β i)) (fun (_x : Lex.{max u2 u1} (forall (i : ι), β i)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Lex.{max u2 u1} (forall (i : ι), β i)) => forall (i : ι), β i) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Lex.{max u2 u1} (forall (i : ι), β i)) (forall (i : ι), β i)) (ofLex.{max u2 u1} (forall (i : ι), β i)) x i) (x i)
-Case conversion may be inaccurate. Consider using '#align pi.of_lex_apply Pi.ofLex_applyₓ'. -/
 @[simp]
 theorem ofLex_apply (x : Lex (∀ i, β i)) (i : ι) : ofLex x i = x i :=
   rfl
 #align pi.of_lex_apply Pi.ofLex_apply
 
-/- warning: pi.lex_lt_of_lt_of_preorder -> Pi.lex_lt_of_lt_of_preorder is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : forall (i : ι), Preorder.{u2} (β i)] {r : ι -> ι -> Prop}, (WellFounded.{succ u1} ι r) -> (forall {x : forall (i : ι), β i} {y : forall (i : ι), β i}, (LT.lt.{max u1 u2} (forall (i : ι), β i) (Preorder.toHasLt.{max u1 u2} (forall (i : ι), β i) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => _inst_1 i))) x y) -> (Exists.{succ u1} ι (fun (i : ι) => And (forall (j : ι), (r j i) -> (And (LE.le.{u2} (β j) (Preorder.toHasLe.{u2} (β j) (_inst_1 j)) (x j) (y j)) (LE.le.{u2} (β j) (Preorder.toHasLe.{u2} (β j) (_inst_1 j)) (y j) (x j)))) (LT.lt.{u2} (β i) (Preorder.toHasLt.{u2} (β i) (_inst_1 i)) (x i) (y i)))))
-but is expected to have type
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : forall (i : ι), Preorder.{u2} (β i)] {r : ι -> ι -> Prop}, (WellFounded.{succ u1} ι r) -> (forall {x : forall (i : ι), β i} {y : forall (i : ι), β i}, (LT.lt.{max u1 u2} (forall (i : ι), β i) (Preorder.toLT.{max u1 u2} (forall (i : ι), β i) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => _inst_1 i))) x y) -> (Exists.{succ u1} ι (fun (i : ι) => And (forall (j : ι), (r j i) -> (And (LE.le.{u2} (β j) (Preorder.toLE.{u2} (β j) (_inst_1 j)) (x j) (y j)) (LE.le.{u2} (β j) (Preorder.toLE.{u2} (β j) (_inst_1 j)) (y j) (x j)))) (LT.lt.{u2} (β i) (Preorder.toLT.{u2} (β i) (_inst_1 i)) (x i) (y i)))))
-Case conversion may be inaccurate. Consider using '#align pi.lex_lt_of_lt_of_preorder Pi.lex_lt_of_lt_of_preorderₓ'. -/
 theorem lex_lt_of_lt_of_preorder [∀ i, Preorder (β i)] {r} (hwf : WellFounded r) {x y : ∀ i, β i}
     (hlt : x < y) : ∃ i, (∀ j, r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i :=
   let h' := Pi.lt_def.1 hlt
@@ -87,12 +75,6 @@ theorem lex_lt_of_lt_of_preorder [∀ i, Preorder (β i)] {r} (hwf : WellFounded
   ⟨i, fun j hj => ⟨h'.1 j, Classical.not_not.1 fun h => hl j (lt_of_le_not_le (h'.1 j) h) hj⟩, hi⟩
 #align pi.lex_lt_of_lt_of_preorder Pi.lex_lt_of_lt_of_preorder
 
-/- warning: pi.lex_lt_of_lt -> Pi.lex_lt_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : forall (i : ι), PartialOrder.{u2} (β i)] {r : ι -> ι -> Prop}, (WellFounded.{succ u1} ι r) -> (forall {x : forall (i : ι), β i} {y : forall (i : ι), β i}, (LT.lt.{max u1 u2} (forall (i : ι), β i) (Preorder.toHasLt.{max u1 u2} (forall (i : ι), β i) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u2} (β i) (_inst_1 i)))) x y) -> (Pi.Lex.{u1, u2} ι (fun (i : ι) => β i) r (fun (i : ι) => LT.lt.{u2} (β i) (Preorder.toHasLt.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_1 i)))) x y))
-but is expected to have type
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : forall (i : ι), PartialOrder.{u2} (β i)] {r : ι -> ι -> Prop}, (WellFounded.{succ u1} ι r) -> (forall {x : forall (i : ι), β i} {y : forall (i : ι), β i}, (LT.lt.{max u1 u2} (forall (i : ι), β i) (Preorder.toLT.{max u1 u2} (forall (i : ι), β i) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u2} (β i) (_inst_1 i)))) x y) -> (Pi.Lex.{u1, u2} ι (fun (i : ι) => β i) r (fun (i : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.822 : β i) (x._@.Mathlib.Data.Pi.Lex._hyg.824 : β i) => LT.lt.{u2} (β i) (Preorder.toLT.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_1 i))) x._@.Mathlib.Data.Pi.Lex._hyg.822 x._@.Mathlib.Data.Pi.Lex._hyg.824) x y))
-Case conversion may be inaccurate. Consider using '#align pi.lex_lt_of_lt Pi.lex_lt_of_ltₓ'. -/
 theorem lex_lt_of_lt [∀ i, PartialOrder (β i)] {r} (hwf : WellFounded r) {x y : ∀ i, β i}
     (hlt : x < y) : Pi.Lex r (fun i => (· < ·)) x y := by simp_rw [Pi.Lex, le_antisymm_iff];
   exact lex_lt_of_lt_of_preorder hwf hlt
@@ -120,12 +102,6 @@ theorem isTrichotomous_lex [∀ i, IsTrichotomous (β i) s] (wf : WellFounded r)
 instance [LT ι] [∀ a, LT (β a)] : LT (Lex (∀ i, β i)) :=
   ⟨Pi.Lex (· < ·) fun _ => (· < ·)⟩
 
-/- warning: pi.lex.is_strict_order -> Pi.Lex.isStrictOrder is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : forall (a : ι), PartialOrder.{u2} (β a)], IsStrictOrder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (LT.lt.{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 : ι) => Preorder.toHasLt.{u2} (β a) (PartialOrder.toPreorder.{u2} (β a) (_inst_2 a)))))
-but is expected to have type
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : forall (a : ι), PartialOrder.{u2} (β a)], IsStrictOrder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (fun (x._@.Mathlib.Data.Pi.Lex._hyg.1246 : Lex.{max u1 u2} (forall (i : ι), β i)) (x._@.Mathlib.Data.Pi.Lex._hyg.1248 : Lex.{max u1 u2} (forall (i : ι), β i)) => LT.lt.{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 : ι) => Preorder.toLT.{u2} (β a) (PartialOrder.toPreorder.{u2} (β a) (_inst_2 a)))) x._@.Mathlib.Data.Pi.Lex._hyg.1246 x._@.Mathlib.Data.Pi.Lex._hyg.1248)
-Case conversion may be inaccurate. Consider using '#align pi.lex.is_strict_order Pi.Lex.isStrictOrderₓ'. -/
 instance Lex.isStrictOrder [LinearOrder ι] [∀ a, PartialOrder (β a)] :
     IsStrictOrder (Lex (∀ i, β i)) (· < ·)
     where
@@ -154,35 +130,17 @@ variable [LinearOrder ι] [IsWellOrder ι (· < ·)] [∀ i, PartialOrder (β i)
 
 open Function
 
-/- warning: pi.to_lex_monotone -> Pi.toLex_monotone is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)], Monotone.{max u1 u2, max u1 u2} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)))
-but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.1683 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.1685 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.1683 x._@.Mathlib.Data.Pi.Lex._hyg.1685)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)], Monotone.{max u2 u1, max u2 u1} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.preorder.{u2, u1} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)))
-Case conversion may be inaccurate. Consider using '#align pi.to_lex_monotone Pi.toLex_monotoneₓ'. -/
 theorem toLex_monotone : Monotone (@toLex (∀ i, β i)) := fun a b h =>
   or_iff_not_imp_left.2 fun hne =>
     let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min { i | a i ≠ b i } (Function.ne_iff.1 hne)
     ⟨i, fun j hj => by contrapose! hl; exact ⟨j, hl, hj⟩, (h i).lt_of_ne hi⟩
 #align pi.to_lex_monotone Pi.toLex_monotone
 
-/- warning: pi.to_lex_strict_mono -> Pi.toLex_strictMono is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)], StrictMono.{max u1 u2, max u1 u2} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)))
-but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.1870 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.1872 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.1870 x._@.Mathlib.Data.Pi.Lex._hyg.1872)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)], StrictMono.{max u2 u1, max u2 u1} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.preorder.{u2, u1} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)))
-Case conversion may be inaccurate. Consider using '#align pi.to_lex_strict_mono Pi.toLex_strictMonoₓ'. -/
 theorem toLex_strictMono : StrictMono (@toLex (∀ i, β i)) := fun a b h =>
   let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min { i | a i ≠ b i } (Function.ne_iff.1 h.Ne)
   ⟨i, fun j hj => by contrapose! hl; exact ⟨j, hl, hj⟩, (h.le i).lt_of_ne hi⟩
 #align pi.to_lex_strict_mono Pi.toLex_strictMono
 
-/- warning: pi.lt_to_lex_update_self_iff -> Pi.lt_toLex_update_self_iff is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{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 : ι) => Preorder.toHasLt.{u2} (β a) (PartialOrder.toPreorder.{u2} (β a) (_inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a))) (LT.lt.{u2} (β i) (Preorder.toHasLt.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (x i) a)
-but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2053 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2055 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2053 x._@.Mathlib.Data.Pi.Lex._hyg.2055)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Pi.instLTLexForAll.{u2, u1} ι (fun (i : ι) => β i) (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) (fun (a : ι) => Preorder.toLT.{u1} (β a) (PartialOrder.toPreorder.{u1} (β a) (_inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a))) (LT.lt.{u1} (β i) (Preorder.toLT.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (x i) a)
-Case conversion may be inaccurate. Consider using '#align pi.lt_to_lex_update_self_iff Pi.lt_toLex_update_self_iffₓ'. -/
 @[simp]
 theorem lt_toLex_update_self_iff : toLex x < toLex (update x i a) ↔ x i < a :=
   by
@@ -196,12 +154,6 @@ theorem lt_toLex_update_self_iff : toLex x < toLex (update x i a) ↔ x i < a :=
   · rwa [update_same] at h
 #align pi.lt_to_lex_update_self_iff Pi.lt_toLex_update_self_iff
 
-/- warning: pi.to_lex_update_lt_self_iff -> Pi.toLex_update_lt_self_iff is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (Pi.Lex.hasLt.{u1, u2} ι (fun (a : ι) => β a) (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))) (fun (a : ι) => Preorder.toHasLt.{u2} (β a) (PartialOrder.toPreorder.{u2} (β a) (_inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x)) (LT.lt.{u2} (β i) (Preorder.toHasLt.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) a (x i))
-but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2351 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2353 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2351 x._@.Mathlib.Data.Pi.Lex._hyg.2353)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Pi.instLTLexForAll.{u2, u1} ι (fun (a : ι) => β a) (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) (fun (a : ι) => Preorder.toLT.{u1} (β a) (PartialOrder.toPreorder.{u1} (β a) (_inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x)) (LT.lt.{u1} (β i) (Preorder.toLT.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) a (x i))
-Case conversion may be inaccurate. Consider using '#align pi.to_lex_update_lt_self_iff Pi.toLex_update_lt_self_iffₓ'. -/
 @[simp]
 theorem toLex_update_lt_self_iff : toLex (update x i a) < toLex x ↔ a < x i :=
   by
@@ -215,23 +167,11 @@ theorem toLex_update_lt_self_iff : toLex (update x i a) < toLex x ↔ a < x i :=
   · rwa [update_same] at h
 #align pi.to_lex_update_lt_self_iff Pi.toLex_update_lt_self_iff
 
-/- warning: pi.le_to_lex_update_self_iff -> Pi.le_toLex_update_self_iff is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Preorder.toHasLe.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a))) (LE.le.{u2} (β i) (Preorder.toHasLe.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (x i) a)
-but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2649 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2651 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2649 x._@.Mathlib.Data.Pi.Lex._hyg.2651)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Preorder.toLE.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (PartialOrder.toPreorder.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a))) (LE.le.{u1} (β i) (Preorder.toLE.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (x i) a)
-Case conversion may be inaccurate. Consider using '#align pi.le_to_lex_update_self_iff Pi.le_toLex_update_self_iffₓ'. -/
 @[simp]
 theorem le_toLex_update_self_iff : toLex x ≤ toLex (update x i a) ↔ x i ≤ a := by
   simp_rw [le_iff_lt_or_eq, lt_to_lex_update_self_iff, toLex_inj, eq_update_self_iff]
 #align pi.le_to_lex_update_self_iff Pi.le_toLex_update_self_iff
 
-/- warning: pi.to_lex_update_le_self_iff -> Pi.toLex_update_le_self_iff is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (Preorder.toHasLe.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (a : ι) => β a) _inst_1 (fun (a : ι) => _inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x)) (LE.le.{u2} (β i) (Preorder.toHasLe.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) a (x i))
-but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2745 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2747 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2745 x._@.Mathlib.Data.Pi.Lex._hyg.2747)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Preorder.toLE.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (PartialOrder.toPreorder.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (a : ι) => β a) _inst_1 (fun (a : ι) => _inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x)) (LE.le.{u1} (β i) (Preorder.toLE.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) a (x i))
-Case conversion may be inaccurate. Consider using '#align pi.to_lex_update_le_self_iff Pi.toLex_update_le_self_iffₓ'. -/
 @[simp]
 theorem toLex_update_le_self_iff : toLex (update x i a) ≤ toLex x ↔ a ≤ x i := by
   simp_rw [le_iff_lt_or_eq, to_lex_update_lt_self_iff, toLex_inj, update_eq_self_iff]
@@ -263,12 +203,6 @@ instance [Preorder ι] [∀ i, LT (β i)] [∀ i, DenselyOrdered (β i)] :
       rw [h j hj]
       iterate 2 · rw [a₂.update_noteq hj.ne a]; · rwa [a₂.update_same i a]⟩
 
-/- warning: pi.lex.no_max_order' -> Pi.Lex.noMaxOrder' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), LT.{u2} (β i)] (i : ι) [_inst_3 : NoMaxOrder.{u2} (β i) (_inst_2 i)], NoMaxOrder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.hasLt.{u1, u2} ι (fun (i : ι) => β i) (Preorder.toHasLt.{u1} ι _inst_1) (fun (a : ι) => _inst_2 a))
-but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : Preorder.{u2} ι] [_inst_2 : forall (i : ι), LT.{u1} (β i)] (i : ι) [_inst_3 : NoMaxOrder.{u1} (β i) (_inst_2 i)], NoMaxOrder.{max u2 u1} (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.instLTLexForAll.{u2, u1} ι (fun (i : ι) => β i) (Preorder.toLT.{u2} ι _inst_1) (fun (a : ι) => _inst_2 a))
-Case conversion may be inaccurate. Consider using '#align pi.lex.no_max_order' Pi.Lex.noMaxOrder'ₓ'. -/
 theorem Lex.noMaxOrder' [Preorder ι] [∀ i, LT (β i)] (i : ι) [NoMaxOrder (β i)] :
     NoMaxOrder (Lex (∀ i, β i)) :=
   ⟨fun a => by
@@ -304,12 +238,6 @@ instance Lex.orderedCommGroup [LinearOrder ι] [∀ a, OrderedCommGroup (β a)]
 #align pi.lex.ordered_add_comm_group Pi.Lex.orderedAddCommGroup
 -/
 
-/- warning: pi.lex_desc -> Pi.lex_desc is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : Preorder.{u2} α] {f : ι -> α} {i : ι} {j : ι}, (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι _inst_1) i j) -> (LT.lt.{u2} α (Preorder.toHasLt.{u2} α _inst_3) (f j) (f i)) -> (LT.lt.{max u1 u2} (Lex.{max u1 u2} (ι -> α)) (Pi.Lex.hasLt.{u1, u2} ι (fun (ᾰ : ι) => α) (Preorder.toHasLt.{u1} ι _inst_1) (fun (a : ι) => Preorder.toHasLt.{u2} α _inst_3)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) => (ι -> α) -> (Lex.{max u1 u2} (ι -> α))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (toLex.{max u1 u2} (ι -> α)) (Function.comp.{succ u1, succ u1, succ u2} ι ι α f (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} ι) (fun (_x : Equiv.{succ u1, succ u1} ι ι) => ι -> ι) (Equiv.hasCoeToFun.{succ u1, succ u1} ι ι) (Equiv.swap.{succ u1} ι (fun (a : ι) (b : ι) => _inst_2 a b) i j)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) => (ι -> α) -> (Lex.{max u1 u2} (ι -> α))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (toLex.{max u1 u2} (ι -> α)) f))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : Preorder.{u2} α] {f : ι -> α} {i : ι} {j : ι}, (LT.lt.{u1} ι (Preorder.toLT.{u1} ι _inst_1) i j) -> (LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_3) (f j) (f i)) -> (LT.lt.{max u1 u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ι -> α) => Lex.{max u1 u2} (ι -> α)) (Function.comp.{succ u1, succ u1, succ u2} ι ι α f (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} ι) ι (fun (a : ι) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ι) => ι) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} ι ι) (Equiv.swap.{succ u1} ι (fun (a : ι) (b : ι) => _inst_2 a b) i j)))) (Pi.instLTLexForAll.{u1, u2} ι (fun (ᾰ : ι) => α) (Preorder.toLT.{u1} ι _inst_1) (fun (a : ι) => Preorder.toLT.{u2} α _inst_3)) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (ι -> α) (fun (_x : ι -> α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ι -> α) => Lex.{max u1 u2} (ι -> α)) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (toLex.{max u1 u2} (ι -> α)) (Function.comp.{succ u1, succ u1, succ u2} ι ι α f (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} ι) ι (fun (_x : ι) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ι) => ι) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} ι ι) (Equiv.swap.{succ u1} ι (fun (a : ι) (b : ι) => _inst_2 a b) i j)))) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (ι -> α) (fun (_x : ι -> α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ι -> α) => Lex.{max u1 u2} (ι -> α)) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (toLex.{max u1 u2} (ι -> α)) f))
-Case conversion may be inaccurate. Consider using '#align pi.lex_desc Pi.lex_descₓ'. -/
 /-- If we swap two strictly decreasing values in a function, then the result is lexicographically
 smaller than the original function. -/
 theorem lex_desc {α} [Preorder ι] [DecidableEq ι] [Preorder α] {f : ι → α} {i j : ι} (h₁ : i < j)

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

@@ -94,9 +94,7 @@ but is expected to have type
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : forall (i : ι), PartialOrder.{u2} (β i)] {r : ι -> ι -> Prop}, (WellFounded.{succ u1} ι r) -> (forall {x : forall (i : ι), β i} {y : forall (i : ι), β i}, (LT.lt.{max u1 u2} (forall (i : ι), β i) (Preorder.toLT.{max u1 u2} (forall (i : ι), β i) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u2} (β i) (_inst_1 i)))) x y) -> (Pi.Lex.{u1, u2} ι (fun (i : ι) => β i) r (fun (i : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.822 : β i) (x._@.Mathlib.Data.Pi.Lex._hyg.824 : β i) => LT.lt.{u2} (β i) (Preorder.toLT.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_1 i))) x._@.Mathlib.Data.Pi.Lex._hyg.822 x._@.Mathlib.Data.Pi.Lex._hyg.824) x y))
 Case conversion may be inaccurate. Consider using '#align pi.lex_lt_of_lt Pi.lex_lt_of_ltₓ'. -/
 theorem lex_lt_of_lt [∀ i, PartialOrder (β i)] {r} (hwf : WellFounded r) {x y : ∀ i, β i}
-    (hlt : x < y) : Pi.Lex r (fun i => (· < ·)) x y :=
-  by
-  simp_rw [Pi.Lex, le_antisymm_iff]
+    (hlt : x < y) : Pi.Lex r (fun i => (· < ·)) x y := by simp_rw [Pi.Lex, le_antisymm_iff];
   exact lex_lt_of_lt_of_preorder hwf hlt
 #align pi.lex_lt_of_lt Pi.lex_lt_of_lt
 
@@ -110,8 +108,7 @@ theorem isTrichotomous_lex [∀ i, IsTrichotomous (β i) s] (wf : WellFounded r)
       · rw [Function.ne_iff] at hab
         let i := wf.min _ hab
         have hri : ∀ j, r j i → a j = b j := by
-          intro j
-          rw [← not_imp_not]
+          intro j; rw [← not_imp_not]
           exact fun h' => wf.not_lt_min _ _ h'
         have hne : a i ≠ b i := wf.min_mem _ hab
         cases' trichotomous_of s (a i) (b i) with hi hi
@@ -166,9 +163,7 @@ Case conversion may be inaccurate. Consider using '#align pi.to_lex_monotone Pi.
 theorem toLex_monotone : Monotone (@toLex (∀ i, β i)) := fun a b h =>
   or_iff_not_imp_left.2 fun hne =>
     let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min { i | a i ≠ b i } (Function.ne_iff.1 hne)
-    ⟨i, fun j hj => by
-      contrapose! hl
-      exact ⟨j, hl, hj⟩, (h i).lt_of_ne hi⟩
+    ⟨i, fun j hj => by contrapose! hl; exact ⟨j, hl, hj⟩, (h i).lt_of_ne hi⟩
 #align pi.to_lex_monotone Pi.toLex_monotone
 
 /- warning: pi.to_lex_strict_mono -> Pi.toLex_strictMono is a dubious translation:
@@ -179,9 +174,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align pi.to_lex_strict_mono Pi.toLex_strictMonoₓ'. -/
 theorem toLex_strictMono : StrictMono (@toLex (∀ i, β i)) := fun a b h =>
   let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min { i | a i ≠ b i } (Function.ne_iff.1 h.Ne)
-  ⟨i, fun j hj => by
-    contrapose! hl
-    exact ⟨j, hl, hj⟩, (h.le i).lt_of_ne hi⟩
+  ⟨i, fun j hj => by contrapose! hl; exact ⟨j, hl, hj⟩, (h.le i).lt_of_ne hi⟩
 #align pi.to_lex_strict_mono Pi.toLex_strictMono
 
 /- warning: pi.lt_to_lex_update_self_iff -> Pi.lt_toLex_update_self_iff is a dubious translation:

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

@@ -67,7 +67,7 @@ theorem toLex_apply (x : ∀ i, β i) (i : ι) : toLex x i = x i :=
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} (x : Lex.{max u1 u2} (forall (i : ι), β i)) (i : ι), Eq.{succ u2} (β i) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (forall (i : ι), β i)) (forall (i : ι), β i)) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (forall (i : ι), β i)) (forall (i : ι), β i)) => (Lex.{max u1 u2} (forall (i : ι), β i)) -> (forall (i : ι), β i)) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (forall (i : ι), β i)) (forall (i : ι), β i)) (ofLex.{max u1 u2} (forall (i : ι), β i)) x i) (x i)
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} (x : Lex.{max u2 u1} (forall (i : ι), β i)) (i : ι), Eq.{succ u1} (β i) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Lex.{max u2 u1} (forall (i : ι), β i)) (forall (i : ι), β i)) (Lex.{max u2 u1} (forall (i : ι), β i)) (fun (_x : Lex.{max u2 u1} (forall (i : ι), β i)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Lex.{max u2 u1} (forall (i : ι), β i)) => forall (i : ι), β i) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Lex.{max u2 u1} (forall (i : ι), β i)) (forall (i : ι), β i)) (ofLex.{max u2 u1} (forall (i : ι), β i)) x i) (x i)
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} (x : Lex.{max u2 u1} (forall (i : ι), β i)) (i : ι), Eq.{succ u1} (β i) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Lex.{max u2 u1} (forall (i : ι), β i)) (forall (i : ι), β i)) (Lex.{max u2 u1} (forall (i : ι), β i)) (fun (_x : Lex.{max u2 u1} (forall (i : ι), β i)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Lex.{max u2 u1} (forall (i : ι), β i)) => forall (i : ι), β i) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Lex.{max u2 u1} (forall (i : ι), β i)) (forall (i : ι), β i)) (ofLex.{max u2 u1} (forall (i : ι), β i)) x i) (x i)
 Case conversion may be inaccurate. Consider using '#align pi.of_lex_apply Pi.ofLex_applyₓ'. -/
 @[simp]
 theorem ofLex_apply (x : Lex (∀ i, β i)) (i : ι) : ofLex x i = x i :=
@@ -161,7 +161,7 @@ open Function
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)], Monotone.{max u1 u2, max u1 u2} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)))
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.1683 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.1685 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.1683 x._@.Mathlib.Data.Pi.Lex._hyg.1685)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)], Monotone.{max u2 u1, max u2 u1} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.preorder.{u2, u1} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)))
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.1683 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.1685 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.1683 x._@.Mathlib.Data.Pi.Lex._hyg.1685)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)], Monotone.{max u2 u1, max u2 u1} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.preorder.{u2, u1} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)))
 Case conversion may be inaccurate. Consider using '#align pi.to_lex_monotone Pi.toLex_monotoneₓ'. -/
 theorem toLex_monotone : Monotone (@toLex (∀ i, β i)) := fun a b h =>
   or_iff_not_imp_left.2 fun hne =>
@@ -175,7 +175,7 @@ theorem toLex_monotone : Monotone (@toLex (∀ i, β i)) := fun a b h =>
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)], StrictMono.{max u1 u2, max u1 u2} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)))
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.1870 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.1872 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.1870 x._@.Mathlib.Data.Pi.Lex._hyg.1872)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)], StrictMono.{max u2 u1, max u2 u1} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.preorder.{u2, u1} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)))
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.1870 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.1872 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.1870 x._@.Mathlib.Data.Pi.Lex._hyg.1872)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)], StrictMono.{max u2 u1, max u2 u1} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.preorder.{u2, u1} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)))
 Case conversion may be inaccurate. Consider using '#align pi.to_lex_strict_mono Pi.toLex_strictMonoₓ'. -/
 theorem toLex_strictMono : StrictMono (@toLex (∀ i, β i)) := fun a b h =>
   let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min { i | a i ≠ b i } (Function.ne_iff.1 h.Ne)
@@ -188,7 +188,7 @@ theorem toLex_strictMono : StrictMono (@toLex (∀ i, β i)) := fun a b h =>
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{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 : ι) => Preorder.toHasLt.{u2} (β a) (PartialOrder.toPreorder.{u2} (β a) (_inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a))) (LT.lt.{u2} (β i) (Preorder.toHasLt.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (x i) a)
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2053 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2055 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2053 x._@.Mathlib.Data.Pi.Lex._hyg.2055)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Pi.instLTLexForAll.{u2, u1} ι (fun (i : ι) => β i) (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) (fun (a : ι) => Preorder.toLT.{u1} (β a) (PartialOrder.toPreorder.{u1} (β a) (_inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a))) (LT.lt.{u1} (β i) (Preorder.toLT.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (x i) a)
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2053 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2055 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2053 x._@.Mathlib.Data.Pi.Lex._hyg.2055)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Pi.instLTLexForAll.{u2, u1} ι (fun (i : ι) => β i) (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) (fun (a : ι) => Preorder.toLT.{u1} (β a) (PartialOrder.toPreorder.{u1} (β a) (_inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a))) (LT.lt.{u1} (β i) (Preorder.toLT.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (x i) a)
 Case conversion may be inaccurate. Consider using '#align pi.lt_to_lex_update_self_iff Pi.lt_toLex_update_self_iffₓ'. -/
 @[simp]
 theorem lt_toLex_update_self_iff : toLex x < toLex (update x i a) ↔ x i < a :=
@@ -207,7 +207,7 @@ theorem lt_toLex_update_self_iff : toLex x < toLex (update x i a) ↔ x i < a :=
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (Pi.Lex.hasLt.{u1, u2} ι (fun (a : ι) => β a) (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))) (fun (a : ι) => Preorder.toHasLt.{u2} (β a) (PartialOrder.toPreorder.{u2} (β a) (_inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x)) (LT.lt.{u2} (β i) (Preorder.toHasLt.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) a (x i))
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2351 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2353 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2351 x._@.Mathlib.Data.Pi.Lex._hyg.2353)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Pi.instLTLexForAll.{u2, u1} ι (fun (a : ι) => β a) (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) (fun (a : ι) => Preorder.toLT.{u1} (β a) (PartialOrder.toPreorder.{u1} (β a) (_inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x)) (LT.lt.{u1} (β i) (Preorder.toLT.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) a (x i))
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2351 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2353 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2351 x._@.Mathlib.Data.Pi.Lex._hyg.2353)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Pi.instLTLexForAll.{u2, u1} ι (fun (a : ι) => β a) (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) (fun (a : ι) => Preorder.toLT.{u1} (β a) (PartialOrder.toPreorder.{u1} (β a) (_inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x)) (LT.lt.{u1} (β i) (Preorder.toLT.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) a (x i))
 Case conversion may be inaccurate. Consider using '#align pi.to_lex_update_lt_self_iff Pi.toLex_update_lt_self_iffₓ'. -/
 @[simp]
 theorem toLex_update_lt_self_iff : toLex (update x i a) < toLex x ↔ a < x i :=
@@ -226,7 +226,7 @@ theorem toLex_update_lt_self_iff : toLex (update x i a) < toLex x ↔ a < x i :=
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Preorder.toHasLe.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a))) (LE.le.{u2} (β i) (Preorder.toHasLe.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (x i) a)
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2649 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2651 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2649 x._@.Mathlib.Data.Pi.Lex._hyg.2651)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Preorder.toLE.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (PartialOrder.toPreorder.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a))) (LE.le.{u1} (β i) (Preorder.toLE.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (x i) a)
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2649 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2651 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2649 x._@.Mathlib.Data.Pi.Lex._hyg.2651)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Preorder.toLE.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (PartialOrder.toPreorder.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a))) (LE.le.{u1} (β i) (Preorder.toLE.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (x i) a)
 Case conversion may be inaccurate. Consider using '#align pi.le_to_lex_update_self_iff Pi.le_toLex_update_self_iffₓ'. -/
 @[simp]
 theorem le_toLex_update_self_iff : toLex x ≤ toLex (update x i a) ↔ x i ≤ a := by
@@ -237,7 +237,7 @@ theorem le_toLex_update_self_iff : toLex x ≤ toLex (update x i a) ↔ x i ≤
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (Preorder.toHasLe.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (a : ι) => β a) _inst_1 (fun (a : ι) => _inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x)) (LE.le.{u2} (β i) (Preorder.toHasLe.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) a (x i))
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2745 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2747 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2745 x._@.Mathlib.Data.Pi.Lex._hyg.2747)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Preorder.toLE.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (PartialOrder.toPreorder.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (a : ι) => β a) _inst_1 (fun (a : ι) => _inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x)) (LE.le.{u1} (β i) (Preorder.toLE.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) a (x i))
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2745 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2747 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2745 x._@.Mathlib.Data.Pi.Lex._hyg.2747)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Preorder.toLE.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (PartialOrder.toPreorder.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (a : ι) => β a) _inst_1 (fun (a : ι) => _inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x)) (LE.le.{u1} (β i) (Preorder.toLE.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) a (x i))
 Case conversion may be inaccurate. Consider using '#align pi.to_lex_update_le_self_iff Pi.toLex_update_le_self_iffₓ'. -/
 @[simp]
 theorem toLex_update_le_self_iff : toLex (update x i a) ≤ toLex x ↔ a ≤ x i := by
@@ -315,7 +315,7 @@ instance Lex.orderedCommGroup [LinearOrder ι] [∀ a, OrderedCommGroup (β a)]
 lean 3 declaration is
   forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : Preorder.{u2} α] {f : ι -> α} {i : ι} {j : ι}, (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι _inst_1) i j) -> (LT.lt.{u2} α (Preorder.toHasLt.{u2} α _inst_3) (f j) (f i)) -> (LT.lt.{max u1 u2} (Lex.{max u1 u2} (ι -> α)) (Pi.Lex.hasLt.{u1, u2} ι (fun (ᾰ : ι) => α) (Preorder.toHasLt.{u1} ι _inst_1) (fun (a : ι) => Preorder.toHasLt.{u2} α _inst_3)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) => (ι -> α) -> (Lex.{max u1 u2} (ι -> α))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (toLex.{max u1 u2} (ι -> α)) (Function.comp.{succ u1, succ u1, succ u2} ι ι α f (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} ι) (fun (_x : Equiv.{succ u1, succ u1} ι ι) => ι -> ι) (Equiv.hasCoeToFun.{succ u1, succ u1} ι ι) (Equiv.swap.{succ u1} ι (fun (a : ι) (b : ι) => _inst_2 a b) i j)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) => (ι -> α) -> (Lex.{max u1 u2} (ι -> α))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (toLex.{max u1 u2} (ι -> α)) f))
 but is expected to have type
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : Preorder.{u2} α] {f : ι -> α} {i : ι} {j : ι}, (LT.lt.{u1} ι (Preorder.toLT.{u1} ι _inst_1) i j) -> (LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_3) (f j) (f i)) -> (LT.lt.{max u1 u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ι -> α) => Lex.{max u1 u2} (ι -> α)) (Function.comp.{succ u1, succ u1, succ u2} ι ι α f (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} ι) ι (fun (a : ι) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ι) => ι) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} ι ι) (Equiv.swap.{succ u1} ι (fun (a : ι) (b : ι) => _inst_2 a b) i j)))) (Pi.instLTLexForAll.{u1, u2} ι (fun (ᾰ : ι) => α) (Preorder.toLT.{u1} ι _inst_1) (fun (a : ι) => Preorder.toLT.{u2} α _inst_3)) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (ι -> α) (fun (_x : ι -> α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ι -> α) => Lex.{max u1 u2} (ι -> α)) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (toLex.{max u1 u2} (ι -> α)) (Function.comp.{succ u1, succ u1, succ u2} ι ι α f (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} ι) ι (fun (_x : ι) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ι) => ι) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} ι ι) (Equiv.swap.{succ u1} ι (fun (a : ι) (b : ι) => _inst_2 a b) i j)))) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (ι -> α) (fun (_x : ι -> α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ι -> α) => Lex.{max u1 u2} (ι -> α)) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (toLex.{max u1 u2} (ι -> α)) f))
+  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : Preorder.{u2} α] {f : ι -> α} {i : ι} {j : ι}, (LT.lt.{u1} ι (Preorder.toLT.{u1} ι _inst_1) i j) -> (LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_3) (f j) (f i)) -> (LT.lt.{max u1 u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ι -> α) => Lex.{max u1 u2} (ι -> α)) (Function.comp.{succ u1, succ u1, succ u2} ι ι α f (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} ι) ι (fun (a : ι) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ι) => ι) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} ι ι) (Equiv.swap.{succ u1} ι (fun (a : ι) (b : ι) => _inst_2 a b) i j)))) (Pi.instLTLexForAll.{u1, u2} ι (fun (ᾰ : ι) => α) (Preorder.toLT.{u1} ι _inst_1) (fun (a : ι) => Preorder.toLT.{u2} α _inst_3)) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (ι -> α) (fun (_x : ι -> α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ι -> α) => Lex.{max u1 u2} (ι -> α)) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (toLex.{max u1 u2} (ι -> α)) (Function.comp.{succ u1, succ u1, succ u2} ι ι α f (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} ι) ι (fun (_x : ι) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ι) => ι) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} ι ι) (Equiv.swap.{succ u1} ι (fun (a : ι) (b : ι) => _inst_2 a b) i j)))) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (ι -> α) (fun (_x : ι -> α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ι -> α) => Lex.{max u1 u2} (ι -> α)) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (toLex.{max u1 u2} (ι -> α)) f))
 Case conversion may be inaccurate. Consider using '#align pi.lex_desc Pi.lex_descₓ'. -/
 /-- If we swap two strictly decreasing values in a function, then the result is lexicographically
 smaller than the original function. -/

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

@@ -74,23 +74,31 @@ theorem ofLex_apply (x : Lex (∀ i, β i)) (i : ι) : ofLex x i = x i :=
   rfl
 #align pi.of_lex_apply Pi.ofLex_apply
 
-#print Pi.lex_lt_of_lt_of_preorder /-
+/- warning: pi.lex_lt_of_lt_of_preorder -> Pi.lex_lt_of_lt_of_preorder is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : forall (i : ι), Preorder.{u2} (β i)] {r : ι -> ι -> Prop}, (WellFounded.{succ u1} ι r) -> (forall {x : forall (i : ι), β i} {y : forall (i : ι), β i}, (LT.lt.{max u1 u2} (forall (i : ι), β i) (Preorder.toHasLt.{max u1 u2} (forall (i : ι), β i) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => _inst_1 i))) x y) -> (Exists.{succ u1} ι (fun (i : ι) => And (forall (j : ι), (r j i) -> (And (LE.le.{u2} (β j) (Preorder.toHasLe.{u2} (β j) (_inst_1 j)) (x j) (y j)) (LE.le.{u2} (β j) (Preorder.toHasLe.{u2} (β j) (_inst_1 j)) (y j) (x j)))) (LT.lt.{u2} (β i) (Preorder.toHasLt.{u2} (β i) (_inst_1 i)) (x i) (y i)))))
+but is expected to have type
+  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : forall (i : ι), Preorder.{u2} (β i)] {r : ι -> ι -> Prop}, (WellFounded.{succ u1} ι r) -> (forall {x : forall (i : ι), β i} {y : forall (i : ι), β i}, (LT.lt.{max u1 u2} (forall (i : ι), β i) (Preorder.toLT.{max u1 u2} (forall (i : ι), β i) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => _inst_1 i))) x y) -> (Exists.{succ u1} ι (fun (i : ι) => And (forall (j : ι), (r j i) -> (And (LE.le.{u2} (β j) (Preorder.toLE.{u2} (β j) (_inst_1 j)) (x j) (y j)) (LE.le.{u2} (β j) (Preorder.toLE.{u2} (β j) (_inst_1 j)) (y j) (x j)))) (LT.lt.{u2} (β i) (Preorder.toLT.{u2} (β i) (_inst_1 i)) (x i) (y i)))))
+Case conversion may be inaccurate. Consider using '#align pi.lex_lt_of_lt_of_preorder Pi.lex_lt_of_lt_of_preorderₓ'. -/
 theorem lex_lt_of_lt_of_preorder [∀ i, Preorder (β i)] {r} (hwf : WellFounded r) {x y : ∀ i, β i}
     (hlt : x < y) : ∃ i, (∀ j, r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i :=
   let h' := Pi.lt_def.1 hlt
   let ⟨i, hi, hl⟩ := hwf.has_min _ h'.2
   ⟨i, fun j hj => ⟨h'.1 j, Classical.not_not.1 fun h => hl j (lt_of_le_not_le (h'.1 j) h) hj⟩, hi⟩
 #align pi.lex_lt_of_lt_of_preorder Pi.lex_lt_of_lt_of_preorder
--/
 
-#print Pi.lex_lt_of_lt /-
+/- warning: pi.lex_lt_of_lt -> Pi.lex_lt_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : forall (i : ι), PartialOrder.{u2} (β i)] {r : ι -> ι -> Prop}, (WellFounded.{succ u1} ι r) -> (forall {x : forall (i : ι), β i} {y : forall (i : ι), β i}, (LT.lt.{max u1 u2} (forall (i : ι), β i) (Preorder.toHasLt.{max u1 u2} (forall (i : ι), β i) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u2} (β i) (_inst_1 i)))) x y) -> (Pi.Lex.{u1, u2} ι (fun (i : ι) => β i) r (fun (i : ι) => LT.lt.{u2} (β i) (Preorder.toHasLt.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_1 i)))) x y))
+but is expected to have type
+  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : forall (i : ι), PartialOrder.{u2} (β i)] {r : ι -> ι -> Prop}, (WellFounded.{succ u1} ι r) -> (forall {x : forall (i : ι), β i} {y : forall (i : ι), β i}, (LT.lt.{max u1 u2} (forall (i : ι), β i) (Preorder.toLT.{max u1 u2} (forall (i : ι), β i) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u2} (β i) (_inst_1 i)))) x y) -> (Pi.Lex.{u1, u2} ι (fun (i : ι) => β i) r (fun (i : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.822 : β i) (x._@.Mathlib.Data.Pi.Lex._hyg.824 : β i) => LT.lt.{u2} (β i) (Preorder.toLT.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_1 i))) x._@.Mathlib.Data.Pi.Lex._hyg.822 x._@.Mathlib.Data.Pi.Lex._hyg.824) x y))
+Case conversion may be inaccurate. Consider using '#align pi.lex_lt_of_lt Pi.lex_lt_of_ltₓ'. -/
 theorem lex_lt_of_lt [∀ i, PartialOrder (β i)] {r} (hwf : WellFounded r) {x y : ∀ i, β i}
     (hlt : x < y) : Pi.Lex r (fun i => (· < ·)) x y :=
   by
   simp_rw [Pi.Lex, le_antisymm_iff]
   exact lex_lt_of_lt_of_preorder hwf hlt
 #align pi.lex_lt_of_lt Pi.lex_lt_of_lt
--/
 
 #print Pi.isTrichotomous_lex /-
 theorem isTrichotomous_lex [∀ i, IsTrichotomous (β i) s] (wf : WellFounded r) :
@@ -115,7 +123,12 @@ theorem isTrichotomous_lex [∀ i, IsTrichotomous (β i) s] (wf : WellFounded r)
 instance [LT ι] [∀ a, LT (β a)] : LT (Lex (∀ i, β i)) :=
   ⟨Pi.Lex (· < ·) fun _ => (· < ·)⟩
 
-#print Pi.Lex.isStrictOrder /-
+/- warning: pi.lex.is_strict_order -> Pi.Lex.isStrictOrder is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : forall (a : ι), PartialOrder.{u2} (β a)], IsStrictOrder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (LT.lt.{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 : ι) => Preorder.toHasLt.{u2} (β a) (PartialOrder.toPreorder.{u2} (β a) (_inst_2 a)))))
+but is expected to have type
+  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : forall (a : ι), PartialOrder.{u2} (β a)], IsStrictOrder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (fun (x._@.Mathlib.Data.Pi.Lex._hyg.1246 : Lex.{max u1 u2} (forall (i : ι), β i)) (x._@.Mathlib.Data.Pi.Lex._hyg.1248 : Lex.{max u1 u2} (forall (i : ι), β i)) => LT.lt.{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 : ι) => Preorder.toLT.{u2} (β a) (PartialOrder.toPreorder.{u2} (β a) (_inst_2 a)))) x._@.Mathlib.Data.Pi.Lex._hyg.1246 x._@.Mathlib.Data.Pi.Lex._hyg.1248)
+Case conversion may be inaccurate. Consider using '#align pi.lex.is_strict_order Pi.Lex.isStrictOrderₓ'. -/
 instance Lex.isStrictOrder [LinearOrder ι] [∀ a, PartialOrder (β a)] :
     IsStrictOrder (Lex (∀ i, β i)) (· < ·)
     where
@@ -127,7 +140,6 @@ instance Lex.isStrictOrder [LinearOrder ι] [∀ a, PartialOrder (β a)] :
       ⟨N₁, fun j hj => (lt_N₁ _ hj).trans (lt_N₂ _ hj), a_lt_b.trans b_lt_c⟩,
       ⟨N₂, fun j hj => (lt_N₁ _ (hj.trans H)).trans (lt_N₂ _ hj), (lt_N₁ _ H).symm ▸ b_lt_c⟩]
 #align pi.lex.is_strict_order Pi.Lex.isStrictOrder
--/
 
 instance [LinearOrder ι] [∀ a, PartialOrder (β a)] : PartialOrder (Lex (∀ i, β i)) :=
   partialOrderOfSO (· < ·)
@@ -147,7 +159,7 @@ open Function
 
 /- warning: pi.to_lex_monotone -> Pi.toLex_monotone is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)], Monotone.{max u1 u2, max u1 u2} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)))
+  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)], Monotone.{max u1 u2, max u1 u2} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)))
 but is expected to have type
   forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.1683 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.1685 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.1683 x._@.Mathlib.Data.Pi.Lex._hyg.1685)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)], Monotone.{max u2 u1, max u2 u1} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.preorder.{u2, u1} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)))
 Case conversion may be inaccurate. Consider using '#align pi.to_lex_monotone Pi.toLex_monotoneₓ'. -/
@@ -161,7 +173,7 @@ theorem toLex_monotone : Monotone (@toLex (∀ i, β i)) := fun a b h =>
 
 /- warning: pi.to_lex_strict_mono -> Pi.toLex_strictMono is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)], StrictMono.{max u1 u2, max u1 u2} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)))
+  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)], StrictMono.{max u1 u2, max u1 u2} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)))
 but is expected to have type
   forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.1870 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.1872 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.1870 x._@.Mathlib.Data.Pi.Lex._hyg.1872)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)], StrictMono.{max u2 u1, max u2 u1} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.preorder.{u2, u1} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)))
 Case conversion may be inaccurate. Consider using '#align pi.to_lex_strict_mono Pi.toLex_strictMonoₓ'. -/
@@ -174,7 +186,7 @@ theorem toLex_strictMono : StrictMono (@toLex (∀ i, β i)) := fun a b h =>
 
 /- warning: pi.lt_to_lex_update_self_iff -> Pi.lt_toLex_update_self_iff is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.hasLt.{u1, u2} ι (fun (i : ι) => β i) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))) (fun (a : ι) => Preorder.toLT.{u2} (β a) (PartialOrder.toPreorder.{u2} (β a) (_inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a))) (LT.lt.{u2} (β i) (Preorder.toLT.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (x i) a)
+  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{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 : ι) => Preorder.toHasLt.{u2} (β a) (PartialOrder.toPreorder.{u2} (β a) (_inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a))) (LT.lt.{u2} (β i) (Preorder.toHasLt.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (x i) a)
 but is expected to have type
   forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2053 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2055 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2053 x._@.Mathlib.Data.Pi.Lex._hyg.2055)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Pi.instLTLexForAll.{u2, u1} ι (fun (i : ι) => β i) (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) (fun (a : ι) => Preorder.toLT.{u1} (β a) (PartialOrder.toPreorder.{u1} (β a) (_inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a))) (LT.lt.{u1} (β i) (Preorder.toLT.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (x i) a)
 Case conversion may be inaccurate. Consider using '#align pi.lt_to_lex_update_self_iff Pi.lt_toLex_update_self_iffₓ'. -/
@@ -193,7 +205,7 @@ theorem lt_toLex_update_self_iff : toLex x < toLex (update x i a) ↔ x i < a :=
 
 /- warning: pi.to_lex_update_lt_self_iff -> Pi.toLex_update_lt_self_iff is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (Pi.Lex.hasLt.{u1, u2} ι (fun (a : ι) => β a) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))) (fun (a : ι) => Preorder.toLT.{u2} (β a) (PartialOrder.toPreorder.{u2} (β a) (_inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x)) (LT.lt.{u2} (β i) (Preorder.toLT.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) a (x i))
+  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (Pi.Lex.hasLt.{u1, u2} ι (fun (a : ι) => β a) (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))) (fun (a : ι) => Preorder.toHasLt.{u2} (β a) (PartialOrder.toPreorder.{u2} (β a) (_inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x)) (LT.lt.{u2} (β i) (Preorder.toHasLt.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) a (x i))
 but is expected to have type
   forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2351 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2353 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2351 x._@.Mathlib.Data.Pi.Lex._hyg.2353)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Pi.instLTLexForAll.{u2, u1} ι (fun (a : ι) => β a) (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) (fun (a : ι) => Preorder.toLT.{u1} (β a) (PartialOrder.toPreorder.{u1} (β a) (_inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x)) (LT.lt.{u1} (β i) (Preorder.toLT.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) a (x i))
 Case conversion may be inaccurate. Consider using '#align pi.to_lex_update_lt_self_iff Pi.toLex_update_lt_self_iffₓ'. -/
@@ -212,7 +224,7 @@ theorem toLex_update_lt_self_iff : toLex (update x i a) < toLex x ↔ a < x i :=
 
 /- warning: pi.le_to_lex_update_self_iff -> Pi.le_toLex_update_self_iff is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Preorder.toLE.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a))) (LE.le.{u2} (β i) (Preorder.toLE.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (x i) a)
+  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Preorder.toHasLe.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a))) (LE.le.{u2} (β i) (Preorder.toHasLe.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (x i) a)
 but is expected to have type
   forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2649 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2651 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2649 x._@.Mathlib.Data.Pi.Lex._hyg.2651)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Preorder.toLE.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (PartialOrder.toPreorder.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a))) (LE.le.{u1} (β i) (Preorder.toLE.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (x i) a)
 Case conversion may be inaccurate. Consider using '#align pi.le_to_lex_update_self_iff Pi.le_toLex_update_self_iffₓ'. -/
@@ -223,7 +235,7 @@ theorem le_toLex_update_self_iff : toLex x ≤ toLex (update x i a) ↔ x i ≤
 
 /- warning: pi.to_lex_update_le_self_iff -> Pi.toLex_update_le_self_iff is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (Preorder.toLE.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (a : ι) => β a) _inst_1 (fun (a : ι) => _inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x)) (LE.le.{u2} (β i) (Preorder.toLE.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) a (x i))
+  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (Preorder.toHasLe.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (a : ι) => β a) _inst_1 (fun (a : ι) => _inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x)) (LE.le.{u2} (β i) (Preorder.toHasLe.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) a (x i))
 but is expected to have type
   forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2745 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2747 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2745 x._@.Mathlib.Data.Pi.Lex._hyg.2747)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Preorder.toLE.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (PartialOrder.toPreorder.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (a : ι) => β a) _inst_1 (fun (a : ι) => _inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x)) (LE.le.{u1} (β i) (Preorder.toLE.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) a (x i))
 Case conversion may be inaccurate. Consider using '#align pi.to_lex_update_le_self_iff Pi.toLex_update_le_self_iffₓ'. -/
@@ -260,7 +272,7 @@ instance [Preorder ι] [∀ i, LT (β i)] [∀ i, DenselyOrdered (β i)] :
 
 /- warning: pi.lex.no_max_order' -> Pi.Lex.noMaxOrder' is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), LT.{u2} (β i)] (i : ι) [_inst_3 : NoMaxOrder.{u2} (β i) (_inst_2 i)], NoMaxOrder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.hasLt.{u1, u2} ι (fun (i : ι) => β i) (Preorder.toLT.{u1} ι _inst_1) (fun (a : ι) => _inst_2 a))
+  forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), LT.{u2} (β i)] (i : ι) [_inst_3 : NoMaxOrder.{u2} (β i) (_inst_2 i)], NoMaxOrder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.hasLt.{u1, u2} ι (fun (i : ι) => β i) (Preorder.toHasLt.{u1} ι _inst_1) (fun (a : ι) => _inst_2 a))
 but is expected to have type
   forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : Preorder.{u2} ι] [_inst_2 : forall (i : ι), LT.{u1} (β i)] (i : ι) [_inst_3 : NoMaxOrder.{u1} (β i) (_inst_2 i)], NoMaxOrder.{max u2 u1} (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.instLTLexForAll.{u2, u1} ι (fun (i : ι) => β i) (Preorder.toLT.{u2} ι _inst_1) (fun (a : ι) => _inst_2 a))
 Case conversion may be inaccurate. Consider using '#align pi.lex.no_max_order' Pi.Lex.noMaxOrder'ₓ'. -/
@@ -299,7 +311,12 @@ instance Lex.orderedCommGroup [LinearOrder ι] [∀ a, OrderedCommGroup (β a)]
 #align pi.lex.ordered_add_comm_group Pi.Lex.orderedAddCommGroup
 -/
 
-#print Pi.lex_desc /-
+/- warning: pi.lex_desc -> Pi.lex_desc is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : Preorder.{u2} α] {f : ι -> α} {i : ι} {j : ι}, (LT.lt.{u1} ι (Preorder.toHasLt.{u1} ι _inst_1) i j) -> (LT.lt.{u2} α (Preorder.toHasLt.{u2} α _inst_3) (f j) (f i)) -> (LT.lt.{max u1 u2} (Lex.{max u1 u2} (ι -> α)) (Pi.Lex.hasLt.{u1, u2} ι (fun (ᾰ : ι) => α) (Preorder.toHasLt.{u1} ι _inst_1) (fun (a : ι) => Preorder.toHasLt.{u2} α _inst_3)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) => (ι -> α) -> (Lex.{max u1 u2} (ι -> α))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (toLex.{max u1 u2} (ι -> α)) (Function.comp.{succ u1, succ u1, succ u2} ι ι α f (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} ι) (fun (_x : Equiv.{succ u1, succ u1} ι ι) => ι -> ι) (Equiv.hasCoeToFun.{succ u1, succ u1} ι ι) (Equiv.swap.{succ u1} ι (fun (a : ι) (b : ι) => _inst_2 a b) i j)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) => (ι -> α) -> (Lex.{max u1 u2} (ι -> α))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (toLex.{max u1 u2} (ι -> α)) f))
+but is expected to have type
+  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : DecidableEq.{succ u1} ι] [_inst_3 : Preorder.{u2} α] {f : ι -> α} {i : ι} {j : ι}, (LT.lt.{u1} ι (Preorder.toLT.{u1} ι _inst_1) i j) -> (LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_3) (f j) (f i)) -> (LT.lt.{max u1 u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ι -> α) => Lex.{max u1 u2} (ι -> α)) (Function.comp.{succ u1, succ u1, succ u2} ι ι α f (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} ι) ι (fun (a : ι) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ι) => ι) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} ι ι) (Equiv.swap.{succ u1} ι (fun (a : ι) (b : ι) => _inst_2 a b) i j)))) (Pi.instLTLexForAll.{u1, u2} ι (fun (ᾰ : ι) => α) (Preorder.toLT.{u1} ι _inst_1) (fun (a : ι) => Preorder.toLT.{u2} α _inst_3)) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (ι -> α) (fun (_x : ι -> α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ι -> α) => Lex.{max u1 u2} (ι -> α)) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (toLex.{max u1 u2} (ι -> α)) (Function.comp.{succ u1, succ u1, succ u2} ι ι α f (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} ι) ι (fun (_x : ι) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ι) => ι) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} ι ι) (Equiv.swap.{succ u1} ι (fun (a : ι) (b : ι) => _inst_2 a b) i j)))) (FunLike.coe.{succ (max u1 u2), succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (ι -> α) (fun (_x : ι -> α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ι -> α) => Lex.{max u1 u2} (ι -> α)) _x) (Equiv.instFunLikeEquiv.{succ (max u1 u2), succ (max u1 u2)} (ι -> α) (Lex.{max u1 u2} (ι -> α))) (toLex.{max u1 u2} (ι -> α)) f))
+Case conversion may be inaccurate. Consider using '#align pi.lex_desc Pi.lex_descₓ'. -/
 /-- If we swap two strictly decreasing values in a function, then the result is lexicographically
 smaller than the original function. -/
 theorem lex_desc {α} [Preorder ι] [DecidableEq ι] [Preorder α] {f : ι → α} {i j : ι} (h₁ : i < j)
@@ -307,7 +324,6 @@ theorem lex_desc {α} [Preorder ι] [DecidableEq ι] [Preorder α] {f : ι → 
   ⟨i, fun k hik => congr_arg f (Equiv.swap_apply_of_ne_of_ne hik.Ne (hik.trans h₁).Ne), by
     simpa only [Pi.toLex_apply, Function.comp_apply, Equiv.swap_apply_left] using h₂⟩
 #align pi.lex_desc Pi.lex_desc
--/
 
 end Pi
 

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

@@ -149,7 +149,7 @@ open Function
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)], Monotone.{max u1 u2, max u1 u2} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)))
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.1685 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.1687 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.1685 x._@.Mathlib.Data.Pi.Lex._hyg.1687)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)], Monotone.{max u2 u1, max u2 u1} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.preorder.{u2, u1} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)))
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.1683 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.1685 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.1683 x._@.Mathlib.Data.Pi.Lex._hyg.1685)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)], Monotone.{max u2 u1, max u2 u1} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.preorder.{u2, u1} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)))
 Case conversion may be inaccurate. Consider using '#align pi.to_lex_monotone Pi.toLex_monotoneₓ'. -/
 theorem toLex_monotone : Monotone (@toLex (∀ i, β i)) := fun a b h =>
   or_iff_not_imp_left.2 fun hne =>
@@ -163,7 +163,7 @@ theorem toLex_monotone : Monotone (@toLex (∀ i, β i)) := fun a b h =>
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)], StrictMono.{max u1 u2, max u1 u2} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)))
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.1872 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.1874 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.1872 x._@.Mathlib.Data.Pi.Lex._hyg.1874)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)], StrictMono.{max u2 u1, max u2 u1} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.preorder.{u2, u1} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)))
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.1870 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.1872 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.1870 x._@.Mathlib.Data.Pi.Lex._hyg.1872)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)], StrictMono.{max u2 u1, max u2 u1} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.preorder.{u2, u1} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)))
 Case conversion may be inaccurate. Consider using '#align pi.to_lex_strict_mono Pi.toLex_strictMonoₓ'. -/
 theorem toLex_strictMono : StrictMono (@toLex (∀ i, β i)) := fun a b h =>
   let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min { i | a i ≠ b i } (Function.ne_iff.1 h.Ne)
@@ -176,7 +176,7 @@ theorem toLex_strictMono : StrictMono (@toLex (∀ i, β i)) := fun a b h =>
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.hasLt.{u1, u2} ι (fun (i : ι) => β i) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))) (fun (a : ι) => Preorder.toLT.{u2} (β a) (PartialOrder.toPreorder.{u2} (β a) (_inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a))) (LT.lt.{u2} (β i) (Preorder.toLT.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (x i) a)
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2055 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2057 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2055 x._@.Mathlib.Data.Pi.Lex._hyg.2057)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Pi.instLTLexForAll.{u2, u1} ι (fun (i : ι) => β i) (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) (fun (a : ι) => Preorder.toLT.{u1} (β a) (PartialOrder.toPreorder.{u1} (β a) (_inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a))) (LT.lt.{u1} (β i) (Preorder.toLT.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (x i) a)
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2053 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2055 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2053 x._@.Mathlib.Data.Pi.Lex._hyg.2055)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Pi.instLTLexForAll.{u2, u1} ι (fun (i : ι) => β i) (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) (fun (a : ι) => Preorder.toLT.{u1} (β a) (PartialOrder.toPreorder.{u1} (β a) (_inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a))) (LT.lt.{u1} (β i) (Preorder.toLT.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (x i) a)
 Case conversion may be inaccurate. Consider using '#align pi.lt_to_lex_update_self_iff Pi.lt_toLex_update_self_iffₓ'. -/
 @[simp]
 theorem lt_toLex_update_self_iff : toLex x < toLex (update x i a) ↔ x i < a :=
@@ -195,7 +195,7 @@ theorem lt_toLex_update_self_iff : toLex x < toLex (update x i a) ↔ x i < a :=
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (Pi.Lex.hasLt.{u1, u2} ι (fun (a : ι) => β a) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))) (fun (a : ι) => Preorder.toLT.{u2} (β a) (PartialOrder.toPreorder.{u2} (β a) (_inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x)) (LT.lt.{u2} (β i) (Preorder.toLT.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) a (x i))
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2353 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2355 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2353 x._@.Mathlib.Data.Pi.Lex._hyg.2355)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Pi.instLTLexForAll.{u2, u1} ι (fun (a : ι) => β a) (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) (fun (a : ι) => Preorder.toLT.{u1} (β a) (PartialOrder.toPreorder.{u1} (β a) (_inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x)) (LT.lt.{u1} (β i) (Preorder.toLT.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) a (x i))
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2351 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2353 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2351 x._@.Mathlib.Data.Pi.Lex._hyg.2353)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Pi.instLTLexForAll.{u2, u1} ι (fun (a : ι) => β a) (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) (fun (a : ι) => Preorder.toLT.{u1} (β a) (PartialOrder.toPreorder.{u1} (β a) (_inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x)) (LT.lt.{u1} (β i) (Preorder.toLT.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) a (x i))
 Case conversion may be inaccurate. Consider using '#align pi.to_lex_update_lt_self_iff Pi.toLex_update_lt_self_iffₓ'. -/
 @[simp]
 theorem toLex_update_lt_self_iff : toLex (update x i a) < toLex x ↔ a < x i :=
@@ -214,7 +214,7 @@ theorem toLex_update_lt_self_iff : toLex (update x i a) < toLex x ↔ a < x i :=
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Preorder.toLE.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a))) (LE.le.{u2} (β i) (Preorder.toLE.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (x i) a)
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2651 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2653 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2651 x._@.Mathlib.Data.Pi.Lex._hyg.2653)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Preorder.toLE.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (PartialOrder.toPreorder.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a))) (LE.le.{u1} (β i) (Preorder.toLE.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (x i) a)
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2649 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2651 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2649 x._@.Mathlib.Data.Pi.Lex._hyg.2651)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Preorder.toLE.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (PartialOrder.toPreorder.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a))) (LE.le.{u1} (β i) (Preorder.toLE.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (x i) a)
 Case conversion may be inaccurate. Consider using '#align pi.le_to_lex_update_self_iff Pi.le_toLex_update_self_iffₓ'. -/
 @[simp]
 theorem le_toLex_update_self_iff : toLex x ≤ toLex (update x i a) ↔ x i ≤ a := by
@@ -225,7 +225,7 @@ theorem le_toLex_update_self_iff : toLex x ≤ toLex (update x i a) ↔ x i ≤
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (Preorder.toLE.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (a : ι) => β a) _inst_1 (fun (a : ι) => _inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x)) (LE.le.{u2} (β i) (Preorder.toLE.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) a (x i))
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2749 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2751 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2749 x._@.Mathlib.Data.Pi.Lex._hyg.2751)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Preorder.toLE.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (PartialOrder.toPreorder.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (a : ι) => β a) _inst_1 (fun (a : ι) => _inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x)) (LE.le.{u1} (β i) (Preorder.toLE.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) a (x i))
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2745 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2747 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2745 x._@.Mathlib.Data.Pi.Lex._hyg.2747)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Preorder.toLE.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (PartialOrder.toPreorder.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (a : ι) => β a) _inst_1 (fun (a : ι) => _inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x)) (LE.le.{u1} (β i) (Preorder.toLE.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) a (x i))
 Case conversion may be inaccurate. Consider using '#align pi.to_lex_update_le_self_iff Pi.toLex_update_le_self_iffₓ'. -/
 @[simp]
 theorem toLex_update_le_self_iff : toLex (update x i a) ≤ toLex x ↔ a ≤ x i := by

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

@@ -67,7 +67,7 @@ theorem toLex_apply (x : ∀ i, β i) (i : ι) : toLex x i = x i :=
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} (x : Lex.{max u1 u2} (forall (i : ι), β i)) (i : ι), Eq.{succ u2} (β i) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (forall (i : ι), β i)) (forall (i : ι), β i)) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (forall (i : ι), β i)) (forall (i : ι), β i)) => (Lex.{max u1 u2} (forall (i : ι), β i)) -> (forall (i : ι), β i)) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Lex.{max u1 u2} (forall (i : ι), β i)) (forall (i : ι), β i)) (ofLex.{max u1 u2} (forall (i : ι), β i)) x i) (x i)
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} (x : Lex.{max u2 u1} (forall (i : ι), β i)) (i : ι), Eq.{succ u1} (β i) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Lex.{max u2 u1} (forall (i : ι), β i)) (forall (i : ι), β i)) (Lex.{max u2 u1} (forall (i : ι), β i)) (fun (_x : Lex.{max u2 u1} (forall (i : ι), β i)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Lex.{max u2 u1} (forall (i : ι), β i)) => forall (i : ι), β i) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Lex.{max u2 u1} (forall (i : ι), β i)) (forall (i : ι), β i)) (ofLex.{max u2 u1} (forall (i : ι), β i)) x i) (x i)
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} (x : Lex.{max u2 u1} (forall (i : ι), β i)) (i : ι), Eq.{succ u1} (β i) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Lex.{max u2 u1} (forall (i : ι), β i)) (forall (i : ι), β i)) (Lex.{max u2 u1} (forall (i : ι), β i)) (fun (_x : Lex.{max u2 u1} (forall (i : ι), β i)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Lex.{max u2 u1} (forall (i : ι), β i)) => forall (i : ι), β i) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Lex.{max u2 u1} (forall (i : ι), β i)) (forall (i : ι), β i)) (ofLex.{max u2 u1} (forall (i : ι), β i)) x i) (x i)
 Case conversion may be inaccurate. Consider using '#align pi.of_lex_apply Pi.ofLex_applyₓ'. -/
 @[simp]
 theorem ofLex_apply (x : Lex (∀ i, β i)) (i : ι) : ofLex x i = x i :=
@@ -149,7 +149,7 @@ open Function
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)], Monotone.{max u1 u2, max u1 u2} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)))
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.1683 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.1685 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.1683 x._@.Mathlib.Data.Pi.Lex._hyg.1685)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)], Monotone.{max u2 u1, max u2 u1} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.preorder.{u2, u1} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)))
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.1685 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.1687 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.1685 x._@.Mathlib.Data.Pi.Lex._hyg.1687)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)], Monotone.{max u2 u1, max u2 u1} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.preorder.{u2, u1} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)))
 Case conversion may be inaccurate. Consider using '#align pi.to_lex_monotone Pi.toLex_monotoneₓ'. -/
 theorem toLex_monotone : Monotone (@toLex (∀ i, β i)) := fun a b h =>
   or_iff_not_imp_left.2 fun hne =>
@@ -163,7 +163,7 @@ theorem toLex_monotone : Monotone (@toLex (∀ i, β i)) := fun a b h =>
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)], StrictMono.{max u1 u2, max u1 u2} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.preorder.{u1, u2} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)))
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.1869 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.1871 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.1869 x._@.Mathlib.Data.Pi.Lex._hyg.1871)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)], StrictMono.{max u2 u1, max u2 u1} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.preorder.{u2, u1} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)))
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.1872 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.1874 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.1872 x._@.Mathlib.Data.Pi.Lex._hyg.1874)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)], StrictMono.{max u2 u1, max u2 u1} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.preorder.{u2, u1} ι (fun (i : ι) => β i) (fun (i : ι) => PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (PartialOrder.toPreorder.{max u2 u1} (Lex.{max u2 u1} (forall (i : ι), β i)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a))) (FunLike.coe.{max (succ u2) (succ u1), max (succ u2) (succ u1), max (succ u2) (succ u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)))
 Case conversion may be inaccurate. Consider using '#align pi.to_lex_strict_mono Pi.toLex_strictMonoₓ'. -/
 theorem toLex_strictMono : StrictMono (@toLex (∀ i, β i)) := fun a b h =>
   let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min { i | a i ≠ b i } (Function.ne_iff.1 h.Ne)
@@ -176,7 +176,7 @@ theorem toLex_strictMono : StrictMono (@toLex (∀ i, β i)) := fun a b h =>
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.hasLt.{u1, u2} ι (fun (i : ι) => β i) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))) (fun (a : ι) => Preorder.toLT.{u2} (β a) (PartialOrder.toPreorder.{u2} (β a) (_inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a))) (LT.lt.{u2} (β i) (Preorder.toLT.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (x i) a)
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2051 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2053 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2051 x._@.Mathlib.Data.Pi.Lex._hyg.2053)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Pi.instLTLexForAll.{u2, u1} ι (fun (i : ι) => β i) (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) (fun (a : ι) => Preorder.toLT.{u1} (β a) (PartialOrder.toPreorder.{u1} (β a) (_inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a))) (LT.lt.{u1} (β i) (Preorder.toLT.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (x i) a)
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2055 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2057 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2055 x._@.Mathlib.Data.Pi.Lex._hyg.2057)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Pi.instLTLexForAll.{u2, u1} ι (fun (i : ι) => β i) (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) (fun (a : ι) => Preorder.toLT.{u1} (β a) (PartialOrder.toPreorder.{u1} (β a) (_inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a))) (LT.lt.{u1} (β i) (Preorder.toLT.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (x i) a)
 Case conversion may be inaccurate. Consider using '#align pi.lt_to_lex_update_self_iff Pi.lt_toLex_update_self_iffₓ'. -/
 @[simp]
 theorem lt_toLex_update_self_iff : toLex x < toLex (update x i a) ↔ x i < a :=
@@ -195,7 +195,7 @@ theorem lt_toLex_update_self_iff : toLex x < toLex (update x i a) ↔ x i < a :=
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (Pi.Lex.hasLt.{u1, u2} ι (fun (a : ι) => β a) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))) (fun (a : ι) => Preorder.toLT.{u2} (β a) (PartialOrder.toPreorder.{u2} (β a) (_inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x)) (LT.lt.{u2} (β i) (Preorder.toLT.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) a (x i))
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2347 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2349 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2347 x._@.Mathlib.Data.Pi.Lex._hyg.2349)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Pi.instLTLexForAll.{u2, u1} ι (fun (a : ι) => β a) (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) (fun (a : ι) => Preorder.toLT.{u1} (β a) (PartialOrder.toPreorder.{u1} (β a) (_inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x)) (LT.lt.{u1} (β i) (Preorder.toLT.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) a (x i))
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2353 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2355 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2353 x._@.Mathlib.Data.Pi.Lex._hyg.2355)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Pi.instLTLexForAll.{u2, u1} ι (fun (a : ι) => β a) (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) (fun (a : ι) => Preorder.toLT.{u1} (β a) (PartialOrder.toPreorder.{u1} (β a) (_inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x)) (LT.lt.{u1} (β i) (Preorder.toLT.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) a (x i))
 Case conversion may be inaccurate. Consider using '#align pi.to_lex_update_lt_self_iff Pi.toLex_update_lt_self_iffₓ'. -/
 @[simp]
 theorem toLex_update_lt_self_iff : toLex (update x i a) < toLex x ↔ a < x i :=
@@ -214,7 +214,7 @@ theorem toLex_update_lt_self_iff : toLex (update x i a) < toLex x ↔ a < x i :=
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Preorder.toLE.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (i : ι), β i)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a))) (LE.le.{u2} (β i) (Preorder.toLE.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) (x i) a)
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2643 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2645 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2643 x._@.Mathlib.Data.Pi.Lex._hyg.2645)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Preorder.toLE.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (PartialOrder.toPreorder.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a))) (LE.le.{u1} (β i) (Preorder.toLE.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (x i) a)
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2651 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2653 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2651 x._@.Mathlib.Data.Pi.Lex._hyg.2653)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Preorder.toLE.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (PartialOrder.toPreorder.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) x) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (i : ι) => β i) _inst_1 (fun (a : ι) => _inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a))) (LE.le.{u1} (β i) (Preorder.toLE.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) (x i) a)
 Case conversion may be inaccurate. Consider using '#align pi.le_to_lex_update_self_iff Pi.le_toLex_update_self_iffₓ'. -/
 @[simp]
 theorem le_toLex_update_self_iff : toLex x ≤ toLex (update x i a) ↔ x i ≤ a := by
@@ -225,7 +225,7 @@ theorem le_toLex_update_self_iff : toLex x ≤ toLex (update x i a) ↔ x i ≤
 lean 3 declaration is
   forall {ι : Type.{u1}} {β : ι -> Type.{u2}} [_inst_1 : LinearOrder.{u1} ι] [_inst_2 : IsWellOrder.{u1} ι (LT.lt.{u1} ι (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι (SemilatticeInf.toPartialOrder.{u1} ι (Lattice.toSemilatticeInf.{u1} ι (LinearOrder.toLattice.{u1} ι _inst_1))))))] [_inst_3 : forall (i : ι), PartialOrder.{u2} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (Preorder.toLE.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (PartialOrder.toPreorder.{max u1 u2} (Lex.{max u1 u2} (forall (a : ι), β a)) (Pi.Lex.partialOrder.{u1, u2} ι (fun (a : ι) => β a) _inst_1 (fun (a : ι) => _inst_3 a)))) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) => (forall (a : ι), β a) -> (Lex.{max u1 u2} (forall (a : ι), β a))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (a : ι), β a) (Lex.{max u1 u2} (forall (a : ι), β a))) (toLex.{max u1 u2} (forall (a : ι), β a)) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => Eq.decidable.{u1} ι _inst_1 a b) x i a)) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) => (forall (i : ι), β i) -> (Lex.{max u1 u2} (forall (i : ι), β i))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (forall (i : ι), β i) (Lex.{max u1 u2} (forall (i : ι), β i))) (toLex.{max u1 u2} (forall (i : ι), β i)) x)) (LE.le.{u2} (β i) (Preorder.toLE.{u2} (β i) (PartialOrder.toPreorder.{u2} (β i) (_inst_3 i))) a (x i))
 but is expected to have type
-  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2739 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2741 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2739 x._@.Mathlib.Data.Pi.Lex._hyg.2741)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Preorder.toLE.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (PartialOrder.toPreorder.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (a : ι) => β a) _inst_1 (fun (a : ι) => _inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x)) (LE.le.{u1} (β i) (Preorder.toLE.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) a (x i))
+  forall {ι : Type.{u2}} {β : ι -> Type.{u1}} [_inst_1 : LinearOrder.{u2} ι] [_inst_2 : IsWellOrder.{u2} ι (fun (x._@.Mathlib.Data.Pi.Lex._hyg.2749 : ι) (x._@.Mathlib.Data.Pi.Lex._hyg.2751 : ι) => LT.lt.{u2} ι (Preorder.toLT.{u2} ι (PartialOrder.toPreorder.{u2} ι (SemilatticeInf.toPartialOrder.{u2} ι (Lattice.toSemilatticeInf.{u2} ι (DistribLattice.toLattice.{u2} ι (instDistribLattice.{u2} ι _inst_1)))))) x._@.Mathlib.Data.Pi.Lex._hyg.2749 x._@.Mathlib.Data.Pi.Lex._hyg.2751)] [_inst_3 : forall (i : ι), PartialOrder.{u1} (β i)] {x : forall (i : ι), β i} {i : ι} {a : β i}, Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Preorder.toLE.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (PartialOrder.toPreorder.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (a : ι) => β a) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (Pi.instPartialOrderLexForAll.{u2, u1} ι (fun (a : ι) => β a) _inst_1 (fun (a : ι) => _inst_3 a)))) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (forall (a : ι), β a) (fun (_x : forall (a : ι), β a) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (a : ι), β a) => Lex.{max u2 u1} (forall (a : ι), β a)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (a : ι), β a) (Lex.{max u2 u1} (forall (a : ι), β a))) (toLex.{max u2 u1} (forall (a : ι), β a)) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => β i) (fun (a : ι) (b : ι) => instDecidableEq.{u2} ι _inst_1 a b) x i a)) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (forall (i : ι), β i) (fun (_x : forall (i : ι), β i) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : forall (i : ι), β i) => Lex.{max u2 u1} (forall (i : ι), β i)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (forall (i : ι), β i) (Lex.{max u2 u1} (forall (i : ι), β i))) (toLex.{max u2 u1} (forall (i : ι), β i)) x)) (LE.le.{u1} (β i) (Preorder.toLE.{u1} (β i) (PartialOrder.toPreorder.{u1} (β i) (_inst_3 i))) a (x i))
 Case conversion may be inaccurate. Consider using '#align pi.to_lex_update_le_self_iff Pi.toLex_update_le_self_iffₓ'. -/
 @[simp]
 theorem toLex_update_le_self_iff : toLex (update x i a) ≤ toLex x ↔ a ≤ x i := by

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

A PR accompanying #12339.

Zulip discussion

@@ -191,9 +191,9 @@ instance [Preorder ι] [∀ i, LT (β i)] [∀ i, DenselyOrdered (β i)] :
     obtain ⟨a, ha₁, ha₂⟩ := exists_between hi
     classical
       refine' ⟨Function.update a₂ _ a, ⟨i, fun j hj => _, _⟩, i, fun j hj => _, _⟩
-      rw [h j hj]
-      dsimp only at hj
-      · rw [Function.update_noteq hj.ne a]
+      · rw [h j hj]
+        dsimp only at hj
+        rw [Function.update_noteq hj.ne a]
       · rwa [Function.update_same i a]
       · rw [Function.update_noteq hj.ne a]
       · rwa [Function.update_same i a]⟩

Co-authored-by: Moritz Firsching <firsching@google.com>

@@ -119,7 +119,7 @@ open Function
 
 theorem toLex_monotone : Monotone (@toLex (∀ i, β i)) := fun a b h =>
   or_iff_not_imp_left.2 fun hne =>
-    let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min (r := (· < · )) { i | a i ≠ b i }
+    let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min (r := (· < ·)) { i | a i ≠ b i }
       (Function.ne_iff.1 hne)
     ⟨i, fun j hj => by
       contrapose! hl
@@ -127,7 +127,7 @@ theorem toLex_monotone : Monotone (@toLex (∀ i, β i)) := fun a b h =>
 #align pi.to_lex_monotone Pi.toLex_monotone
 
 theorem toLex_strictMono : StrictMono (@toLex (∀ i, β i)) := fun a b h =>
-  let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min (r := (· < · )) { i | a i ≠ b i }
+  let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min (r := (· < ·)) { i | a i ≠ b i }
     (Function.ne_iff.1 h.ne)
   ⟨i, fun j hj => by
     contrapose! hl

Rename

• Data.Pi.Algebra to Algebra.Group.Pi.Basic
• Algebra.Group.Pi to Algebra.Group.Pi.Lemmas

Move a few instances from the latter to the former, the goal being that Algebra.Group.Pi.Basic is about all the pi instances of the classes defined in Algebra.Group.Defs. Algebra.Group.Pi.Lemmas will need further rearranging.

@@ -3,11 +3,10 @@ Copyright (c) 2019 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
 -/
-import Mathlib.Order.Basic
-import Mathlib.Order.WellFounded
 import Mathlib.Algebra.Group.OrderSynonym
-import Mathlib.Algebra.Group.Pi
+import Mathlib.Algebra.Group.Pi.Basic
 import Mathlib.Algebra.Order.Group.Defs
+import Mathlib.Order.WellFounded
 import Mathlib.Mathport.Notation
 
 #align_import data.pi.lex from "leanprover-community/mathlib"@"6623e6af705e97002a9054c1c05a980180276fc1"

I literally went through and regex'd some uses of cases', replacing them with rcases; this is meant to be a low effort PR as I hope that tools can do this in the future.

rcases is an easier replacement than cases, though with better tools we could in future do a second pass converting simple rcases added here (and existing ones) to cases.

@@ -74,7 +74,7 @@ theorem lex_lt_of_lt [∀ i, PartialOrder (β i)] {r} (hwf : WellFounded r) {x y
 theorem isTrichotomous_lex [∀ i, IsTrichotomous (β i) s] (wf : WellFounded r) :
     IsTrichotomous (∀ i, β i) (Pi.Lex r @s) :=
   { trichotomous := fun a b => by
-      cases' eq_or_ne a b with hab hab
+      rcases eq_or_ne a b with hab | hab
       · exact Or.inr (Or.inl hab)
       · rw [Function.ne_iff] at hab
         let i := wf.min _ hab

@@ -245,14 +245,14 @@ instance Lex.orderedCommGroup [∀ i, OrderedCommGroup (β i)] :
 noncomputable instance Lex.linearOrderedCancelCommMonoid [IsWellOrder ι (· < ·)]
     [∀ i, LinearOrderedCancelCommMonoid (β i)] :
     LinearOrderedCancelCommMonoid (Lex (∀ i, β i)) where
-  __ := (inferInstance : LinearOrder (Lex (∀ i, β i)))
-  __ := (inferInstance: OrderedCancelCommMonoid (Lex (∀ i, β i)))
+  __ : LinearOrder (Lex (∀ i, β i)) := inferInstance
+  __ : OrderedCancelCommMonoid (Lex (∀ i, β i)) := inferInstance
 
 @[to_additive]
 noncomputable instance Lex.linearOrderedCommGroup [IsWellOrder ι (· < ·)]
     [∀ i, LinearOrderedCommGroup (β i)] :
     LinearOrderedCommGroup (Lex (∀ i, β i)) where
-  __ := (inferInstance : LinearOrder (Lex (∀ i, β i)))
+  __ : LinearOrder (Lex (∀ i, β i)) := inferInstance
   mul_le_mul_left _ _ := mul_le_mul_left'
 
 end OrderedMonoid

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

@@ -5,6 +5,7 @@ Authors: Chris Hughes
 -/
 import Mathlib.Order.Basic
 import Mathlib.Order.WellFounded
+import Mathlib.Algebra.Group.OrderSynonym
 import Mathlib.Algebra.Group.Pi
 import Mathlib.Algebra.Order.Group.Defs
 import Mathlib.Mathport.Notation
@@ -36,9 +37,6 @@ variable {ι : Type*} {β : ι → Type*} (r : ι → ι → Prop) (s : ∀ {i},
 
 namespace Pi
 
-instance {α : Type*} : ∀ [Inhabited α], Inhabited (Lex α) :=
-  @fun x => x
-
 /-- The lexicographic relation on `Π i : ι, β i`, where `ι` is ordered by `r`,
   and each `β i` is ordered by `s`. -/
 protected def Lex (x y : ∀ i, β i) : Prop :=
@@ -222,24 +220,49 @@ instance [LinearOrder ι] [IsWellOrder ι (· < ·)] [Nonempty ι] [∀ i, Parti
     let ⟨_, hb⟩ := exists_lt (ofLex a)
     ⟨_, toLex_strictMono hb⟩⟩
 
---We might want the analog of `Pi.orderedCancelCommMonoid` as well in the future.
+section OrderedMonoid
+
+variable [LinearOrder ι]
+
+@[to_additive]
+instance Lex.orderedCancelCommMonoid [∀ i, OrderedCancelCommMonoid (β i)] :
+    OrderedCancelCommMonoid (Lex (∀ i, β i)) where
+  mul_le_mul_left _ _ hxy z :=
+    hxy.elim (fun hxyz => hxyz ▸ le_rfl) fun ⟨i, hi⟩ =>
+      Or.inr ⟨i, fun j hji => congr_arg (z j * ·) (hi.1 j hji), mul_lt_mul_left' hi.2 _⟩
+  le_of_mul_le_mul_left _ _ _ hxyz :=
+    hxyz.elim (fun h => (mul_left_cancel h).le) fun ⟨i, hi⟩ =>
+      Or.inr ⟨i, fun j hj => (mul_left_cancel <| hi.1 j hj), lt_of_mul_lt_mul_left' hi.2⟩
+
 @[to_additive]
-instance Lex.orderedCommGroup [LinearOrder ι] [∀ a, OrderedCommGroup (β a)] :
-    OrderedCommGroup (Lex (∀ i, β i)) :=
-  { Pi.commGroup with
-    mul_le_mul_left := fun x y hxy z =>
-      hxy.elim (fun hxyz => hxyz ▸ le_rfl) fun ⟨i, hi⟩ =>
-        Or.inr ⟨i, fun j hji =>
-          show z j * x j = z j * y j by rw [hi.1 j hji], mul_lt_mul_left' hi.2 _⟩ }
+instance Lex.orderedCommGroup [∀ i, OrderedCommGroup (β i)] :
+    OrderedCommGroup (Lex (∀ i, β i)) where
+  mul_le_mul_left _ _ := mul_le_mul_left'
 #align pi.lex.ordered_comm_group Pi.Lex.orderedCommGroup
 #align pi.lex.ordered_add_comm_group Pi.Lex.orderedAddCommGroup
 
+@[to_additive]
+noncomputable instance Lex.linearOrderedCancelCommMonoid [IsWellOrder ι (· < ·)]
+    [∀ i, LinearOrderedCancelCommMonoid (β i)] :
+    LinearOrderedCancelCommMonoid (Lex (∀ i, β i)) where
+  __ := (inferInstance : LinearOrder (Lex (∀ i, β i)))
+  __ := (inferInstance: OrderedCancelCommMonoid (Lex (∀ i, β i)))
+
+@[to_additive]
+noncomputable instance Lex.linearOrderedCommGroup [IsWellOrder ι (· < ·)]
+    [∀ i, LinearOrderedCommGroup (β i)] :
+    LinearOrderedCommGroup (Lex (∀ i, β i)) where
+  __ := (inferInstance : LinearOrder (Lex (∀ i, β i)))
+  mul_le_mul_left _ _ := mul_le_mul_left'
+
+end OrderedMonoid
+
 /-- If we swap two strictly decreasing values in a function, then the result is lexicographically
 smaller than the original function. -/
-theorem lex_desc {α} [Preorder ι] [DecidableEq ι] [Preorder α] {f : ι → α} {i j : ι} (h₁ : i < j)
+theorem lex_desc {α} [Preorder ι] [DecidableEq ι] [Preorder α] {f : ι → α} {i j : ι} (h₁ : i ≤ j)
     (h₂ : f j < f i) : toLex (f ∘ Equiv.swap i j) < toLex f :=
-  ⟨i, fun k hik => congr_arg f (Equiv.swap_apply_of_ne_of_ne hik.ne (hik.trans h₁).ne), by
+  ⟨i, fun k hik => congr_arg f (Equiv.swap_apply_of_ne_of_ne hik.ne (hik.trans_le h₁).ne), by
     simpa only [Pi.toLex_apply, Function.comp_apply, Equiv.swap_apply_left] using h₂⟩
-#align pi.lex_desc Pi.lex_desc
+#align pi.lex_desc Pi.lex_descₓ
 
 end Pi

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

@@ -32,11 +32,11 @@ Related files are:
 -/
 
 
-variable {ι : Type _} {β : ι → Type _} (r : ι → ι → Prop) (s : ∀ {i}, β i → β i → Prop)
+variable {ι : Type*} {β : ι → Type*} (r : ι → ι → Prop) (s : ∀ {i}, β i → β i → Prop)
 
 namespace Pi
 
-instance {α : Type _} : ∀ [Inhabited α], Inhabited (Lex α) :=
+instance {α : Type*} : ∀ [Inhabited α], Inhabited (Lex α) :=
   @fun x => x
 
 /-- The lexicographic relation on `Π i : ι, β i`, where `ι` is ordered by `r`,

• depends on: #5966

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

@@ -2,11 +2,6 @@
 Copyright (c) 2019 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
-
-! This file was ported from Lean 3 source module data.pi.lex
-! leanprover-community/mathlib commit 6623e6af705e97002a9054c1c05a980180276fc1
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.Basic
 import Mathlib.Order.WellFounded
@@ -14,6 +9,8 @@ import Mathlib.Algebra.Group.Pi
 import Mathlib.Algebra.Order.Group.Defs
 import Mathlib.Mathport.Notation
 
+#align_import data.pi.lex from "leanprover-community/mathlib"@"6623e6af705e97002a9054c1c05a980180276fc1"
+
 /-!
 # Lexicographic order on Pi types
 

These are all doc fixes

@@ -29,7 +29,7 @@ This file defines the lexicographic order for Pi types. `a` is less than `b` if
 Related files are:
 * `Data.Finset.Colex`: Colexicographic order on finite sets.
 * `Data.List.Lex`: Lexicographic order on lists.
-* `Data.Oigma.Order`: Lexicographic order on `Σₗ i, α i`.
+* `Data.Sigma.Order`: Lexicographic order on `Σₗ i, α i`.
 * `Data.PSigma.Order`: Lexicographic order on `Σₗ' i, α i`.
 * `Data.Prod.Lex`: Lexicographic order on `α × β`.
 -/

Too often tempted to change these during other PRs, so doing a mass edit here.

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

@@ -89,7 +89,7 @@ theorem isTrichotomous_lex [∀ i, IsTrichotomous (β i) s] (wf : WellFounded r)
           exact fun h' => wf.not_lt_min _ _ h'
         have hne : a i ≠ b i := wf.min_mem _ hab
         cases' trichotomous_of s (a i) (b i) with hi hi
-        exacts[Or.inl ⟨i, hri, hi⟩,
+        exacts [Or.inl ⟨i, hri, hi⟩,
           Or.inr <| Or.inr <| ⟨i, fun j hj => (hri j hj).symm, hi.resolve_left hne⟩] }
 #align pi.is_trichotomous_lex Pi.isTrichotomous_lex
 
@@ -102,7 +102,7 @@ instance Lex.isStrictOrder [LinearOrder ι] [∀ a, PartialOrder (β a)] :
   trans := by
     rintro a b c ⟨N₁, lt_N₁, a_lt_b⟩ ⟨N₂, lt_N₂, b_lt_c⟩
     rcases lt_trichotomy N₁ N₂ with (H | rfl | H)
-    exacts[⟨N₁, fun j hj => (lt_N₁ _ hj).trans (lt_N₂ _ <| hj.trans H), lt_N₂ _ H ▸ a_lt_b⟩,
+    exacts [⟨N₁, fun j hj => (lt_N₁ _ hj).trans (lt_N₂ _ <| hj.trans H), lt_N₂ _ H ▸ a_lt_b⟩,
       ⟨N₁, fun j hj => (lt_N₁ _ hj).trans (lt_N₂ _ hj), a_lt_b.trans b_lt_c⟩,
       ⟨N₂, fun j hj => (lt_N₁ _ (hj.trans H)).trans (lt_N₂ _ hj), (lt_N₁ _ H).symm ▸ b_lt_c⟩]
 #align pi.lex.is_strict_order Pi.Lex.isStrictOrder

Gives the notation3 command the ability to generate a delaborator in most common situations. When it succeeds, notation3-defined syntax is pretty printable.

Examples:

(⋃ (i : ι) (i' : ι'), s i i') = ⋃ (i' : ι') (i : ι), s i i'
(⨆ (g : α → ℝ≥0∞) (_ : Measurable g) (_ : g ≤ f), ∫⁻ (a : α), g a ∂μ) = ∫⁻ (a : α), f a ∂μ

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

@@ -51,7 +51,7 @@ protected def Lex (x y : ∀ i, β i) : Prop :=
 /- This unfortunately results in a type that isn't delta-reduced, so we keep the notation out of the
 basic API, just in case -/
 /-- The notation `Πₗ i, α i` refers to a pi type equipped with the lexicographic order. -/
-notation3 "Πₗ "(...)", "r:(scoped p => Lex (∀ i, p i)) => r
+notation3 (prettyPrint := false) "Πₗ "(...)", "r:(scoped p => Lex (∀ i, p i)) => r
 
 @[simp]
 theorem toLex_apply (x : ∀ i, β i) (i : ι) : toLex x i = x i :=

leanprover-community/mathlib#18277 backported a bug about classical which is already fixed in mathlib4, so these diffs simpy need a SHA update.

(Comment: This might not be the full PR #18277 yet, as I worked on a file-by-file base)

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
 
 ! This file was ported from Lean 3 source module data.pi.lex
-! leanprover-community/mathlib commit d4f69d96f3532729da8ebb763f4bc26fcf640f06
+! leanprover-community/mathlib commit 6623e6af705e97002a9054c1c05a980180276fc1
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/

Co-authored-by: Floris van Doorn <fpvdoorn@gmail.com>

@@ -235,6 +235,7 @@ instance Lex.orderedCommGroup [LinearOrder ι] [∀ a, OrderedCommGroup (β a)]
         Or.inr ⟨i, fun j hji =>
           show z j * x j = z j * y j by rw [hi.1 j hji], mul_lt_mul_left' hi.2 _⟩ }
 #align pi.lex.ordered_comm_group Pi.Lex.orderedCommGroup
+#align pi.lex.ordered_add_comm_group Pi.Lex.orderedAddCommGroup
 
 /-- If we swap two strictly decreasing values in a function, then the result is lexicographically
 smaller than the original function. -/

mathlib3 SHA: d4f69d96