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

@@ -361,7 +361,7 @@ theorem row_eq_prod {μ : YoungDiagram} {i : ℕ} : μ.row i = {i} ×ˢ Finset.r
   by
   ext ⟨a, b⟩
   simp only [Finset.mem_product, Finset.mem_singleton, Finset.mem_range, mem_row_iff,
-    mem_iff_lt_row_len, and_comm', and_congr_right_iff]
+    mem_iff_lt_row_len, and_comm, and_congr_right_iff]
   rintro rfl; rfl
 #align young_diagram.row_eq_prod YoungDiagram.row_eq_prod
 -/
@@ -448,7 +448,7 @@ theorem col_eq_prod {μ : YoungDiagram} {j : ℕ} : μ.col j = Finset.range (μ.
   by
   ext ⟨a, b⟩
   simp only [Finset.mem_product, Finset.mem_singleton, Finset.mem_range, mem_col_iff,
-    mem_iff_lt_col_len, and_comm', and_congr_right_iff]
+    mem_iff_lt_col_len, and_comm, and_congr_right_iff]
   rintro rfl; rfl
 #align young_diagram.col_eq_prod YoungDiagram.col_eq_prod
 -/

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

@@ -335,7 +335,7 @@ protected theorem exists_not_mem_row (μ : YoungDiagram) (i : ℕ) : ∃ j, (i,
   by
   obtain ⟨j, hj⟩ :=
     Infinite.exists_not_mem_finset (μ.cells.Preimage (Prod.mk i) fun _ _ _ _ h => by cases h; rfl)
-  rw [Finset.mem_preimage] at hj 
+  rw [Finset.mem_preimage] at hj
   exact ⟨j, hj⟩
 #align young_diagram.exists_not_mem_row YoungDiagram.exists_not_mem_row
 -/
@@ -509,9 +509,9 @@ theorem rowLens_sorted (μ : YoungDiagram) : μ.rowLens.Sorted (· ≥ ·) :=
 #print YoungDiagram.pos_of_mem_rowLens /-
 theorem pos_of_mem_rowLens (μ : YoungDiagram) (x : ℕ) (hx : x ∈ μ.rowLens) : 0 < x :=
   by
-  rw [row_lens, List.mem_map] at hx 
+  rw [row_lens, List.mem_map] at hx
   obtain ⟨i, hi, rfl : μ.row_len i = x⟩ := hx
-  rwa [List.mem_range, ← mem_iff_lt_col_len, mem_iff_lt_row_len] at hi 
+  rwa [List.mem_range, ← mem_iff_lt_col_len, mem_iff_lt_row_len] at hi
 #align young_diagram.pos_of_mem_row_lens YoungDiagram.pos_of_mem_rowLens
 -/
 

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

@@ -376,7 +376,7 @@ theorem rowLen_eq_card (μ : YoungDiagram) {i : ℕ} : μ.rowLen i = (μ.row i).
 @[mono]
 theorem rowLen_anti (μ : YoungDiagram) (i1 i2 : ℕ) (hi : i1 ≤ i2) : μ.rowLen i2 ≤ μ.rowLen i1 :=
   by
-  by_contra' h_lt; rw [← lt_self_iff_false (μ.row_len i1)]
+  by_contra! h_lt; rw [← lt_self_iff_false (μ.row_len i1)]
   rw [← mem_iff_lt_row_len] at h_lt ⊢
   exact μ.up_left_mem hi (by rfl) h_lt
 #align young_diagram.row_len_anti YoungDiagram.rowLen_anti

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

@@ -3,8 +3,8 @@ Copyright (c) 2022 Jake Levinson. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jake Levinson
 -/
-import Mathbin.Order.UpperLower.Basic
-import Mathbin.Data.Finset.Preimage
+import Order.UpperLower.Basic
+import Data.Finset.Preimage
 
 #align_import combinatorics.young.young_diagram from "leanprover-community/mathlib"@"4c19a16e4b705bf135cf9a80ac18fcc99c438514"
 

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

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Jake Levinson. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jake Levinson
-
-! This file was ported from Lean 3 source module combinatorics.young.young_diagram
-! leanprover-community/mathlib commit 4c19a16e4b705bf135cf9a80ac18fcc99c438514
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.UpperLower.Basic
 import Mathbin.Data.Finset.Preimage
 
+#align_import combinatorics.young.young_diagram from "leanprover-community/mathlib"@"4c19a16e4b705bf135cf9a80ac18fcc99c438514"
+
 /-!
 # Young diagrams
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/2a0ce625dbb0ffbc7d1316597de0b25c1ec75303

@@ -618,7 +618,7 @@ theorem ofRowLens_to_rowLens_eq_self {μ : YoungDiagram} : ofRowLens _ (rowLens_
 /-- The right_inv direction of the equivalence -/
 theorem rowLens_ofRowLens_eq_self {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (hpos : ∀ x ∈ w, 0 < x) :
     (ofRowLens w hw).rowLens = w := by
-  ext (i r)
+  ext i r
   cases lt_or_ge i w.length
   · simp only [Option.mem_def, ← List.nthLe_eq_iff, h, row_lens_length_of_row_lens hpos]
     revert r

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

@@ -111,15 +111,19 @@ theorem up_left_mem (μ : YoungDiagram) {i1 i2 j1 j2 : ℕ} (hi : i1 ≤ i2) (hj
 
 section DistribLattice
 
+#print YoungDiagram.cells_subset_iff /-
 @[simp]
 theorem cells_subset_iff {μ ν : YoungDiagram} : μ.cells ⊆ ν.cells ↔ μ ≤ ν :=
   Iff.rfl
 #align young_diagram.cells_subset_iff YoungDiagram.cells_subset_iff
+-/
 
+#print YoungDiagram.cells_ssubset_iff /-
 @[simp]
 theorem cells_ssubset_iff {μ ν : YoungDiagram} : μ.cells ⊂ ν.cells ↔ μ < ν :=
   Iff.rfl
 #align young_diagram.cells_ssubset_iff YoungDiagram.cells_ssubset_iff
+-/
 
 instance : Sup YoungDiagram
     where sup μ ν :=
@@ -128,20 +132,26 @@ instance : Sup YoungDiagram
         rw [Finset.coe_union]
         exact μ.is_lower_set.union ν.is_lower_set }
 
+#print YoungDiagram.cells_sup /-
 @[simp]
 theorem cells_sup (μ ν : YoungDiagram) : (μ ⊔ ν).cells = μ.cells ∪ ν.cells :=
   rfl
 #align young_diagram.cells_sup YoungDiagram.cells_sup
+-/
 
+#print YoungDiagram.coe_sup /-
 @[simp, norm_cast]
 theorem coe_sup (μ ν : YoungDiagram) : ↑(μ ⊔ ν) = (μ ∪ ν : Set (ℕ × ℕ)) :=
   Finset.coe_union _ _
 #align young_diagram.coe_sup YoungDiagram.coe_sup
+-/
 
+#print YoungDiagram.mem_sup /-
 @[simp]
 theorem mem_sup {μ ν : YoungDiagram} {x : ℕ × ℕ} : x ∈ μ ⊔ ν ↔ x ∈ μ ∨ x ∈ ν :=
   Finset.mem_union
 #align young_diagram.mem_sup YoungDiagram.mem_sup
+-/
 
 instance : Inf YoungDiagram
     where inf μ ν :=
@@ -150,10 +160,12 @@ instance : Inf YoungDiagram
         rw [Finset.coe_inter]
         exact μ.is_lower_set.inter ν.is_lower_set }
 
+#print YoungDiagram.cells_inf /-
 @[simp]
 theorem cells_inf (μ ν : YoungDiagram) : (μ ⊓ ν).cells = μ.cells ∩ ν.cells :=
   rfl
 #align young_diagram.cells_inf YoungDiagram.cells_inf
+-/
 
 #print YoungDiagram.coe_inf /-
 @[simp, norm_cast]
@@ -177,20 +189,26 @@ instance : OrderBot YoungDiagram
       IsLowerSet := fun _ _ _ => False.elim }
   bot_le _ _ := False.elim
 
+#print YoungDiagram.cells_bot /-
 @[simp]
 theorem cells_bot : (⊥ : YoungDiagram).cells = ∅ :=
   rfl
 #align young_diagram.cells_bot YoungDiagram.cells_bot
+-/
 
+#print YoungDiagram.coe_bot /-
 @[simp, norm_cast]
 theorem coe_bot : ↑(⊥ : YoungDiagram) = (∅ : Set (ℕ × ℕ)) :=
   rfl
 #align young_diagram.coe_bot YoungDiagram.coe_bot
+-/
 
+#print YoungDiagram.not_mem_bot /-
 @[simp]
 theorem not_mem_bot (x : ℕ × ℕ) : x ∉ (⊥ : YoungDiagram) :=
   Finset.not_mem_empty x
 #align young_diagram.not_mem_bot YoungDiagram.not_mem_bot
+-/
 
 instance : Inhabited YoungDiagram :=
   ⟨⊥⟩
@@ -251,27 +269,35 @@ theorem transpose_eq_iff {μ ν : YoungDiagram} : μ.transpose = ν.transpose 
 #align young_diagram.transpose_eq_iff YoungDiagram.transpose_eq_iff
 -/
 
+#print YoungDiagram.le_of_transpose_le /-
 -- This is effectively both directions of `transpose_le_iff` below.
 protected theorem le_of_transpose_le {μ ν : YoungDiagram} (h_le : μ.transpose ≤ ν) :
     μ ≤ ν.transpose := fun c hc => by simp only [mem_transpose]; apply h_le; simpa
 #align young_diagram.le_of_transpose_le YoungDiagram.le_of_transpose_le
+-/
 
+#print YoungDiagram.transpose_le_iff /-
 @[simp]
 theorem transpose_le_iff {μ ν : YoungDiagram} : μ.transpose ≤ ν.transpose ↔ μ ≤ ν :=
   ⟨fun h => by convert YoungDiagram.le_of_transpose_le h; simp, fun h => by
     convert @YoungDiagram.le_of_transpose_le _ _ _; simpa⟩
 #align young_diagram.transpose_le_iff YoungDiagram.transpose_le_iff
+-/
 
+#print YoungDiagram.transpose_mono /-
 @[mono]
 protected theorem transpose_mono {μ ν : YoungDiagram} (h_le : μ ≤ ν) : μ.transpose ≤ ν.transpose :=
   transpose_le_iff.mpr h_le
 #align young_diagram.transpose_mono YoungDiagram.transpose_mono
+-/
 
+#print YoungDiagram.transposeOrderIso /-
 /-- Transposing Young diagrams is an `order_iso`. -/
 @[simps]
 def transposeOrderIso : YoungDiagram ≃o YoungDiagram :=
   ⟨⟨transpose, transpose, fun _ => by simp, fun _ => by simp⟩, by simp⟩
 #align young_diagram.transpose_order_iso YoungDiagram.transposeOrderIso
+-/
 
 end Transpose
 
@@ -463,10 +489,12 @@ def rowLens (μ : YoungDiagram) : List ℕ :=
 #align young_diagram.row_lens YoungDiagram.rowLens
 -/
 
+#print YoungDiagram.get_rowLens /-
 @[simp]
 theorem get_rowLens {μ : YoungDiagram} {i : ℕ} {hi : i < μ.rowLens.length} :
     μ.rowLens.nthLe i hi = μ.rowLen i := by simp only [row_lens, List.nthLe_range, List.nthLe_map']
 #align young_diagram.nth_le_row_lens YoungDiagram.get_rowLens
+-/
 
 #print YoungDiagram.length_rowLens /-
 @[simp]
@@ -568,11 +596,13 @@ theorem rowLens_length_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (hpo
 #align young_diagram.row_lens_length_of_row_lens YoungDiagram.rowLens_length_ofRowLens
 -/
 
+#print YoungDiagram.rowLen_ofRowLens /-
 /-- The length of the `i`th row in `of_row_lens w hw` is the `i`th entry of `w` -/
 theorem rowLen_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (i : ℕ) (hi : i < w.length) :
     (ofRowLens w hw).rowLen i = w.nthLe i hi := by
   simp [row_len, Nat.find_eq_iff, mem_of_row_lens, hi]
 #align young_diagram.row_len_of_row_lens YoungDiagram.rowLen_ofRowLens
+-/
 
 #print YoungDiagram.ofRowLens_to_rowLens_eq_self /-
 /-- The left_inv direction of the equivalence -/

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

@@ -544,7 +544,6 @@ def ofRowLens (w : List ℕ) (hw : w.Sorted (· ≥ ·)) : YoungDiagram
       j1 ≤ j2 := hj
       _ < w.nth_le i2 _ := h2
       _ ≤ w.nth_le i1 _ := _
-      
     obtain rfl | h := eq_or_lt_of_le hi
     · rfl
     · apply list.pairwise_iff_nth_le.mp hw _ _ _ h

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

@@ -259,7 +259,7 @@ protected theorem le_of_transpose_le {μ ν : YoungDiagram} (h_le : μ.transpose
 @[simp]
 theorem transpose_le_iff {μ ν : YoungDiagram} : μ.transpose ≤ ν.transpose ↔ μ ≤ ν :=
   ⟨fun h => by convert YoungDiagram.le_of_transpose_le h; simp, fun h => by
-    convert@YoungDiagram.le_of_transpose_le _ _ _; simpa⟩
+    convert @YoungDiagram.le_of_transpose_le _ _ _; simpa⟩
 #align young_diagram.transpose_le_iff YoungDiagram.transpose_le_iff
 
 @[mono]

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

@@ -312,7 +312,7 @@ protected theorem exists_not_mem_row (μ : YoungDiagram) (i : ℕ) : ∃ j, (i,
   by
   obtain ⟨j, hj⟩ :=
     Infinite.exists_not_mem_finset (μ.cells.Preimage (Prod.mk i) fun _ _ _ _ h => by cases h; rfl)
-  rw [Finset.mem_preimage] at hj
+  rw [Finset.mem_preimage] at hj 
   exact ⟨j, hj⟩
 #align young_diagram.exists_not_mem_row YoungDiagram.exists_not_mem_row
 -/
@@ -354,7 +354,7 @@ theorem rowLen_eq_card (μ : YoungDiagram) {i : ℕ} : μ.rowLen i = (μ.row i).
 theorem rowLen_anti (μ : YoungDiagram) (i1 i2 : ℕ) (hi : i1 ≤ i2) : μ.rowLen i2 ≤ μ.rowLen i1 :=
   by
   by_contra' h_lt; rw [← lt_self_iff_false (μ.row_len i1)]
-  rw [← mem_iff_lt_row_len] at h_lt⊢
+  rw [← mem_iff_lt_row_len] at h_lt ⊢
   exact μ.up_left_mem hi (by rfl) h_lt
 #align young_diagram.row_len_anti YoungDiagram.rowLen_anti
 -/
@@ -484,9 +484,9 @@ theorem rowLens_sorted (μ : YoungDiagram) : μ.rowLens.Sorted (· ≥ ·) :=
 #print YoungDiagram.pos_of_mem_rowLens /-
 theorem pos_of_mem_rowLens (μ : YoungDiagram) (x : ℕ) (hx : x ∈ μ.rowLens) : 0 < x :=
   by
-  rw [row_lens, List.mem_map] at hx
+  rw [row_lens, List.mem_map] at hx 
   obtain ⟨i, hi, rfl : μ.row_len i = x⟩ := hx
-  rwa [List.mem_range, ← mem_iff_lt_col_len, mem_iff_lt_row_len] at hi
+  rwa [List.mem_range, ← mem_iff_lt_col_len, mem_iff_lt_row_len] at hi 
 #align young_diagram.pos_of_mem_row_lens YoungDiagram.pos_of_mem_rowLens
 -/
 
@@ -537,7 +537,7 @@ def ofRowLens (w : List ℕ) (hw : w.Sorted (· ≥ ·)) : YoungDiagram
   cells := YoungDiagram.cellsOfRowLens w
   IsLowerSet := by
     rintro ⟨i2, j2⟩ ⟨i1, j1⟩ ⟨hi : i1 ≤ i2, hj : j1 ≤ j2⟩ hcell
-    rw [Finset.mem_coe, YoungDiagram.mem_cellsOfRowLens] at hcell⊢
+    rw [Finset.mem_coe, YoungDiagram.mem_cellsOfRowLens] at hcell ⊢
     obtain ⟨h1, h2⟩ := hcell
     refine' ⟨hi.trans_lt h1, _⟩
     calc

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

@@ -111,23 +111,11 @@ theorem up_left_mem (μ : YoungDiagram) {i1 i2 j1 j2 : ℕ} (hi : i1 ≤ i2) (hj
 
 section DistribLattice
 
-/- warning: young_diagram.cells_subset_iff -> YoungDiagram.cells_subset_iff is a dubious translation:
-lean 3 declaration is
-  forall {μ : YoungDiagram} {ν : YoungDiagram}, Iff (HasSubset.Subset.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.hasSubset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells μ) (YoungDiagram.cells ν)) (LE.le.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ ν)
-but is expected to have type
-  forall {μ : YoungDiagram} {ν : YoungDiagram}, Iff (HasSubset.Subset.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.instHasSubsetFinset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells μ) (YoungDiagram.cells ν)) (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.instPartialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat))) μ ν)
-Case conversion may be inaccurate. Consider using '#align young_diagram.cells_subset_iff YoungDiagram.cells_subset_iffₓ'. -/
 @[simp]
 theorem cells_subset_iff {μ ν : YoungDiagram} : μ.cells ⊆ ν.cells ↔ μ ≤ ν :=
   Iff.rfl
 #align young_diagram.cells_subset_iff YoungDiagram.cells_subset_iff
 
-/- warning: young_diagram.cells_ssubset_iff -> YoungDiagram.cells_ssubset_iff is a dubious translation:
-lean 3 declaration is
-  forall {μ : YoungDiagram} {ν : YoungDiagram}, Iff (HasSSubset.SSubset.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.hasSsubset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells μ) (YoungDiagram.cells ν)) (LT.lt.{0} YoungDiagram (Preorder.toHasLt.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ ν)
-but is expected to have type
-  forall {μ : YoungDiagram} {ν : YoungDiagram}, Iff (HasSSubset.SSubset.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.instHasSSubsetFinset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells μ) (YoungDiagram.cells ν)) (LT.lt.{0} YoungDiagram (Preorder.toLT.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.instPartialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat))) μ ν)
-Case conversion may be inaccurate. Consider using '#align young_diagram.cells_ssubset_iff YoungDiagram.cells_ssubset_iffₓ'. -/
 @[simp]
 theorem cells_ssubset_iff {μ ν : YoungDiagram} : μ.cells ⊂ ν.cells ↔ μ < ν :=
   Iff.rfl
@@ -140,34 +128,16 @@ instance : Sup YoungDiagram
         rw [Finset.coe_union]
         exact μ.is_lower_set.union ν.is_lower_set }
 
-/- warning: young_diagram.cells_sup -> YoungDiagram.cells_sup is a dubious translation:
-lean 3 declaration is
-  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (Sup.sup.{0} YoungDiagram YoungDiagram.hasSup μ ν)) (Union.union.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.hasUnion.{0} (Prod.{0, 0} Nat Nat) (fun (a : Prod.{0, 0} Nat Nat) (b : Prod.{0, 0} Nat Nat) => Prod.decidableEq.{0, 0} Nat Nat (fun (a : Nat) (b : Nat) => Nat.decidableEq a b) (fun (a : Nat) (b : Nat) => Nat.decidableEq a b) a b)) (YoungDiagram.cells μ) (YoungDiagram.cells ν))
-but is expected to have type
-  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (Sup.sup.{0} YoungDiagram YoungDiagram.instSupYoungDiagram μ ν)) (Union.union.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.instUnionFinset.{0} (Prod.{0, 0} Nat Nat) (fun (a : Prod.{0, 0} Nat Nat) (b : Prod.{0, 0} Nat Nat) => instDecidableEqProd.{0, 0} Nat Nat (fun (a : Nat) (b : Nat) => instDecidableEqNat a b) (fun (a : Nat) (b : Nat) => instDecidableEqNat a b) a b)) (YoungDiagram.cells μ) (YoungDiagram.cells ν))
-Case conversion may be inaccurate. Consider using '#align young_diagram.cells_sup YoungDiagram.cells_supₓ'. -/
 @[simp]
 theorem cells_sup (μ ν : YoungDiagram) : (μ ⊔ ν).cells = μ.cells ∪ ν.cells :=
   rfl
 #align young_diagram.cells_sup YoungDiagram.cells_sup
 
-/- warning: young_diagram.coe_sup -> YoungDiagram.coe_sup is a dubious translation:
-lean 3 declaration is
-  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Set.{0} (Prod.{0, 0} Nat Nat)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (HasLiftT.mk.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (CoeTCₓ.coe.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (SetLike.Set.hasCoeT.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (Sup.sup.{0} YoungDiagram YoungDiagram.hasSup μ ν)) (Union.union.{0} (Set.{0} (Prod.{0, 0} Nat Nat)) (Set.hasUnion.{0} (Prod.{0, 0} Nat Nat)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (HasLiftT.mk.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (CoeTCₓ.coe.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (SetLike.Set.hasCoeT.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (HasLiftT.mk.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (CoeTCₓ.coe.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (SetLike.Set.hasCoeT.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) ν))
-but is expected to have type
-  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Set.{0} (Prod.{0, 0} Nat Nat)) (SetLike.coe.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat (Sup.sup.{0} YoungDiagram YoungDiagram.instSupYoungDiagram μ ν)) (Union.union.{0} (Set.{0} (Prod.{0, 0} Nat Nat)) (Set.instUnionSet.{0} (Prod.{0, 0} Nat Nat)) (SetLike.coe.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat μ) (SetLike.coe.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat ν))
-Case conversion may be inaccurate. Consider using '#align young_diagram.coe_sup YoungDiagram.coe_supₓ'. -/
 @[simp, norm_cast]
 theorem coe_sup (μ ν : YoungDiagram) : ↑(μ ⊔ ν) = (μ ∪ ν : Set (ℕ × ℕ)) :=
   Finset.coe_union _ _
 #align young_diagram.coe_sup YoungDiagram.coe_sup
 
-/- warning: young_diagram.mem_sup -> YoungDiagram.mem_sup is a dubious translation:
-lean 3 declaration is
-  forall {μ : YoungDiagram} {ν : YoungDiagram} {x : Prod.{0, 0} Nat Nat}, Iff (Membership.Mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.hasMem.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike) x (Sup.sup.{0} YoungDiagram YoungDiagram.hasSup μ ν)) (Or (Membership.Mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.hasMem.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike) x μ) (Membership.Mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.hasMem.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike) x ν))
-but is expected to have type
-  forall {μ : YoungDiagram} {ν : YoungDiagram} {x : Prod.{0, 0} Nat Nat}, Iff (Membership.mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.instMembership.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat) x (Sup.sup.{0} YoungDiagram YoungDiagram.instSupYoungDiagram μ ν)) (Or (Membership.mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.instMembership.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat) x μ) (Membership.mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.instMembership.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat) x ν))
-Case conversion may be inaccurate. Consider using '#align young_diagram.mem_sup YoungDiagram.mem_supₓ'. -/
 @[simp]
 theorem mem_sup {μ ν : YoungDiagram} {x : ℕ × ℕ} : x ∈ μ ⊔ ν ↔ x ∈ μ ∨ x ∈ ν :=
   Finset.mem_union
@@ -180,12 +150,6 @@ instance : Inf YoungDiagram
         rw [Finset.coe_inter]
         exact μ.is_lower_set.inter ν.is_lower_set }
 
-/- warning: young_diagram.cells_inf -> YoungDiagram.cells_inf is a dubious translation:
-lean 3 declaration is
-  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (Inf.inf.{0} YoungDiagram YoungDiagram.hasInf μ ν)) (Inter.inter.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.hasInter.{0} (Prod.{0, 0} Nat Nat) (fun (a : Prod.{0, 0} Nat Nat) (b : Prod.{0, 0} Nat Nat) => Prod.decidableEq.{0, 0} Nat Nat (fun (a : Nat) (b : Nat) => Nat.decidableEq a b) (fun (a : Nat) (b : Nat) => Nat.decidableEq a b) a b)) (YoungDiagram.cells μ) (YoungDiagram.cells ν))
-but is expected to have type
-  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (Inf.inf.{0} YoungDiagram YoungDiagram.instInfYoungDiagram μ ν)) (Inter.inter.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.instInterFinset.{0} (Prod.{0, 0} Nat Nat) (fun (a : Prod.{0, 0} Nat Nat) (b : Prod.{0, 0} Nat Nat) => instDecidableEqProd.{0, 0} Nat Nat (fun (a : Nat) (b : Nat) => instDecidableEqNat a b) (fun (a : Nat) (b : Nat) => instDecidableEqNat a b) a b)) (YoungDiagram.cells μ) (YoungDiagram.cells ν))
-Case conversion may be inaccurate. Consider using '#align young_diagram.cells_inf YoungDiagram.cells_infₓ'. -/
 @[simp]
 theorem cells_inf (μ ν : YoungDiagram) : (μ ⊓ ν).cells = μ.cells ∩ ν.cells :=
   rfl
@@ -213,34 +177,16 @@ instance : OrderBot YoungDiagram
       IsLowerSet := fun _ _ _ => False.elim }
   bot_le _ _ := False.elim
 
-/- warning: young_diagram.cells_bot -> YoungDiagram.cells_bot is a dubious translation:
-lean 3 declaration is
-  Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (Bot.bot.{0} YoungDiagram (OrderBot.toHasBot.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) YoungDiagram.orderBot))) (EmptyCollection.emptyCollection.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.hasEmptyc.{0} (Prod.{0, 0} Nat Nat)))
-but is expected to have type
-  Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (Bot.bot.{0} YoungDiagram (OrderBot.toBot.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.instPartialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat))) YoungDiagram.instOrderBotYoungDiagramToLEToPreorderInstPartialOrderProdNatInstSetLikeYoungDiagramProdNat))) (EmptyCollection.emptyCollection.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.instEmptyCollectionFinset.{0} (Prod.{0, 0} Nat Nat)))
-Case conversion may be inaccurate. Consider using '#align young_diagram.cells_bot YoungDiagram.cells_botₓ'. -/
 @[simp]
 theorem cells_bot : (⊥ : YoungDiagram).cells = ∅ :=
   rfl
 #align young_diagram.cells_bot YoungDiagram.cells_bot
 
-/- warning: young_diagram.coe_bot -> YoungDiagram.coe_bot is a dubious translation:
-lean 3 declaration is
-  Eq.{1} (Set.{0} (Prod.{0, 0} Nat Nat)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (HasLiftT.mk.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (CoeTCₓ.coe.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (SetLike.Set.hasCoeT.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (Bot.bot.{0} YoungDiagram (OrderBot.toHasBot.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) YoungDiagram.orderBot))) (EmptyCollection.emptyCollection.{0} (Set.{0} (Prod.{0, 0} Nat Nat)) (Set.hasEmptyc.{0} (Prod.{0, 0} Nat Nat)))
-but is expected to have type
-  Eq.{1} (Set.{0} (Prod.{0, 0} Nat Nat)) (Finset.toSet.{0} (Prod.{0, 0} Nat Nat) (YoungDiagram.cells (Bot.bot.{0} YoungDiagram (OrderBot.toBot.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.instPartialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat))) YoungDiagram.instOrderBotYoungDiagramToLEToPreorderInstPartialOrderProdNatInstSetLikeYoungDiagramProdNat)))) (EmptyCollection.emptyCollection.{0} (Set.{0} (Prod.{0, 0} Nat Nat)) (Set.instEmptyCollectionSet.{0} (Prod.{0, 0} Nat Nat)))
-Case conversion may be inaccurate. Consider using '#align young_diagram.coe_bot YoungDiagram.coe_botₓ'. -/
 @[simp, norm_cast]
 theorem coe_bot : ↑(⊥ : YoungDiagram) = (∅ : Set (ℕ × ℕ)) :=
   rfl
 #align young_diagram.coe_bot YoungDiagram.coe_bot
 
-/- warning: young_diagram.not_mem_bot -> YoungDiagram.not_mem_bot is a dubious translation:
-lean 3 declaration is
-  forall (x : Prod.{0, 0} Nat Nat), Not (Membership.Mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.hasMem.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike) x (Bot.bot.{0} YoungDiagram (OrderBot.toHasBot.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) YoungDiagram.orderBot)))
-but is expected to have type
-  forall (x : Prod.{0, 0} Nat Nat), Not (Membership.mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.instMembership.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat) x (Bot.bot.{0} YoungDiagram (OrderBot.toBot.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.instPartialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat))) YoungDiagram.instOrderBotYoungDiagramToLEToPreorderInstPartialOrderProdNatInstSetLikeYoungDiagramProdNat)))
-Case conversion may be inaccurate. Consider using '#align young_diagram.not_mem_bot YoungDiagram.not_mem_botₓ'. -/
 @[simp]
 theorem not_mem_bot (x : ℕ × ℕ) : x ∉ (⊥ : YoungDiagram) :=
   Finset.not_mem_empty x
@@ -305,46 +251,22 @@ theorem transpose_eq_iff {μ ν : YoungDiagram} : μ.transpose = ν.transpose 
 #align young_diagram.transpose_eq_iff YoungDiagram.transpose_eq_iff
 -/
 
-/- warning: young_diagram.le_of_transpose_le -> YoungDiagram.le_of_transpose_le is a dubious translation:
-lean 3 declaration is
-  forall {μ : YoungDiagram} {ν : YoungDiagram}, (LE.le.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (YoungDiagram.transpose μ) ν) -> (LE.le.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ (YoungDiagram.transpose ν))
-but is expected to have type
-  forall {μ : YoungDiagram} {ν : YoungDiagram}, (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) (YoungDiagram.transpose μ) ν) -> (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) μ (YoungDiagram.transpose ν))
-Case conversion may be inaccurate. Consider using '#align young_diagram.le_of_transpose_le YoungDiagram.le_of_transpose_leₓ'. -/
 -- This is effectively both directions of `transpose_le_iff` below.
 protected theorem le_of_transpose_le {μ ν : YoungDiagram} (h_le : μ.transpose ≤ ν) :
     μ ≤ ν.transpose := fun c hc => by simp only [mem_transpose]; apply h_le; simpa
 #align young_diagram.le_of_transpose_le YoungDiagram.le_of_transpose_le
 
-/- warning: young_diagram.transpose_le_iff -> YoungDiagram.transpose_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {μ : YoungDiagram} {ν : YoungDiagram}, Iff (LE.le.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (YoungDiagram.transpose μ) (YoungDiagram.transpose ν)) (LE.le.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ ν)
-but is expected to have type
-  forall {μ : YoungDiagram} {ν : YoungDiagram}, Iff (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) (YoungDiagram.transpose μ) (YoungDiagram.transpose ν)) (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) μ ν)
-Case conversion may be inaccurate. Consider using '#align young_diagram.transpose_le_iff YoungDiagram.transpose_le_iffₓ'. -/
 @[simp]
 theorem transpose_le_iff {μ ν : YoungDiagram} : μ.transpose ≤ ν.transpose ↔ μ ≤ ν :=
   ⟨fun h => by convert YoungDiagram.le_of_transpose_le h; simp, fun h => by
     convert@YoungDiagram.le_of_transpose_le _ _ _; simpa⟩
 #align young_diagram.transpose_le_iff YoungDiagram.transpose_le_iff
 
-/- warning: young_diagram.transpose_mono -> YoungDiagram.transpose_mono is a dubious translation:
-lean 3 declaration is
-  forall {μ : YoungDiagram} {ν : YoungDiagram}, (LE.le.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ ν) -> (LE.le.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (YoungDiagram.transpose μ) (YoungDiagram.transpose ν))
-but is expected to have type
-  forall {μ : YoungDiagram} {ν : YoungDiagram}, (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) μ ν) -> (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) (YoungDiagram.transpose μ) (YoungDiagram.transpose ν))
-Case conversion may be inaccurate. Consider using '#align young_diagram.transpose_mono YoungDiagram.transpose_monoₓ'. -/
 @[mono]
 protected theorem transpose_mono {μ ν : YoungDiagram} (h_le : μ ≤ ν) : μ.transpose ≤ ν.transpose :=
   transpose_le_iff.mpr h_le
 #align young_diagram.transpose_mono YoungDiagram.transpose_mono
 
-/- warning: young_diagram.transpose_order_iso -> YoungDiagram.transposeOrderIso is a dubious translation:
-lean 3 declaration is
-  OrderIso.{0, 0} YoungDiagram YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike)))
-but is expected to have type
-  OrderIso.{0, 0} YoungDiagram YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram)))))
-Case conversion may be inaccurate. Consider using '#align young_diagram.transpose_order_iso YoungDiagram.transposeOrderIsoₓ'. -/
 /-- Transposing Young diagrams is an `order_iso`. -/
 @[simps]
 def transposeOrderIso : YoungDiagram ≃o YoungDiagram :=
@@ -541,12 +463,6 @@ def rowLens (μ : YoungDiagram) : List ℕ :=
 #align young_diagram.row_lens YoungDiagram.rowLens
 -/
 
-/- warning: young_diagram.nth_le_row_lens -> YoungDiagram.get_rowLens is a dubious translation:
-lean 3 declaration is
-  forall {μ : YoungDiagram} {i : Nat} {hi : LT.lt.{0} Nat Nat.hasLt i (List.length.{0} Nat (YoungDiagram.rowLens μ))}, Eq.{1} Nat (List.nthLe.{0} Nat (YoungDiagram.rowLens μ) i hi) (YoungDiagram.rowLen μ i)
-but is expected to have type
-  forall {μ : YoungDiagram} {i : Fin (List.length.{0} Nat (YoungDiagram.rowLens μ))}, Eq.{1} Nat (List.get.{0} Nat (YoungDiagram.rowLens μ) i) (YoungDiagram.rowLen μ (Fin.val (List.length.{0} Nat (YoungDiagram.rowLens μ)) i))
-Case conversion may be inaccurate. Consider using '#align young_diagram.nth_le_row_lens YoungDiagram.get_rowLensₓ'. -/
 @[simp]
 theorem get_rowLens {μ : YoungDiagram} {i : ℕ} {hi : i < μ.rowLens.length} :
     μ.rowLens.nthLe i hi = μ.rowLen i := by simp only [row_lens, List.nthLe_range, List.nthLe_map']
@@ -653,12 +569,6 @@ theorem rowLens_length_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (hpo
 #align young_diagram.row_lens_length_of_row_lens YoungDiagram.rowLens_length_ofRowLens
 -/
 
-/- warning: young_diagram.row_len_of_row_lens -> YoungDiagram.rowLen_ofRowLens is a dubious translation:
-lean 3 declaration is
-  forall {w : List.{0} Nat} {hw : List.Sorted.{0} Nat (GE.ge.{0} Nat Nat.hasLe) w} (i : Nat) (hi : LT.lt.{0} Nat Nat.hasLt i (List.length.{0} Nat w)), Eq.{1} Nat (YoungDiagram.rowLen (YoungDiagram.ofRowLens w hw) i) (List.nthLe.{0} Nat w i hi)
-but is expected to have type
-  forall {w : List.{0} Nat} {hw : List.Sorted.{0} Nat (fun (x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2936 : Nat) (x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2938 : Nat) => GE.ge.{0} Nat instLENat x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2936 x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2938) w} (i : Fin (List.length.{0} Nat w)), Eq.{1} Nat (YoungDiagram.rowLen (YoungDiagram.ofRowLens w hw) (Fin.val (List.length.{0} Nat w) i)) (List.get.{0} Nat w i)
-Case conversion may be inaccurate. Consider using '#align young_diagram.row_len_of_row_lens YoungDiagram.rowLen_ofRowLensₓ'. -/
 /-- The length of the `i`th row in `of_row_lens w hw` is the `i`th entry of `w` -/
 theorem rowLen_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (i : ℕ) (hi : i < w.length) :
     (ofRowLens w hw).rowLen i = w.nthLe i hi := by

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

@@ -288,27 +288,20 @@ theorem mem_transpose {μ : YoungDiagram} {c : ℕ × ℕ} : c ∈ μ.transpose
 
 #print YoungDiagram.transpose_transpose /-
 @[simp]
-theorem transpose_transpose (μ : YoungDiagram) : μ.transpose.transpose = μ :=
-  by
-  ext
-  simp
+theorem transpose_transpose (μ : YoungDiagram) : μ.transpose.transpose = μ := by ext; simp
 #align young_diagram.transpose_transpose YoungDiagram.transpose_transpose
 -/
 
 #print YoungDiagram.transpose_eq_iff_eq_transpose /-
 theorem transpose_eq_iff_eq_transpose {μ ν : YoungDiagram} : μ.transpose = ν ↔ μ = ν.transpose := by
-  constructor <;>
-    · rintro rfl
-      simp
+  constructor <;> · rintro rfl; simp
 #align young_diagram.transpose_eq_iff_eq_transpose YoungDiagram.transpose_eq_iff_eq_transpose
 -/
 
 #print YoungDiagram.transpose_eq_iff /-
 @[simp]
-theorem transpose_eq_iff {μ ν : YoungDiagram} : μ.transpose = ν.transpose ↔ μ = ν :=
-  by
-  rw [transpose_eq_iff_eq_transpose]
-  simp
+theorem transpose_eq_iff {μ ν : YoungDiagram} : μ.transpose = ν.transpose ↔ μ = ν := by
+  rw [transpose_eq_iff_eq_transpose]; simp
 #align young_diagram.transpose_eq_iff YoungDiagram.transpose_eq_iff
 -/
 
@@ -320,10 +313,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align young_diagram.le_of_transpose_le YoungDiagram.le_of_transpose_leₓ'. -/
 -- This is effectively both directions of `transpose_le_iff` below.
 protected theorem le_of_transpose_le {μ ν : YoungDiagram} (h_le : μ.transpose ≤ ν) :
-    μ ≤ ν.transpose := fun c hc => by
-  simp only [mem_transpose]
-  apply h_le
-  simpa
+    μ ≤ ν.transpose := fun c hc => by simp only [mem_transpose]; apply h_le; simpa
 #align young_diagram.le_of_transpose_le YoungDiagram.le_of_transpose_le
 
 /- warning: young_diagram.transpose_le_iff -> YoungDiagram.transpose_le_iff is a dubious translation:
@@ -334,11 +324,8 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align young_diagram.transpose_le_iff YoungDiagram.transpose_le_iffₓ'. -/
 @[simp]
 theorem transpose_le_iff {μ ν : YoungDiagram} : μ.transpose ≤ ν.transpose ↔ μ ≤ ν :=
-  ⟨fun h => by
-    convert YoungDiagram.le_of_transpose_le h
-    simp, fun h => by
-    convert@YoungDiagram.le_of_transpose_le _ _ _
-    simpa⟩
+  ⟨fun h => by convert YoungDiagram.le_of_transpose_le h; simp, fun h => by
+    convert@YoungDiagram.le_of_transpose_le _ _ _; simpa⟩
 #align young_diagram.transpose_le_iff YoungDiagram.transpose_le_iff
 
 /- warning: young_diagram.transpose_mono -> YoungDiagram.transpose_mono is a dubious translation:
@@ -402,11 +389,7 @@ theorem mk_mem_row_iff {μ : YoungDiagram} {i j : ℕ} : (i, j) ∈ μ.row i ↔
 protected theorem exists_not_mem_row (μ : YoungDiagram) (i : ℕ) : ∃ j, (i, j) ∉ μ :=
   by
   obtain ⟨j, hj⟩ :=
-    Infinite.exists_not_mem_finset
-      (μ.cells.Preimage (Prod.mk i) fun _ _ _ _ h =>
-        by
-        cases h
-        rfl)
+    Infinite.exists_not_mem_finset (μ.cells.Preimage (Prod.mk i) fun _ _ _ _ h => by cases h; rfl)
   rw [Finset.mem_preimage] at hj
   exact ⟨j, hj⟩
 #align young_diagram.exists_not_mem_row YoungDiagram.exists_not_mem_row
@@ -422,8 +405,7 @@ def rowLen (μ : YoungDiagram) (i : ℕ) : ℕ :=
 #print YoungDiagram.mem_iff_lt_rowLen /-
 theorem mem_iff_lt_rowLen {μ : YoungDiagram} {i j : ℕ} : (i, j) ∈ μ ↔ j < μ.rowLen i :=
   by
-  rw [row_len, Nat.lt_find_iff]
-  push_neg
+  rw [row_len, Nat.lt_find_iff]; push_neg
   exact ⟨fun h _ hmj => μ.up_left_mem (by rfl) hmj h, fun h => h _ (by rfl)⟩
 #align young_diagram.mem_iff_lt_row_len YoungDiagram.mem_iff_lt_rowLen
 -/
@@ -435,8 +417,7 @@ theorem row_eq_prod {μ : YoungDiagram} {i : ℕ} : μ.row i = {i} ×ˢ Finset.r
   ext ⟨a, b⟩
   simp only [Finset.mem_product, Finset.mem_singleton, Finset.mem_range, mem_row_iff,
     mem_iff_lt_row_len, and_comm', and_congr_right_iff]
-  rintro rfl
-  rfl
+  rintro rfl; rfl
 #align young_diagram.row_eq_prod YoungDiagram.row_eq_prod
 -/
 
@@ -450,8 +431,7 @@ theorem rowLen_eq_card (μ : YoungDiagram) {i : ℕ} : μ.rowLen i = (μ.row i).
 @[mono]
 theorem rowLen_anti (μ : YoungDiagram) (i1 i2 : ℕ) (hi : i1 ≤ i2) : μ.rowLen i2 ≤ μ.rowLen i1 :=
   by
-  by_contra' h_lt
-  rw [← lt_self_iff_false (μ.row_len i1)]
+  by_contra' h_lt; rw [← lt_self_iff_false (μ.row_len i1)]
   rw [← mem_iff_lt_row_len] at h_lt⊢
   exact μ.up_left_mem hi (by rfl) h_lt
 #align young_diagram.row_len_anti YoungDiagram.rowLen_anti
@@ -485,10 +465,8 @@ theorem mk_mem_col_iff {μ : YoungDiagram} {i j : ℕ} : (i, j) ∈ μ.col j ↔
 -/
 
 #print YoungDiagram.exists_not_mem_col /-
-protected theorem exists_not_mem_col (μ : YoungDiagram) (j : ℕ) : ∃ i, (i, j) ∉ μ.cells :=
-  by
-  convert μ.transpose.exists_not_mem_row j
-  simp
+protected theorem exists_not_mem_col (μ : YoungDiagram) (j : ℕ) : ∃ i, (i, j) ∉ μ.cells := by
+  convert μ.transpose.exists_not_mem_row j; simp
 #align young_diagram.exists_not_mem_col YoungDiagram.exists_not_mem_col
 -/
 
@@ -514,10 +492,8 @@ theorem rowLen_transpose (μ : YoungDiagram) (i : ℕ) : μ.transpose.rowLen i =
 -/
 
 #print YoungDiagram.mem_iff_lt_colLen /-
-theorem mem_iff_lt_colLen {μ : YoungDiagram} {i j : ℕ} : (i, j) ∈ μ ↔ i < μ.colLen j :=
-  by
-  rw [← row_len_transpose, ← mem_iff_lt_row_len]
-  simp
+theorem mem_iff_lt_colLen {μ : YoungDiagram} {i j : ℕ} : (i, j) ∈ μ ↔ i < μ.colLen j := by
+  rw [← row_len_transpose, ← mem_iff_lt_row_len]; simp
 #align young_diagram.mem_iff_lt_col_len YoungDiagram.mem_iff_lt_colLen
 -/
 
@@ -528,8 +504,7 @@ theorem col_eq_prod {μ : YoungDiagram} {j : ℕ} : μ.col j = Finset.range (μ.
   ext ⟨a, b⟩
   simp only [Finset.mem_product, Finset.mem_singleton, Finset.mem_range, mem_col_iff,
     mem_iff_lt_col_len, and_comm', and_congr_right_iff]
-  rintro rfl
-  rfl
+  rintro rfl; rfl
 #align young_diagram.col_eq_prod YoungDiagram.col_eq_prod
 -/
 

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

@@ -113,7 +113,7 @@ section DistribLattice
 
 /- warning: young_diagram.cells_subset_iff -> YoungDiagram.cells_subset_iff is a dubious translation:
 lean 3 declaration is
-  forall {μ : YoungDiagram} {ν : YoungDiagram}, Iff (HasSubset.Subset.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.hasSubset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells μ) (YoungDiagram.cells ν)) (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ ν)
+  forall {μ : YoungDiagram} {ν : YoungDiagram}, Iff (HasSubset.Subset.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.hasSubset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells μ) (YoungDiagram.cells ν)) (LE.le.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ ν)
 but is expected to have type
   forall {μ : YoungDiagram} {ν : YoungDiagram}, Iff (HasSubset.Subset.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.instHasSubsetFinset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells μ) (YoungDiagram.cells ν)) (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.instPartialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat))) μ ν)
 Case conversion may be inaccurate. Consider using '#align young_diagram.cells_subset_iff YoungDiagram.cells_subset_iffₓ'. -/
@@ -124,7 +124,7 @@ theorem cells_subset_iff {μ ν : YoungDiagram} : μ.cells ⊆ ν.cells ↔ μ 
 
 /- warning: young_diagram.cells_ssubset_iff -> YoungDiagram.cells_ssubset_iff is a dubious translation:
 lean 3 declaration is
-  forall {μ : YoungDiagram} {ν : YoungDiagram}, Iff (HasSSubset.SSubset.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.hasSsubset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells μ) (YoungDiagram.cells ν)) (LT.lt.{0} YoungDiagram (Preorder.toLT.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ ν)
+  forall {μ : YoungDiagram} {ν : YoungDiagram}, Iff (HasSSubset.SSubset.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.hasSsubset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells μ) (YoungDiagram.cells ν)) (LT.lt.{0} YoungDiagram (Preorder.toHasLt.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ ν)
 but is expected to have type
   forall {μ : YoungDiagram} {ν : YoungDiagram}, Iff (HasSSubset.SSubset.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.instHasSSubsetFinset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells μ) (YoungDiagram.cells ν)) (LT.lt.{0} YoungDiagram (Preorder.toLT.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.instPartialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat))) μ ν)
 Case conversion may be inaccurate. Consider using '#align young_diagram.cells_ssubset_iff YoungDiagram.cells_ssubset_iffₓ'. -/
@@ -215,7 +215,7 @@ instance : OrderBot YoungDiagram
 
 /- warning: young_diagram.cells_bot -> YoungDiagram.cells_bot is a dubious translation:
 lean 3 declaration is
-  Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (Bot.bot.{0} YoungDiagram (OrderBot.toHasBot.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) YoungDiagram.orderBot))) (EmptyCollection.emptyCollection.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.hasEmptyc.{0} (Prod.{0, 0} Nat Nat)))
+  Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (Bot.bot.{0} YoungDiagram (OrderBot.toHasBot.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) YoungDiagram.orderBot))) (EmptyCollection.emptyCollection.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.hasEmptyc.{0} (Prod.{0, 0} Nat Nat)))
 but is expected to have type
   Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (Bot.bot.{0} YoungDiagram (OrderBot.toBot.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.instPartialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat))) YoungDiagram.instOrderBotYoungDiagramToLEToPreorderInstPartialOrderProdNatInstSetLikeYoungDiagramProdNat))) (EmptyCollection.emptyCollection.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.instEmptyCollectionFinset.{0} (Prod.{0, 0} Nat Nat)))
 Case conversion may be inaccurate. Consider using '#align young_diagram.cells_bot YoungDiagram.cells_botₓ'. -/
@@ -226,7 +226,7 @@ theorem cells_bot : (⊥ : YoungDiagram).cells = ∅ :=
 
 /- warning: young_diagram.coe_bot -> YoungDiagram.coe_bot is a dubious translation:
 lean 3 declaration is
-  Eq.{1} (Set.{0} (Prod.{0, 0} Nat Nat)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (HasLiftT.mk.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (CoeTCₓ.coe.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (SetLike.Set.hasCoeT.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (Bot.bot.{0} YoungDiagram (OrderBot.toHasBot.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) YoungDiagram.orderBot))) (EmptyCollection.emptyCollection.{0} (Set.{0} (Prod.{0, 0} Nat Nat)) (Set.hasEmptyc.{0} (Prod.{0, 0} Nat Nat)))
+  Eq.{1} (Set.{0} (Prod.{0, 0} Nat Nat)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (HasLiftT.mk.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (CoeTCₓ.coe.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (SetLike.Set.hasCoeT.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (Bot.bot.{0} YoungDiagram (OrderBot.toHasBot.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) YoungDiagram.orderBot))) (EmptyCollection.emptyCollection.{0} (Set.{0} (Prod.{0, 0} Nat Nat)) (Set.hasEmptyc.{0} (Prod.{0, 0} Nat Nat)))
 but is expected to have type
   Eq.{1} (Set.{0} (Prod.{0, 0} Nat Nat)) (Finset.toSet.{0} (Prod.{0, 0} Nat Nat) (YoungDiagram.cells (Bot.bot.{0} YoungDiagram (OrderBot.toBot.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.instPartialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat))) YoungDiagram.instOrderBotYoungDiagramToLEToPreorderInstPartialOrderProdNatInstSetLikeYoungDiagramProdNat)))) (EmptyCollection.emptyCollection.{0} (Set.{0} (Prod.{0, 0} Nat Nat)) (Set.instEmptyCollectionSet.{0} (Prod.{0, 0} Nat Nat)))
 Case conversion may be inaccurate. Consider using '#align young_diagram.coe_bot YoungDiagram.coe_botₓ'. -/
@@ -237,7 +237,7 @@ theorem coe_bot : ↑(⊥ : YoungDiagram) = (∅ : Set (ℕ × ℕ)) :=
 
 /- warning: young_diagram.not_mem_bot -> YoungDiagram.not_mem_bot is a dubious translation:
 lean 3 declaration is
-  forall (x : Prod.{0, 0} Nat Nat), Not (Membership.Mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.hasMem.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike) x (Bot.bot.{0} YoungDiagram (OrderBot.toHasBot.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) YoungDiagram.orderBot)))
+  forall (x : Prod.{0, 0} Nat Nat), Not (Membership.Mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.hasMem.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike) x (Bot.bot.{0} YoungDiagram (OrderBot.toHasBot.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) YoungDiagram.orderBot)))
 but is expected to have type
   forall (x : Prod.{0, 0} Nat Nat), Not (Membership.mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.instMembership.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat) x (Bot.bot.{0} YoungDiagram (OrderBot.toBot.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.instPartialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat))) YoungDiagram.instOrderBotYoungDiagramToLEToPreorderInstPartialOrderProdNatInstSetLikeYoungDiagramProdNat)))
 Case conversion may be inaccurate. Consider using '#align young_diagram.not_mem_bot YoungDiagram.not_mem_botₓ'. -/
@@ -314,7 +314,7 @@ theorem transpose_eq_iff {μ ν : YoungDiagram} : μ.transpose = ν.transpose 
 
 /- warning: young_diagram.le_of_transpose_le -> YoungDiagram.le_of_transpose_le is a dubious translation:
 lean 3 declaration is
-  forall {μ : YoungDiagram} {ν : YoungDiagram}, (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (YoungDiagram.transpose μ) ν) -> (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ (YoungDiagram.transpose ν))
+  forall {μ : YoungDiagram} {ν : YoungDiagram}, (LE.le.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (YoungDiagram.transpose μ) ν) -> (LE.le.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ (YoungDiagram.transpose ν))
 but is expected to have type
   forall {μ : YoungDiagram} {ν : YoungDiagram}, (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) (YoungDiagram.transpose μ) ν) -> (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) μ (YoungDiagram.transpose ν))
 Case conversion may be inaccurate. Consider using '#align young_diagram.le_of_transpose_le YoungDiagram.le_of_transpose_leₓ'. -/
@@ -328,7 +328,7 @@ protected theorem le_of_transpose_le {μ ν : YoungDiagram} (h_le : μ.transpose
 
 /- warning: young_diagram.transpose_le_iff -> YoungDiagram.transpose_le_iff is a dubious translation:
 lean 3 declaration is
-  forall {μ : YoungDiagram} {ν : YoungDiagram}, Iff (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (YoungDiagram.transpose μ) (YoungDiagram.transpose ν)) (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ ν)
+  forall {μ : YoungDiagram} {ν : YoungDiagram}, Iff (LE.le.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (YoungDiagram.transpose μ) (YoungDiagram.transpose ν)) (LE.le.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ ν)
 but is expected to have type
   forall {μ : YoungDiagram} {ν : YoungDiagram}, Iff (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) (YoungDiagram.transpose μ) (YoungDiagram.transpose ν)) (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) μ ν)
 Case conversion may be inaccurate. Consider using '#align young_diagram.transpose_le_iff YoungDiagram.transpose_le_iffₓ'. -/
@@ -343,7 +343,7 @@ theorem transpose_le_iff {μ ν : YoungDiagram} : μ.transpose ≤ ν.transpose
 
 /- warning: young_diagram.transpose_mono -> YoungDiagram.transpose_mono is a dubious translation:
 lean 3 declaration is
-  forall {μ : YoungDiagram} {ν : YoungDiagram}, (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ ν) -> (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (YoungDiagram.transpose μ) (YoungDiagram.transpose ν))
+  forall {μ : YoungDiagram} {ν : YoungDiagram}, (LE.le.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ ν) -> (LE.le.{0} YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (YoungDiagram.transpose μ) (YoungDiagram.transpose ν))
 but is expected to have type
   forall {μ : YoungDiagram} {ν : YoungDiagram}, (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) μ ν) -> (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) (YoungDiagram.transpose μ) (YoungDiagram.transpose ν))
 Case conversion may be inaccurate. Consider using '#align young_diagram.transpose_mono YoungDiagram.transpose_monoₓ'. -/
@@ -354,7 +354,7 @@ protected theorem transpose_mono {μ ν : YoungDiagram} (h_le : μ ≤ ν) : μ.
 
 /- warning: young_diagram.transpose_order_iso -> YoungDiagram.transposeOrderIso is a dubious translation:
 lean 3 declaration is
-  OrderIso.{0, 0} YoungDiagram YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike)))
+  OrderIso.{0, 0} YoungDiagram YoungDiagram (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (Preorder.toHasLe.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike)))
 but is expected to have type
   OrderIso.{0, 0} YoungDiagram YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram)))))
 Case conversion may be inaccurate. Consider using '#align young_diagram.transpose_order_iso YoungDiagram.transposeOrderIsoₓ'. -/

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

@@ -593,7 +593,7 @@ theorem rowLens_sorted (μ : YoungDiagram) : μ.rowLens.Sorted (· ≥ ·) :=
 #print YoungDiagram.pos_of_mem_rowLens /-
 theorem pos_of_mem_rowLens (μ : YoungDiagram) (x : ℕ) (hx : x ∈ μ.rowLens) : 0 < x :=
   by
-  rw [row_lens, List.mem_map'] at hx
+  rw [row_lens, List.mem_map] at hx
   obtain ⟨i, hi, rfl : μ.row_len i = x⟩ := hx
   rwa [List.mem_range, ← mem_iff_lt_col_len, mem_iff_lt_row_len] at hi
 #align young_diagram.pos_of_mem_row_lens YoungDiagram.pos_of_mem_rowLens

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

@@ -337,7 +337,7 @@ theorem transpose_le_iff {μ ν : YoungDiagram} : μ.transpose ≤ ν.transpose
   ⟨fun h => by
     convert YoungDiagram.le_of_transpose_le h
     simp, fun h => by
-    convert @YoungDiagram.le_of_transpose_le _ _ _
+    convert@YoungDiagram.le_of_transpose_le _ _ _
     simpa⟩
 #align young_diagram.transpose_le_iff YoungDiagram.transpose_le_iff
 
@@ -682,7 +682,7 @@ theorem rowLens_length_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (hpo
 lean 3 declaration is
   forall {w : List.{0} Nat} {hw : List.Sorted.{0} Nat (GE.ge.{0} Nat Nat.hasLe) w} (i : Nat) (hi : LT.lt.{0} Nat Nat.hasLt i (List.length.{0} Nat w)), Eq.{1} Nat (YoungDiagram.rowLen (YoungDiagram.ofRowLens w hw) i) (List.nthLe.{0} Nat w i hi)
 but is expected to have type
-  forall {w : List.{0} Nat} {hw : List.Sorted.{0} Nat (fun (x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2898 : Nat) (x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2900 : Nat) => GE.ge.{0} Nat instLENat x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2898 x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2900) w} (i : Fin (List.length.{0} Nat w)), Eq.{1} Nat (YoungDiagram.rowLen (YoungDiagram.ofRowLens w hw) (Fin.val (List.length.{0} Nat w) i)) (List.get.{0} Nat w i)
+  forall {w : List.{0} Nat} {hw : List.Sorted.{0} Nat (fun (x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2936 : Nat) (x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2938 : Nat) => GE.ge.{0} Nat instLENat x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2936 x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2938) w} (i : Fin (List.length.{0} Nat w)), Eq.{1} Nat (YoungDiagram.rowLen (YoungDiagram.ofRowLens w hw) (Fin.val (List.length.{0} Nat w) i)) (List.get.{0} Nat w i)
 Case conversion may be inaccurate. Consider using '#align young_diagram.row_len_of_row_lens YoungDiagram.rowLen_ofRowLensₓ'. -/
 /-- The length of the `i`th row in `of_row_lens w hw` is the `i`th entry of `w` -/
 theorem rowLen_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (i : ℕ) (hi : i < w.length) :

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

@@ -682,7 +682,7 @@ theorem rowLens_length_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (hpo
 lean 3 declaration is
   forall {w : List.{0} Nat} {hw : List.Sorted.{0} Nat (GE.ge.{0} Nat Nat.hasLe) w} (i : Nat) (hi : LT.lt.{0} Nat Nat.hasLt i (List.length.{0} Nat w)), Eq.{1} Nat (YoungDiagram.rowLen (YoungDiagram.ofRowLens w hw) i) (List.nthLe.{0} Nat w i hi)
 but is expected to have type
-  forall {w : List.{0} Nat} {hw : List.Sorted.{0} Nat (fun (x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2897 : Nat) (x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2899 : Nat) => GE.ge.{0} Nat instLENat x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2897 x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2899) w} (i : Fin (List.length.{0} Nat w)), Eq.{1} Nat (YoungDiagram.rowLen (YoungDiagram.ofRowLens w hw) (Fin.val (List.length.{0} Nat w) i)) (List.get.{0} Nat w i)
+  forall {w : List.{0} Nat} {hw : List.Sorted.{0} Nat (fun (x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2898 : Nat) (x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2900 : Nat) => GE.ge.{0} Nat instLENat x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2898 x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2900) w} (i : Fin (List.length.{0} Nat w)), Eq.{1} Nat (YoungDiagram.rowLen (YoungDiagram.ofRowLens w hw) (Fin.val (List.length.{0} Nat w) i)) (List.get.{0} Nat w i)
 Case conversion may be inaccurate. Consider using '#align young_diagram.row_len_of_row_lens YoungDiagram.rowLen_ofRowLensₓ'. -/
 /-- The length of the `i`th row in `of_row_lens w hw` is the `i`th entry of `w` -/
 theorem rowLen_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (i : ℕ) (hi : i < w.length) :

mathlib commit https://github.com/leanprover-community/mathlib/commit/195fcd60ff2bfe392543bceb0ec2adcdb472db4c

@@ -682,7 +682,7 @@ theorem rowLens_length_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (hpo
 lean 3 declaration is
   forall {w : List.{0} Nat} {hw : List.Sorted.{0} Nat (GE.ge.{0} Nat Nat.hasLe) w} (i : Nat) (hi : LT.lt.{0} Nat Nat.hasLt i (List.length.{0} Nat w)), Eq.{1} Nat (YoungDiagram.rowLen (YoungDiagram.ofRowLens w hw) i) (List.nthLe.{0} Nat w i hi)
 but is expected to have type
-  forall {w : List.{0} Nat} {hw : List.Sorted.{0} Nat (fun (x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2895 : Nat) (x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2897 : Nat) => GE.ge.{0} Nat instLENat x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2895 x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2897) w} (i : Fin (List.length.{0} Nat w)), Eq.{1} Nat (YoungDiagram.rowLen (YoungDiagram.ofRowLens w hw) (Fin.val (List.length.{0} Nat w) i)) (List.get.{0} Nat w i)
+  forall {w : List.{0} Nat} {hw : List.Sorted.{0} Nat (fun (x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2897 : Nat) (x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2899 : Nat) => GE.ge.{0} Nat instLENat x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2897 x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2899) w} (i : Fin (List.length.{0} Nat w)), Eq.{1} Nat (YoungDiagram.rowLen (YoungDiagram.ofRowLens w hw) (Fin.val (List.length.{0} Nat w) i)) (List.get.{0} Nat w i)
 Case conversion may be inaccurate. Consider using '#align young_diagram.row_len_of_row_lens YoungDiagram.rowLen_ofRowLensₓ'. -/
 /-- The length of the `i`th row in `of_row_lens w hw` is the `i`th entry of `w` -/
 theorem rowLen_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (i : ℕ) (hi : i < w.length) :

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

@@ -133,7 +133,7 @@ theorem cells_ssubset_iff {μ ν : YoungDiagram} : μ.cells ⊂ ν.cells ↔ μ
   Iff.rfl
 #align young_diagram.cells_ssubset_iff YoungDiagram.cells_ssubset_iff
 
-instance : HasSup YoungDiagram
+instance : Sup YoungDiagram
     where sup μ ν :=
     { cells := μ.cells ∪ ν.cells
       IsLowerSet := by
@@ -142,9 +142,9 @@ instance : HasSup YoungDiagram
 
 /- warning: young_diagram.cells_sup -> YoungDiagram.cells_sup is a dubious translation:
 lean 3 declaration is
-  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (HasSup.sup.{0} YoungDiagram YoungDiagram.hasSup μ ν)) (Union.union.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.hasUnion.{0} (Prod.{0, 0} Nat Nat) (fun (a : Prod.{0, 0} Nat Nat) (b : Prod.{0, 0} Nat Nat) => Prod.decidableEq.{0, 0} Nat Nat (fun (a : Nat) (b : Nat) => Nat.decidableEq a b) (fun (a : Nat) (b : Nat) => Nat.decidableEq a b) a b)) (YoungDiagram.cells μ) (YoungDiagram.cells ν))
+  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (Sup.sup.{0} YoungDiagram YoungDiagram.hasSup μ ν)) (Union.union.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.hasUnion.{0} (Prod.{0, 0} Nat Nat) (fun (a : Prod.{0, 0} Nat Nat) (b : Prod.{0, 0} Nat Nat) => Prod.decidableEq.{0, 0} Nat Nat (fun (a : Nat) (b : Nat) => Nat.decidableEq a b) (fun (a : Nat) (b : Nat) => Nat.decidableEq a b) a b)) (YoungDiagram.cells μ) (YoungDiagram.cells ν))
 but is expected to have type
-  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (HasSup.sup.{0} YoungDiagram YoungDiagram.instHasSupYoungDiagram μ ν)) (Union.union.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.instUnionFinset.{0} (Prod.{0, 0} Nat Nat) (fun (a : Prod.{0, 0} Nat Nat) (b : Prod.{0, 0} Nat Nat) => instDecidableEqProd.{0, 0} Nat Nat (fun (a : Nat) (b : Nat) => instDecidableEqNat a b) (fun (a : Nat) (b : Nat) => instDecidableEqNat a b) a b)) (YoungDiagram.cells μ) (YoungDiagram.cells ν))
+  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (Sup.sup.{0} YoungDiagram YoungDiagram.instSupYoungDiagram μ ν)) (Union.union.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.instUnionFinset.{0} (Prod.{0, 0} Nat Nat) (fun (a : Prod.{0, 0} Nat Nat) (b : Prod.{0, 0} Nat Nat) => instDecidableEqProd.{0, 0} Nat Nat (fun (a : Nat) (b : Nat) => instDecidableEqNat a b) (fun (a : Nat) (b : Nat) => instDecidableEqNat a b) a b)) (YoungDiagram.cells μ) (YoungDiagram.cells ν))
 Case conversion may be inaccurate. Consider using '#align young_diagram.cells_sup YoungDiagram.cells_supₓ'. -/
 @[simp]
 theorem cells_sup (μ ν : YoungDiagram) : (μ ⊔ ν).cells = μ.cells ∪ ν.cells :=
@@ -153,9 +153,9 @@ theorem cells_sup (μ ν : YoungDiagram) : (μ ⊔ ν).cells = μ.cells ∪ ν.c
 
 /- warning: young_diagram.coe_sup -> YoungDiagram.coe_sup is a dubious translation:
 lean 3 declaration is
-  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Set.{0} (Prod.{0, 0} Nat Nat)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (HasLiftT.mk.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (CoeTCₓ.coe.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (SetLike.Set.hasCoeT.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (HasSup.sup.{0} YoungDiagram YoungDiagram.hasSup μ ν)) (Union.union.{0} (Set.{0} (Prod.{0, 0} Nat Nat)) (Set.hasUnion.{0} (Prod.{0, 0} Nat Nat)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (HasLiftT.mk.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (CoeTCₓ.coe.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (SetLike.Set.hasCoeT.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (HasLiftT.mk.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (CoeTCₓ.coe.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (SetLike.Set.hasCoeT.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) ν))
+  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Set.{0} (Prod.{0, 0} Nat Nat)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (HasLiftT.mk.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (CoeTCₓ.coe.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (SetLike.Set.hasCoeT.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (Sup.sup.{0} YoungDiagram YoungDiagram.hasSup μ ν)) (Union.union.{0} (Set.{0} (Prod.{0, 0} Nat Nat)) (Set.hasUnion.{0} (Prod.{0, 0} Nat Nat)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (HasLiftT.mk.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (CoeTCₓ.coe.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (SetLike.Set.hasCoeT.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (HasLiftT.mk.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (CoeTCₓ.coe.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (SetLike.Set.hasCoeT.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) ν))
 but is expected to have type
-  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Set.{0} (Prod.{0, 0} Nat Nat)) (SetLike.coe.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat (HasSup.sup.{0} YoungDiagram YoungDiagram.instHasSupYoungDiagram μ ν)) (Union.union.{0} (Set.{0} (Prod.{0, 0} Nat Nat)) (Set.instUnionSet.{0} (Prod.{0, 0} Nat Nat)) (SetLike.coe.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat μ) (SetLike.coe.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat ν))
+  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Set.{0} (Prod.{0, 0} Nat Nat)) (SetLike.coe.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat (Sup.sup.{0} YoungDiagram YoungDiagram.instSupYoungDiagram μ ν)) (Union.union.{0} (Set.{0} (Prod.{0, 0} Nat Nat)) (Set.instUnionSet.{0} (Prod.{0, 0} Nat Nat)) (SetLike.coe.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat μ) (SetLike.coe.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat ν))
 Case conversion may be inaccurate. Consider using '#align young_diagram.coe_sup YoungDiagram.coe_supₓ'. -/
 @[simp, norm_cast]
 theorem coe_sup (μ ν : YoungDiagram) : ↑(μ ⊔ ν) = (μ ∪ ν : Set (ℕ × ℕ)) :=
@@ -164,16 +164,16 @@ theorem coe_sup (μ ν : YoungDiagram) : ↑(μ ⊔ ν) = (μ ∪ ν : Set (ℕ
 
 /- warning: young_diagram.mem_sup -> YoungDiagram.mem_sup is a dubious translation:
 lean 3 declaration is
-  forall {μ : YoungDiagram} {ν : YoungDiagram} {x : Prod.{0, 0} Nat Nat}, Iff (Membership.Mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.hasMem.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike) x (HasSup.sup.{0} YoungDiagram YoungDiagram.hasSup μ ν)) (Or (Membership.Mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.hasMem.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike) x μ) (Membership.Mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.hasMem.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike) x ν))
+  forall {μ : YoungDiagram} {ν : YoungDiagram} {x : Prod.{0, 0} Nat Nat}, Iff (Membership.Mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.hasMem.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike) x (Sup.sup.{0} YoungDiagram YoungDiagram.hasSup μ ν)) (Or (Membership.Mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.hasMem.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike) x μ) (Membership.Mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.hasMem.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike) x ν))
 but is expected to have type
-  forall {μ : YoungDiagram} {ν : YoungDiagram} {x : Prod.{0, 0} Nat Nat}, Iff (Membership.mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.instMembership.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat) x (HasSup.sup.{0} YoungDiagram YoungDiagram.instHasSupYoungDiagram μ ν)) (Or (Membership.mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.instMembership.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat) x μ) (Membership.mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.instMembership.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat) x ν))
+  forall {μ : YoungDiagram} {ν : YoungDiagram} {x : Prod.{0, 0} Nat Nat}, Iff (Membership.mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.instMembership.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat) x (Sup.sup.{0} YoungDiagram YoungDiagram.instSupYoungDiagram μ ν)) (Or (Membership.mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.instMembership.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat) x μ) (Membership.mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.instMembership.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat) x ν))
 Case conversion may be inaccurate. Consider using '#align young_diagram.mem_sup YoungDiagram.mem_supₓ'. -/
 @[simp]
 theorem mem_sup {μ ν : YoungDiagram} {x : ℕ × ℕ} : x ∈ μ ⊔ ν ↔ x ∈ μ ∨ x ∈ ν :=
   Finset.mem_union
 #align young_diagram.mem_sup YoungDiagram.mem_sup
 
-instance : HasInf YoungDiagram
+instance : Inf YoungDiagram
     where inf μ ν :=
     { cells := μ.cells ∩ ν.cells
       IsLowerSet := by
@@ -182,9 +182,9 @@ instance : HasInf YoungDiagram
 
 /- warning: young_diagram.cells_inf -> YoungDiagram.cells_inf is a dubious translation:
 lean 3 declaration is
-  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (HasInf.inf.{0} YoungDiagram YoungDiagram.hasInf μ ν)) (Inter.inter.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.hasInter.{0} (Prod.{0, 0} Nat Nat) (fun (a : Prod.{0, 0} Nat Nat) (b : Prod.{0, 0} Nat Nat) => Prod.decidableEq.{0, 0} Nat Nat (fun (a : Nat) (b : Nat) => Nat.decidableEq a b) (fun (a : Nat) (b : Nat) => Nat.decidableEq a b) a b)) (YoungDiagram.cells μ) (YoungDiagram.cells ν))
+  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (Inf.inf.{0} YoungDiagram YoungDiagram.hasInf μ ν)) (Inter.inter.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.hasInter.{0} (Prod.{0, 0} Nat Nat) (fun (a : Prod.{0, 0} Nat Nat) (b : Prod.{0, 0} Nat Nat) => Prod.decidableEq.{0, 0} Nat Nat (fun (a : Nat) (b : Nat) => Nat.decidableEq a b) (fun (a : Nat) (b : Nat) => Nat.decidableEq a b) a b)) (YoungDiagram.cells μ) (YoungDiagram.cells ν))
 but is expected to have type
-  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (HasInf.inf.{0} YoungDiagram YoungDiagram.instHasInfYoungDiagram μ ν)) (Inter.inter.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.instInterFinset.{0} (Prod.{0, 0} Nat Nat) (fun (a : Prod.{0, 0} Nat Nat) (b : Prod.{0, 0} Nat Nat) => instDecidableEqProd.{0, 0} Nat Nat (fun (a : Nat) (b : Nat) => instDecidableEqNat a b) (fun (a : Nat) (b : Nat) => instDecidableEqNat a b) a b)) (YoungDiagram.cells μ) (YoungDiagram.cells ν))
+  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (Inf.inf.{0} YoungDiagram YoungDiagram.instInfYoungDiagram μ ν)) (Inter.inter.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.instInterFinset.{0} (Prod.{0, 0} Nat Nat) (fun (a : Prod.{0, 0} Nat Nat) (b : Prod.{0, 0} Nat Nat) => instDecidableEqProd.{0, 0} Nat Nat (fun (a : Nat) (b : Nat) => instDecidableEqNat a b) (fun (a : Nat) (b : Nat) => instDecidableEqNat a b) a b)) (YoungDiagram.cells μ) (YoungDiagram.cells ν))
 Case conversion may be inaccurate. Consider using '#align young_diagram.cells_inf YoungDiagram.cells_infₓ'. -/
 @[simp]
 theorem cells_inf (μ ν : YoungDiagram) : (μ ⊓ ν).cells = μ.cells ∩ ν.cells :=

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

@@ -180,12 +180,16 @@ instance : HasInf YoungDiagram
         rw [Finset.coe_inter]
         exact μ.is_lower_set.inter ν.is_lower_set }
 
-#print YoungDiagram.cells_inf /-
+/- warning: young_diagram.cells_inf -> YoungDiagram.cells_inf is a dubious translation:
+lean 3 declaration is
+  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (HasInf.inf.{0} YoungDiagram YoungDiagram.hasInf μ ν)) (Inter.inter.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.hasInter.{0} (Prod.{0, 0} Nat Nat) (fun (a : Prod.{0, 0} Nat Nat) (b : Prod.{0, 0} Nat Nat) => Prod.decidableEq.{0, 0} Nat Nat (fun (a : Nat) (b : Nat) => Nat.decidableEq a b) (fun (a : Nat) (b : Nat) => Nat.decidableEq a b) a b)) (YoungDiagram.cells μ) (YoungDiagram.cells ν))
+but is expected to have type
+  forall (μ : YoungDiagram) (ν : YoungDiagram), Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (HasInf.inf.{0} YoungDiagram YoungDiagram.instHasInfYoungDiagram μ ν)) (Inter.inter.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.instInterFinset.{0} (Prod.{0, 0} Nat Nat) (fun (a : Prod.{0, 0} Nat Nat) (b : Prod.{0, 0} Nat Nat) => instDecidableEqProd.{0, 0} Nat Nat (fun (a : Nat) (b : Nat) => instDecidableEqNat a b) (fun (a : Nat) (b : Nat) => instDecidableEqNat a b) a b)) (YoungDiagram.cells μ) (YoungDiagram.cells ν))
+Case conversion may be inaccurate. Consider using '#align young_diagram.cells_inf YoungDiagram.cells_infₓ'. -/
 @[simp]
 theorem cells_inf (μ ν : YoungDiagram) : (μ ⊓ ν).cells = μ.cells ∩ ν.cells :=
   rfl
 #align young_diagram.cells_inf YoungDiagram.cells_inf
--/
 
 #print YoungDiagram.coe_inf /-
 @[simp, norm_cast]
@@ -209,26 +213,38 @@ instance : OrderBot YoungDiagram
       IsLowerSet := fun _ _ _ => False.elim }
   bot_le _ _ := False.elim
 
-#print YoungDiagram.cells_bot /-
+/- warning: young_diagram.cells_bot -> YoungDiagram.cells_bot is a dubious translation:
+lean 3 declaration is
+  Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (Bot.bot.{0} YoungDiagram (OrderBot.toHasBot.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) YoungDiagram.orderBot))) (EmptyCollection.emptyCollection.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.hasEmptyc.{0} (Prod.{0, 0} Nat Nat)))
+but is expected to have type
+  Eq.{1} (Finset.{0} (Prod.{0, 0} Nat Nat)) (YoungDiagram.cells (Bot.bot.{0} YoungDiagram (OrderBot.toBot.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.instPartialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat))) YoungDiagram.instOrderBotYoungDiagramToLEToPreorderInstPartialOrderProdNatInstSetLikeYoungDiagramProdNat))) (EmptyCollection.emptyCollection.{0} (Finset.{0} (Prod.{0, 0} Nat Nat)) (Finset.instEmptyCollectionFinset.{0} (Prod.{0, 0} Nat Nat)))
+Case conversion may be inaccurate. Consider using '#align young_diagram.cells_bot YoungDiagram.cells_botₓ'. -/
 @[simp]
 theorem cells_bot : (⊥ : YoungDiagram).cells = ∅ :=
   rfl
 #align young_diagram.cells_bot YoungDiagram.cells_bot
--/
 
-#print YoungDiagram.coe_bot /-
+/- warning: young_diagram.coe_bot -> YoungDiagram.coe_bot is a dubious translation:
+lean 3 declaration is
+  Eq.{1} (Set.{0} (Prod.{0, 0} Nat Nat)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (HasLiftT.mk.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (CoeTCₓ.coe.{1, 1} YoungDiagram (Set.{0} (Prod.{0, 0} Nat Nat)) (SetLike.Set.hasCoeT.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (Bot.bot.{0} YoungDiagram (OrderBot.toHasBot.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) YoungDiagram.orderBot))) (EmptyCollection.emptyCollection.{0} (Set.{0} (Prod.{0, 0} Nat Nat)) (Set.hasEmptyc.{0} (Prod.{0, 0} Nat Nat)))
+but is expected to have type
+  Eq.{1} (Set.{0} (Prod.{0, 0} Nat Nat)) (Finset.toSet.{0} (Prod.{0, 0} Nat Nat) (YoungDiagram.cells (Bot.bot.{0} YoungDiagram (OrderBot.toBot.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.instPartialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat))) YoungDiagram.instOrderBotYoungDiagramToLEToPreorderInstPartialOrderProdNatInstSetLikeYoungDiagramProdNat)))) (EmptyCollection.emptyCollection.{0} (Set.{0} (Prod.{0, 0} Nat Nat)) (Set.instEmptyCollectionSet.{0} (Prod.{0, 0} Nat Nat)))
+Case conversion may be inaccurate. Consider using '#align young_diagram.coe_bot YoungDiagram.coe_botₓ'. -/
 @[simp, norm_cast]
 theorem coe_bot : ↑(⊥ : YoungDiagram) = (∅ : Set (ℕ × ℕ)) :=
   rfl
 #align young_diagram.coe_bot YoungDiagram.coe_bot
--/
 
-#print YoungDiagram.not_mem_bot /-
+/- warning: young_diagram.not_mem_bot -> YoungDiagram.not_mem_bot is a dubious translation:
+lean 3 declaration is
+  forall (x : Prod.{0, 0} Nat Nat), Not (Membership.Mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.hasMem.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike) x (Bot.bot.{0} YoungDiagram (OrderBot.toHasBot.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) YoungDiagram.orderBot)))
+but is expected to have type
+  forall (x : Prod.{0, 0} Nat Nat), Not (Membership.mem.{0, 0} (Prod.{0, 0} Nat Nat) YoungDiagram (SetLike.instMembership.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat) x (Bot.bot.{0} YoungDiagram (OrderBot.toBot.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.instPartialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.instSetLikeYoungDiagramProdNat))) YoungDiagram.instOrderBotYoungDiagramToLEToPreorderInstPartialOrderProdNatInstSetLikeYoungDiagramProdNat)))
+Case conversion may be inaccurate. Consider using '#align young_diagram.not_mem_bot YoungDiagram.not_mem_botₓ'. -/
 @[simp]
 theorem not_mem_bot (x : ℕ × ℕ) : x ∉ (⊥ : YoungDiagram) :=
   Finset.not_mem_empty x
 #align young_diagram.not_mem_bot YoungDiagram.not_mem_bot
--/
 
 instance : Inhabited YoungDiagram :=
   ⟨⊥⟩
@@ -296,7 +312,12 @@ theorem transpose_eq_iff {μ ν : YoungDiagram} : μ.transpose = ν.transpose 
 #align young_diagram.transpose_eq_iff YoungDiagram.transpose_eq_iff
 -/
 
-#print YoungDiagram.le_of_transpose_le /-
+/- warning: young_diagram.le_of_transpose_le -> YoungDiagram.le_of_transpose_le is a dubious translation:
+lean 3 declaration is
+  forall {μ : YoungDiagram} {ν : YoungDiagram}, (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (YoungDiagram.transpose μ) ν) -> (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ (YoungDiagram.transpose ν))
+but is expected to have type
+  forall {μ : YoungDiagram} {ν : YoungDiagram}, (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) (YoungDiagram.transpose μ) ν) -> (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) μ (YoungDiagram.transpose ν))
+Case conversion may be inaccurate. Consider using '#align young_diagram.le_of_transpose_le YoungDiagram.le_of_transpose_leₓ'. -/
 -- This is effectively both directions of `transpose_le_iff` below.
 protected theorem le_of_transpose_le {μ ν : YoungDiagram} (h_le : μ.transpose ≤ ν) :
     μ ≤ ν.transpose := fun c hc => by
@@ -304,9 +325,13 @@ protected theorem le_of_transpose_le {μ ν : YoungDiagram} (h_le : μ.transpose
   apply h_le
   simpa
 #align young_diagram.le_of_transpose_le YoungDiagram.le_of_transpose_le
--/
 
-#print YoungDiagram.transpose_le_iff /-
+/- warning: young_diagram.transpose_le_iff -> YoungDiagram.transpose_le_iff is a dubious translation:
+lean 3 declaration is
+  forall {μ : YoungDiagram} {ν : YoungDiagram}, Iff (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (YoungDiagram.transpose μ) (YoungDiagram.transpose ν)) (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ ν)
+but is expected to have type
+  forall {μ : YoungDiagram} {ν : YoungDiagram}, Iff (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) (YoungDiagram.transpose μ) (YoungDiagram.transpose ν)) (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) μ ν)
+Case conversion may be inaccurate. Consider using '#align young_diagram.transpose_le_iff YoungDiagram.transpose_le_iffₓ'. -/
 @[simp]
 theorem transpose_le_iff {μ ν : YoungDiagram} : μ.transpose ≤ ν.transpose ↔ μ ≤ ν :=
   ⟨fun h => by
@@ -315,22 +340,29 @@ theorem transpose_le_iff {μ ν : YoungDiagram} : μ.transpose ≤ ν.transpose
     convert @YoungDiagram.le_of_transpose_le _ _ _
     simpa⟩
 #align young_diagram.transpose_le_iff YoungDiagram.transpose_le_iff
--/
 
-#print YoungDiagram.transpose_mono /-
+/- warning: young_diagram.transpose_mono -> YoungDiagram.transpose_mono is a dubious translation:
+lean 3 declaration is
+  forall {μ : YoungDiagram} {ν : YoungDiagram}, (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) μ ν) -> (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (YoungDiagram.transpose μ) (YoungDiagram.transpose ν))
+but is expected to have type
+  forall {μ : YoungDiagram} {ν : YoungDiagram}, (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) μ ν) -> (LE.le.{0} YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) (YoungDiagram.transpose μ) (YoungDiagram.transpose ν))
+Case conversion may be inaccurate. Consider using '#align young_diagram.transpose_mono YoungDiagram.transpose_monoₓ'. -/
 @[mono]
 protected theorem transpose_mono {μ ν : YoungDiagram} (h_le : μ ≤ ν) : μ.transpose ≤ ν.transpose :=
   transpose_le_iff.mpr h_le
 #align young_diagram.transpose_mono YoungDiagram.transpose_mono
--/
 
-#print YoungDiagram.transposeOrderIso /-
+/- warning: young_diagram.transpose_order_iso -> YoungDiagram.transposeOrderIso is a dubious translation:
+lean 3 declaration is
+  OrderIso.{0, 0} YoungDiagram YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike))) (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SetLike.partialOrder.{0, 0} YoungDiagram (Prod.{0, 0} Nat Nat) YoungDiagram.Prod.setLike)))
+but is expected to have type
+  OrderIso.{0, 0} YoungDiagram YoungDiagram (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram))))) (Preorder.toLE.{0} YoungDiagram (PartialOrder.toPreorder.{0} YoungDiagram (SemilatticeInf.toPartialOrder.{0} YoungDiagram (Lattice.toSemilatticeInf.{0} YoungDiagram (DistribLattice.toLattice.{0} YoungDiagram YoungDiagram.instDistribLatticeYoungDiagram)))))
+Case conversion may be inaccurate. Consider using '#align young_diagram.transpose_order_iso YoungDiagram.transposeOrderIsoₓ'. -/
 /-- Transposing Young diagrams is an `order_iso`. -/
 @[simps]
 def transposeOrderIso : YoungDiagram ≃o YoungDiagram :=
   ⟨⟨transpose, transpose, fun _ => by simp, fun _ => by simp⟩, by simp⟩
 #align young_diagram.transpose_order_iso YoungDiagram.transposeOrderIso
--/
 
 end Transpose
 
@@ -534,12 +566,16 @@ def rowLens (μ : YoungDiagram) : List ℕ :=
 #align young_diagram.row_lens YoungDiagram.rowLens
 -/
 
-#print YoungDiagram.get_rowLens /-
+/- warning: young_diagram.nth_le_row_lens -> YoungDiagram.get_rowLens is a dubious translation:
+lean 3 declaration is
+  forall {μ : YoungDiagram} {i : Nat} {hi : LT.lt.{0} Nat Nat.hasLt i (List.length.{0} Nat (YoungDiagram.rowLens μ))}, Eq.{1} Nat (List.nthLe.{0} Nat (YoungDiagram.rowLens μ) i hi) (YoungDiagram.rowLen μ i)
+but is expected to have type
+  forall {μ : YoungDiagram} {i : Fin (List.length.{0} Nat (YoungDiagram.rowLens μ))}, Eq.{1} Nat (List.get.{0} Nat (YoungDiagram.rowLens μ) i) (YoungDiagram.rowLen μ (Fin.val (List.length.{0} Nat (YoungDiagram.rowLens μ)) i))
+Case conversion may be inaccurate. Consider using '#align young_diagram.nth_le_row_lens YoungDiagram.get_rowLensₓ'. -/
 @[simp]
 theorem get_rowLens {μ : YoungDiagram} {i : ℕ} {hi : i < μ.rowLens.length} :
     μ.rowLens.nthLe i hi = μ.rowLen i := by simp only [row_lens, List.nthLe_range, List.nthLe_map']
 #align young_diagram.nth_le_row_lens YoungDiagram.get_rowLens
--/
 
 #print YoungDiagram.length_rowLens /-
 @[simp]
@@ -642,13 +678,17 @@ theorem rowLens_length_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (hpo
 #align young_diagram.row_lens_length_of_row_lens YoungDiagram.rowLens_length_ofRowLens
 -/
 
-#print YoungDiagram.rowLen_ofRowLens /-
+/- warning: young_diagram.row_len_of_row_lens -> YoungDiagram.rowLen_ofRowLens is a dubious translation:
+lean 3 declaration is
+  forall {w : List.{0} Nat} {hw : List.Sorted.{0} Nat (GE.ge.{0} Nat Nat.hasLe) w} (i : Nat) (hi : LT.lt.{0} Nat Nat.hasLt i (List.length.{0} Nat w)), Eq.{1} Nat (YoungDiagram.rowLen (YoungDiagram.ofRowLens w hw) i) (List.nthLe.{0} Nat w i hi)
+but is expected to have type
+  forall {w : List.{0} Nat} {hw : List.Sorted.{0} Nat (fun (x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2895 : Nat) (x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2897 : Nat) => GE.ge.{0} Nat instLENat x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2895 x._@.Mathlib.Combinatorics.Young.YoungDiagram._hyg.2897) w} (i : Fin (List.length.{0} Nat w)), Eq.{1} Nat (YoungDiagram.rowLen (YoungDiagram.ofRowLens w hw) (Fin.val (List.length.{0} Nat w) i)) (List.get.{0} Nat w i)
+Case conversion may be inaccurate. Consider using '#align young_diagram.row_len_of_row_lens YoungDiagram.rowLen_ofRowLensₓ'. -/
 /-- The length of the `i`th row in `of_row_lens w hw` is the `i`th entry of `w` -/
 theorem rowLen_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (i : ℕ) (hi : i < w.length) :
     (ofRowLens w hw).rowLen i = w.nthLe i hi := by
   simp [row_len, Nat.find_eq_iff, mem_of_row_lens, hi]
 #align young_diagram.row_len_of_row_lens YoungDiagram.rowLen_ofRowLens
--/
 
 #print YoungDiagram.ofRowLens_to_rowLens_eq_self /-
 /-- The left_inv direction of the equivalence -/

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

A PR accompanying #12339.

Zulip discussion

@@ -174,10 +174,10 @@ theorem cells_bot : (⊥ : YoungDiagram).cells = ∅ :=
 @[norm_cast]
 theorem coe_bot : (⊥ : YoungDiagram).cells = (∅ : Set (ℕ × ℕ)) := by
   refine' Set.eq_of_subset_of_subset _ _
-  intros x h
-  simp? [mem_mk, Finset.coe_empty, Set.mem_empty_iff_false] at h says
-    simp only [cells_bot, Finset.coe_empty, Set.mem_empty_iff_false] at h
-  simp only [cells_bot, Finset.coe_empty, Set.empty_subset]
+  · intros x h
+    simp? [mem_mk, Finset.coe_empty, Set.mem_empty_iff_false] at h says
+      simp only [cells_bot, Finset.coe_empty, Set.mem_empty_iff_false] at h
+  · simp only [cells_bot, Finset.coe_empty, Set.empty_subset]
 #align young_diagram.coe_bot YoungDiagram.coe_bot
 
 @[simp]

@@ -413,7 +413,6 @@ def rowLens (μ : YoungDiagram) : List ℕ :=
   (List.range <| μ.colLen 0).map μ.rowLen
 #align young_diagram.row_lens YoungDiagram.rowLens
 
--- Porting note: use `List.get` instead of `List.nthLe` because it has been deprecated
 @[simp]
 theorem get_rowLens {μ : YoungDiagram} {i} :
     μ.rowLens.get i = μ.rowLen i := by simp only [rowLens, List.get_range, List.get_map]
@@ -459,7 +458,6 @@ protected def cellsOfRowLens : List ℕ → Finset (ℕ × ℕ)
         (Embedding.prodMap ⟨_, Nat.succ_injective⟩ (Embedding.refl ℕ))
 #align young_diagram.cells_of_row_lens YoungDiagram.cellsOfRowLens
 
--- Porting note: use `List.get` instead of `List.nthLe` because it has been deprecated
 protected theorem mem_cellsOfRowLens {w : List ℕ} {c : ℕ × ℕ} :
     c ∈ YoungDiagram.cellsOfRowLens w ↔ ∃ h : c.fst < w.length, c.snd < w.get ⟨c.fst, h⟩  := by
   induction' w with w_hd w_tl w_ih generalizing c <;> rw [YoungDiagram.cellsOfRowLens]
@@ -470,10 +468,8 @@ protected theorem mem_cellsOfRowLens {w : List ℕ} {c : ℕ × ℕ} :
     · simp [w_ih, -Finset.singleton_product, Nat.succ_lt_succ_iff]
 #align young_diagram.mem_cells_of_row_lens YoungDiagram.mem_cellsOfRowLens
 
--- Porting note: use `List.get` instead of `List.nthLe` because it has been deprecated
 /-- Young diagram from a sorted list -/
-def ofRowLens (w : List ℕ) (hw : w.Sorted (· ≥ ·)) : YoungDiagram
-    where
+def ofRowLens (w : List ℕ) (hw : w.Sorted (· ≥ ·)) : YoungDiagram where
   cells := YoungDiagram.cellsOfRowLens w
   isLowerSet := by
     rintro ⟨i2, j2⟩ ⟨i1, j1⟩ ⟨hi : i1 ≤ i2, hj : j1 ≤ j2⟩ hcell
@@ -489,7 +485,6 @@ def ofRowLens (w : List ℕ) (hw : w.Sorted (· ≥ ·)) : YoungDiagram
         · exact List.pairwise_iff_get.mp hw _ _ h
 #align young_diagram.of_row_lens YoungDiagram.ofRowLens
 
--- Porting note: use `List.get` instead of `List.nthLe` because it has been deprecated
 theorem mem_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} {c : ℕ × ℕ} :
     c ∈ ofRowLens w hw ↔ ∃ h : c.fst < w.length, c.snd < w.get ⟨c.fst, h⟩ :=
   YoungDiagram.mem_cellsOfRowLens
@@ -503,7 +498,6 @@ theorem rowLens_length_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (hpo
   exact ⟨not_false, fun n hn => ⟨hn, hpos _ (List.get_mem _ _ hn)⟩⟩
 #align young_diagram.row_lens_length_of_row_lens YoungDiagram.rowLens_length_ofRowLens
 
--- Porting note: use `List.get` instead of `List.nthLe` because it has been deprecated
 /-- The length of the `i`th row in `ofRowLens w hw` is the `i`th entry of `w` -/
 theorem rowLen_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (i : Fin w.length) :
     (ofRowLens w hw).rowLen i = w.get i := by
@@ -520,7 +514,6 @@ theorem ofRowLens_to_rowLens_eq_self {μ : YoungDiagram} : ofRowLens _ (rowLens_
 /-- The right_inv direction of the equivalence -/
 theorem rowLens_ofRowLens_eq_self {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (hpos : ∀ x ∈ w, 0 < x) :
     (ofRowLens w hw).rowLens = w :=
-  -- Porting note: golf by `List.get`
   List.ext_get (rowLens_length_ofRowLens hpos) fun i _ h₂ =>
     get_rowLens.trans <| rowLen_ofRowLens ⟨i, h₂⟩
 #align young_diagram.row_lens_of_row_lens_eq_self YoungDiagram.rowLens_ofRowLens_eq_self

Classifies by adding issue number #11215 to porting notes claiming "TODO".

@@ -70,7 +70,7 @@ namespace YoungDiagram
 
 instance : SetLike YoungDiagram (ℕ × ℕ)
     where
-  -- Porting note: TODO: figure out how to do this correctly
+  -- Porting note (#11215): TODO: figure out how to do this correctly
   coe := fun y => y.cells
   coe_injective' μ ν h := by rwa [YoungDiagram.ext_iff, ← Finset.coe_inj]
 

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

• converts "--porting note" into "-- Porting note";
• converts "porting note" into "Porting note".

@@ -70,7 +70,7 @@ namespace YoungDiagram
 
 instance : SetLike YoungDiagram (ℕ × ℕ)
     where
-  -- porting note: TODO: figure out how to do this correctly
+  -- Porting note: TODO: figure out how to do this correctly
   coe := fun y => y.cells
   coe_injective' μ ν h := by rwa [YoungDiagram.ext_iff, ← Finset.coe_inj]
 
@@ -169,7 +169,7 @@ theorem cells_bot : (⊥ : YoungDiagram).cells = ∅ :=
   rfl
 #align young_diagram.cells_bot YoungDiagram.cells_bot
 
--- porting note: removed `↑`, added `.cells` and changed proof
+-- Porting note: removed `↑`, added `.cells` and changed proof
 -- @[simp] -- Porting note (#10618): simp can prove this
 @[norm_cast]
 theorem coe_bot : (⊥ : YoungDiagram).cells = (∅ : Set (ℕ × ℕ)) := by

I replaced a few "terminal" refine/refine's with exact.

The strategy was very simple-minded: essentially any refine whose following line had smaller indentation got replaced by exact and then I cleaned up the mess.

This PR certainly leaves some further terminal refines, but maybe the current change is beneficial.

@@ -500,7 +500,7 @@ theorem rowLens_length_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (hpo
     (ofRowLens w hw).rowLens.length = w.length := by
   simp only [length_rowLens, colLen, Nat.find_eq_iff, mem_cells, mem_ofRowLens,
     lt_self_iff_false, IsEmpty.exists_iff, Classical.not_not]
-  refine' ⟨not_false, fun n hn => ⟨hn, hpos _ (List.get_mem _ _ hn)⟩⟩
+  exact ⟨not_false, fun n hn => ⟨hn, hpos _ (List.get_mem _ _ hn)⟩⟩
 #align young_diagram.row_lens_length_of_row_lens YoungDiagram.rowLens_length_ofRowLens
 
 -- Porting note: use `List.get` instead of `List.nthLe` because it has been deprecated

Classify by adding issue number (#10618) to porting notes claiming anything semantically equivalent to simp can prove this or simp can simplify this.

@@ -170,7 +170,7 @@ theorem cells_bot : (⊥ : YoungDiagram).cells = ∅ :=
 #align young_diagram.cells_bot YoungDiagram.cells_bot
 
 -- porting note: removed `↑`, added `.cells` and changed proof
--- @[simp] -- Porting note: simp can prove this
+-- @[simp] -- Porting note (#10618): simp can prove this
 @[norm_cast]
 theorem coe_bot : (⊥ : YoungDiagram).cells = (∅ : Set (ℕ × ℕ)) := by
   refine' Set.eq_of_subset_of_subset _ _

Removes nonterminal uses of simp at. Replaces most of these with instances of simp? ... says.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com>

@@ -175,7 +175,8 @@ theorem cells_bot : (⊥ : YoungDiagram).cells = ∅ :=
 theorem coe_bot : (⊥ : YoungDiagram).cells = (∅ : Set (ℕ × ℕ)) := by
   refine' Set.eq_of_subset_of_subset _ _
   intros x h
-  simp [mem_mk, Finset.coe_empty, Set.mem_empty_iff_false] at h
+  simp? [mem_mk, Finset.coe_empty, Set.mem_empty_iff_false] at h says
+    simp only [cells_bot, Finset.coe_empty, Set.mem_empty_iff_false] at h
   simp only [cells_bot, Finset.coe_empty, Set.empty_subset]
 #align young_diagram.coe_bot YoungDiagram.coe_bot
 

To fit with the "please try harder" convention of ! tactics.

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

@@ -325,7 +325,7 @@ theorem rowLen_eq_card (μ : YoungDiagram) {i : ℕ} : μ.rowLen i = (μ.row i).
 
 @[mono]
 theorem rowLen_anti (μ : YoungDiagram) (i1 i2 : ℕ) (hi : i1 ≤ i2) : μ.rowLen i2 ≤ μ.rowLen i1 := by
-  by_contra' h_lt
+  by_contra! h_lt
   rw [← lt_self_iff_false (μ.rowLen i1)]
   rw [← mem_iff_lt_rowLen] at h_lt ⊢
   exact μ.up_left_mem hi (by rfl) h_lt

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

@@ -247,7 +247,7 @@ theorem transpose_le_iff {μ ν : YoungDiagram} : μ.transpose ≤ ν.transpose
   ⟨fun h => by
     convert YoungDiagram.le_of_transpose_le h
     simp, fun h => by
-    rw [←transpose_transpose μ] at h
+    rw [← transpose_transpose μ] at h
     exact YoungDiagram.le_of_transpose_le h ⟩
 #align young_diagram.transpose_le_iff YoungDiagram.transpose_le_iff
 

PR contents

This is the supremum of

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

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

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

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

Lean PRs involved in this bump

In particular this includes adjustments for the Lean PRs

• leanprover/lean4#2778
• leanprover/lean4#2790
• leanprover/lean4#2783
• leanprover/lean4#2825
• leanprover/lean4#2722

leanprover/lean4#2778

We can get rid of all the

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

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

leanprover/lean4#2722

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

leanprover/lean4#2783

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

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

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

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

@@ -499,7 +499,7 @@ theorem rowLens_length_ofRowLens {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (hpo
     (ofRowLens w hw).rowLens.length = w.length := by
   simp only [length_rowLens, colLen, Nat.find_eq_iff, mem_cells, mem_ofRowLens,
     lt_self_iff_false, IsEmpty.exists_iff, Classical.not_not]
-  refine' ⟨True.intro, fun n hn => ⟨hn, hpos _ (List.get_mem _ _ hn)⟩⟩
+  refine' ⟨not_false, fun n hn => ⟨hn, hpos _ (List.get_mem _ _ hn)⟩⟩
 #align young_diagram.row_lens_length_of_row_lens YoungDiagram.rowLens_length_ofRowLens
 
 -- Porting note: use `List.get` instead of `List.nthLe` because it has been deprecated

@@ -108,8 +108,8 @@ theorem cells_ssubset_iff {μ ν : YoungDiagram} : μ.cells ⊂ ν.cells ↔ μ
   Iff.rfl
 #align young_diagram.cells_ssubset_iff YoungDiagram.cells_ssubset_iff
 
-instance : Sup YoungDiagram
-    where sup μ ν :=
+instance : Sup YoungDiagram where
+  sup μ ν :=
     { cells := μ.cells ∪ ν.cells
       isLowerSet := by
         rw [Finset.coe_union]
@@ -130,8 +130,8 @@ theorem mem_sup {μ ν : YoungDiagram} {x : ℕ × ℕ} : x ∈ μ ⊔ ν ↔ x
   Finset.mem_union
 #align young_diagram.mem_sup YoungDiagram.mem_sup
 
-instance : Inf YoungDiagram
-    where inf μ ν :=
+instance : Inf YoungDiagram where
+  inf μ ν :=
     { cells := μ.cells ∩ ν.cells
       isLowerSet := by
         rw [Finset.coe_inter]

• depends on: #5966

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

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Jake Levinson. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jake Levinson
-
-! This file was ported from Lean 3 source module combinatorics.young.young_diagram
-! leanprover-community/mathlib commit 59694bd07f0a39c5beccba34bd9f413a160782bf
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.UpperLower.Basic
 import Mathlib.Data.Finset.Preimage
 
+#align_import combinatorics.young.young_diagram from "leanprover-community/mathlib"@"59694bd07f0a39c5beccba34bd9f413a160782bf"
+
 /-!
 # Young diagrams
 

Changes are of the form

• some_tactic at h⊢ -> some_tactic at h ⊢
• some_tactic at h -> some_tactic at h

@@ -330,7 +330,7 @@ theorem rowLen_eq_card (μ : YoungDiagram) {i : ℕ} : μ.rowLen i = (μ.row i).
 theorem rowLen_anti (μ : YoungDiagram) (i1 i2 : ℕ) (hi : i1 ≤ i2) : μ.rowLen i2 ≤ μ.rowLen i1 := by
   by_contra' h_lt
   rw [← lt_self_iff_false (μ.rowLen i1)]
-  rw [← mem_iff_lt_rowLen] at h_lt⊢
+  rw [← mem_iff_lt_rowLen] at h_lt ⊢
   exact μ.up_left_mem hi (by rfl) h_lt
 #align young_diagram.row_len_anti YoungDiagram.rowLen_anti
 
@@ -479,7 +479,7 @@ def ofRowLens (w : List ℕ) (hw : w.Sorted (· ≥ ·)) : YoungDiagram
   cells := YoungDiagram.cellsOfRowLens w
   isLowerSet := by
     rintro ⟨i2, j2⟩ ⟨i1, j1⟩ ⟨hi : i1 ≤ i2, hj : j1 ≤ j2⟩ hcell
-    rw [Finset.mem_coe, YoungDiagram.mem_cellsOfRowLens] at hcell⊢
+    rw [Finset.mem_coe, YoungDiagram.mem_cellsOfRowLens] at hcell ⊢
     obtain ⟨h1, h2⟩ := hcell
     refine' ⟨hi.trans_lt h1, _⟩
     calc

I ran codespell Mathlib and got tired halfway through the suggestions.

@@ -73,7 +73,7 @@ namespace YoungDiagram
 
 instance : SetLike YoungDiagram (ℕ × ℕ)
     where
-  -- porting note: TODO: figure out how to do this correcly
+  -- porting note: TODO: figure out how to do this correctly
   coe := fun y => y.cells
   coe_injective' μ ν h := by rwa [YoungDiagram.ext_iff, ← Finset.coe_inj]
 

Currently, the following notations are changed from · ×ˢ · because Lean 4 can't deal with ambiguous notations. | Definition | Notation | | :

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: Chris Hughes <chrishughes24@gmail.com>

@@ -273,7 +273,7 @@ section Rows
 
 This section defines `μ.row` and `μ.rowLen`, with the following API:
       1.  `(i, j) ∈ μ ↔ j < μ.rowLen i`
-      2.  `μ.row i = {i} ×ᶠ (Finset.range (μ.rowLen i))`
+      2.  `μ.row i = {i} ×ˢ (Finset.range (μ.rowLen i))`
       3.  `μ.rowLen i = (μ.row i).card`
       4.  `∀ {i1 i2}, i1 ≤ i2 → μ.rowLen i2 ≤ μ.rowLen i1`
 
@@ -314,7 +314,7 @@ theorem mem_iff_lt_rowLen {μ : YoungDiagram} {i j : ℕ} : (i, j) ∈ μ ↔ j
   exact ⟨fun h _ hmj => μ.up_left_mem (by rfl) hmj h, fun h => h _ (by rfl)⟩
 #align young_diagram.mem_iff_lt_row_len YoungDiagram.mem_iff_lt_rowLen
 
-theorem row_eq_prod {μ : YoungDiagram} {i : ℕ} : μ.row i = {i} ×ᶠ Finset.range (μ.rowLen i) := by
+theorem row_eq_prod {μ : YoungDiagram} {i : ℕ} : μ.row i = {i} ×ˢ Finset.range (μ.rowLen i) := by
   ext ⟨a, b⟩
   simp only [Finset.mem_product, Finset.mem_singleton, Finset.mem_range, mem_row_iff,
     mem_iff_lt_rowLen, and_comm, and_congr_right_iff]
@@ -380,7 +380,7 @@ theorem mem_iff_lt_colLen {μ : YoungDiagram} {i j : ℕ} : (i, j) ∈ μ ↔ i
   simp
 #align young_diagram.mem_iff_lt_col_len YoungDiagram.mem_iff_lt_colLen
 
-theorem col_eq_prod {μ : YoungDiagram} {j : ℕ} : μ.col j = Finset.range (μ.colLen j) ×ᶠ {j} := by
+theorem col_eq_prod {μ : YoungDiagram} {j : ℕ} : μ.col j = Finset.range (μ.colLen j) ×ˢ {j} := by
   ext ⟨a, b⟩
   simp only [Finset.mem_product, Finset.mem_singleton, Finset.mem_range, mem_col_iff,
     mem_iff_lt_colLen, and_comm, and_congr_right_iff]
@@ -456,7 +456,7 @@ The two directions are `YoungDiagram.rowLens` (defined above) and `YoungDiagram.
 protected def cellsOfRowLens : List ℕ → Finset (ℕ × ℕ)
   | [] => ∅
   | w::ws =>
-    ({0} : Finset ℕ) ×ᶠ Finset.range w ∪
+    ({0} : Finset ℕ) ×ˢ Finset.range w ∪
       (YoungDiagram.cellsOfRowLens ws).map
         (Embedding.prodMap ⟨_, Nat.succ_injective⟩ (Embedding.refl ℕ))
 #align young_diagram.cells_of_row_lens YoungDiagram.cellsOfRowLens

• Run a non-interactive version of fix-comments.py on all files.
• Go through the diff and manually add/discard/edit chunks.

@@ -273,7 +273,7 @@ section Rows
 
 This section defines `μ.row` and `μ.rowLen`, with the following API:
       1.  `(i, j) ∈ μ ↔ j < μ.rowLen i`
-      2.  `μ.row i = {i} ×ᶠ (finset.range (μ.rowLen i))`
+      2.  `μ.row i = {i} ×ᶠ (Finset.range (μ.rowLen i))`
       3.  `μ.rowLen i = (μ.row i).card`
       4.  `∀ {i1 i2}, i1 ≤ i2 → μ.rowLen i2 ≤ μ.rowLen i1`
 
@@ -403,7 +403,7 @@ section RowLens
 
 /-! ### The list of row lengths of a Young diagram
 
-This section defines `μ.rowLens : list ℕ`, the list of row lengths of a Young diagram `μ`.
+This section defines `μ.rowLens : List ℕ`, the list of row lengths of a Young diagram `μ`.
   1. `YoungDiagram.rowLens_sorted` : It is weakly decreasing (`List.Sorted (· ≥ ·)`).
   2. `YoungDiagram.rowLens_pos` : It is strictly positive.
 

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

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

@@ -485,8 +485,7 @@ def ofRowLens (w : List ℕ) (hw : w.Sorted (· ≥ ·)) : YoungDiagram
     calc
       j1 ≤ j2 := hj
       _ < w.get ⟨i2, _⟩  := h2
-      _ ≤ w.get ⟨i1, _⟩ :=
-      by
+      _ ≤ w.get ⟨i1, _⟩ := by
         obtain rfl | h := eq_or_lt_of_le hi
         · convert le_refl (w.get ⟨i1, h1⟩)
         · exact List.pairwise_iff_get.mp hw _ _ h

Notably incorporates https://github.com/leanprover/std4/pull/98 and https://github.com/leanprover/std4/pull/109.

https://github.com/leanprover/std4/pull/98 moves a number of lemmas from Mathlib to Std, so the bump requires deleting them in Mathlib. I did check on each lemma whether its attributes were kept in the move (and gave attribute markings in Mathlib if they were not present in Std), but a reviewer may wish to re-check.

List.mem_map changed statement from b ∈ l.map f ↔ ∃ a, a ∈ l ∧ b = f a to b ∈ l.map f ↔ ∃ a, a ∈ l ∧ f a = b. Similarly for List.exists_of_mem_map. This was a deliberate change, so I have simply adjusted proofs (many become simpler, which supports the change). I also deleted List.mem_map', List.exists_of_mem_map', which were temporary versions in Mathlib while waiting for this change (replacing their uses with the unprimed versions).

Also, the lemma sublist_nil_iff_eq_nil seems to have been renamed to sublist_nil during the move, so I added an alias for the old name.

(another issue fixed during review by @digama0) List.Sublist.filter had an argument change from explicit to implicit. This appears to have been an oversight (cc @JamesGallicchio). I have temporarily introduced List.Sublist.filter' with the argument explicit, and replaced Mathlib uses of Sublist.filter with Sublist.filter'. Later we can fix the argument in Std, and then delete List.Sublist.filter'.

@@ -431,7 +431,7 @@ theorem rowLens_sorted (μ : YoungDiagram) : μ.rowLens.Sorted (· ≥ ·) :=
 #align young_diagram.row_lens_sorted YoungDiagram.rowLens_sorted
 
 theorem pos_of_mem_rowLens (μ : YoungDiagram) (x : ℕ) (hx : x ∈ μ.rowLens) : 0 < x := by
-  rw [rowLens, List.mem_map'] at hx
+  rw [rowLens, List.mem_map] at hx
   obtain ⟨i, hi, rfl : μ.rowLen i = x⟩ := hx
   rwa [List.mem_range, ← mem_iff_lt_colLen, mem_iff_lt_rowLen] at hi
 #align young_diagram.pos_of_mem_row_lens YoungDiagram.pos_of_mem_rowLens

• There is now configuration for congr!, convert, and convert_to to control parts of the congruence algorithm, in particular transparency settings when applying congruence lemmas.
• congr! now applies congruence lemmas with reducible transparency by default. This prevents it from unfolding definitions when applying congruence lemmas. It also now tries both the LHS-biased and RHS-biased simp congruence lemmas, with a configuration option to set which it should try first.
• There is now a new HEq congruence lemma generator that gives each hypothesis access to the proofs of previous hypotheses. This means that if you have an equality ⊢ ⟨a, x⟩ = ⟨b, y⟩ of sigma types, congr! turns this into goals ⊢ a = b and ⊢ a = b → HEq x y (note that congr! will also auto-introduce a = b for you in the second goal). This congruence lemma generator applies to more cases than the simp congruence lemma generator does.
• congr! (and hence convert) are more careful about applying lemmas that don't force definitions to unfold. There were a number of cases in mathlib where the implementation of congr was being abused to unfold definitions.
• With set_option trace.congr! true you can see what congr! sees when it is deciding on congruence lemmas.
• There is also a bug fix in convert_to to do using 1 when there is no using clause, to match its documentation.

Note that congr! is more capable than congr at finding a way to equate left-hand sides and right-hand sides, so you will frequently need to limit its depth with a using clause. However, there is also a new heuristic to prevent considering unlikely-to-be-provable type equalities (controlled by the typeEqs option), which can help limit the depth automatically.

There is also a predefined configuration that you can invoke with, for example, convert (config := .unfoldSameFun) h, that causes it to behave more like congr, including using default transparency when unfolding.

@@ -394,7 +394,7 @@ theorem colLen_eq_card (μ : YoungDiagram) {j : ℕ} : μ.colLen j = (μ.col j).
 
 @[mono]
 theorem colLen_anti (μ : YoungDiagram) (j1 j2 : ℕ) (hj : j1 ≤ j2) : μ.colLen j2 ≤ μ.colLen j1 := by
-  convert μ.transpose.rowLen_anti j1 j2 hj <;> simp
+  convert μ.transpose.rowLen_anti j1 j2 hj using 1 <;> simp
 #align young_diagram.col_len_anti YoungDiagram.colLen_anti
 
 end Columns

This introduces a tactic congr! that is an analogue to mathlib 3's congr'. It is a more insistent version of congr that makes use of more congruence lemmas (including user congruence lemmas), propext, funext, and Subsingleton instances. It also has a feature to lift reflexive relations to equalities. Along with funext, the tactic does intros, allowing congr! to get access to function bodies; the introduced variables can be named using rename_i if needed.

This also modifies convert to use congr! rather than congr, which makes it work more like the mathlib3 version of the tactic.

@@ -356,7 +356,7 @@ theorem mk_mem_col_iff {μ : YoungDiagram} {i j : ℕ} : (i, j) ∈ μ.col j ↔
 #align young_diagram.mk_mem_col_iff YoungDiagram.mk_mem_col_iff
 
 protected theorem exists_not_mem_col (μ : YoungDiagram) (j : ℕ) : ∃ i, (i, j) ∉ μ.cells := by
-  convert μ.transpose.exists_not_mem_row j
+  convert μ.transpose.exists_not_mem_row j using 1
   simp
 #align young_diagram.exists_not_mem_col YoungDiagram.exists_not_mem_col
 

Restore most of the mono attribute now that #1740 is merged.

I think I got all of the monos.

@@ -254,7 +254,7 @@ theorem transpose_le_iff {μ ν : YoungDiagram} : μ.transpose ≤ ν.transpose
     exact YoungDiagram.le_of_transpose_le h ⟩
 #align young_diagram.transpose_le_iff YoungDiagram.transpose_le_iff
 
---@[mono] Porting note: not implemented yet
+@[mono]
 protected theorem transpose_mono {μ ν : YoungDiagram} (h_le : μ ≤ ν) : μ.transpose ≤ ν.transpose :=
   transpose_le_iff.mpr h_le
 #align young_diagram.transpose_mono YoungDiagram.transpose_mono
@@ -326,7 +326,7 @@ theorem rowLen_eq_card (μ : YoungDiagram) {i : ℕ} : μ.rowLen i = (μ.row i).
   simp [row_eq_prod]
 #align young_diagram.row_len_eq_card YoungDiagram.rowLen_eq_card
 
---@[mono] Porting note: not implemented yet
+@[mono]
 theorem rowLen_anti (μ : YoungDiagram) (i1 i2 : ℕ) (hi : i1 ≤ i2) : μ.rowLen i2 ≤ μ.rowLen i1 := by
   by_contra' h_lt
   rw [← lt_self_iff_false (μ.rowLen i1)]
@@ -392,7 +392,7 @@ theorem colLen_eq_card (μ : YoungDiagram) {j : ℕ} : μ.colLen j = (μ.col j).
   simp [col_eq_prod]
 #align young_diagram.col_len_eq_card YoungDiagram.colLen_eq_card
 
---@[mono] Porting note: not implemented yet
+@[mono]
 theorem colLen_anti (μ : YoungDiagram) (j1 j2 : ℕ) (hj : j1 ≤ j2) : μ.colLen j2 ≤ μ.colLen j1 := by
   convert μ.transpose.rowLen_anti j1 j2 hj <;> simp
 #align young_diagram.col_len_anti YoungDiagram.colLen_anti

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

@@ -111,7 +111,7 @@ theorem cells_ssubset_iff {μ ν : YoungDiagram} : μ.cells ⊂ ν.cells ↔ μ
   Iff.rfl
 #align young_diagram.cells_ssubset_iff YoungDiagram.cells_ssubset_iff
 
-instance : HasSup YoungDiagram
+instance : Sup YoungDiagram
     where sup μ ν :=
     { cells := μ.cells ∪ ν.cells
       isLowerSet := by
@@ -133,7 +133,7 @@ theorem mem_sup {μ ν : YoungDiagram} {x : ℕ × ℕ} : x ∈ μ ⊔ ν ↔ x
   Finset.mem_union
 #align young_diagram.mem_sup YoungDiagram.mem_sup
 
-instance : HasInf YoungDiagram
+instance : Inf YoungDiagram
     where inf μ ν :=
     { cells := μ.cells ∩ ν.cells
       isLowerSet := by

@@ -107,9 +107,9 @@ theorem cells_subset_iff {μ ν : YoungDiagram} : μ.cells ⊆ ν.cells ↔ μ 
 #align young_diagram.cells_subset_iff YoungDiagram.cells_subset_iff
 
 @[simp]
-theorem cells_sSubset_iff {μ ν : YoungDiagram} : μ.cells ⊂ ν.cells ↔ μ < ν :=
+theorem cells_ssubset_iff {μ ν : YoungDiagram} : μ.cells ⊂ ν.cells ↔ μ < ν :=
   Iff.rfl
-#align young_diagram.cells_ssubset_iff YoungDiagram.cells_sSubset_iff
+#align young_diagram.cells_ssubset_iff YoungDiagram.cells_ssubset_iff
 
 instance : HasSup YoungDiagram
     where sup μ ν :=

@@ -488,8 +488,8 @@ def ofRowLens (w : List ℕ) (hw : w.Sorted (· ≥ ·)) : YoungDiagram
       _ ≤ w.get ⟨i1, _⟩ :=
       by
         obtain rfl | h := eq_or_lt_of_le hi
-        · rfl
-        · apply List.pairwise_iff_get.mp hw _ _ h
+        · convert le_refl (w.get ⟨i1, h1⟩)
+        · exact List.pairwise_iff_get.mp hw _ _ h
 #align young_diagram.of_row_lens YoungDiagram.ofRowLens
 
 -- Porting note: use `List.get` instead of `List.nthLe` because it has been deprecated

Drop

• by delta mydef; infer_instance. This generates id _ in the proof.

• show _, by infer_instance. This generates let in let; not sure if it's bad for defeq but a reducible inferInstanceAs should not be worse.

@@ -89,7 +89,7 @@ theorem mem_mk (c : ℕ × ℕ) (cells) (isLowerSet) :
 #align young_diagram.mem_mk YoungDiagram.mem_mk
 
 instance decidableMem (μ : YoungDiagram) : DecidablePred (· ∈ μ) :=
-  show DecidablePred (· ∈ μ.cells) by infer_instance
+  inferInstanceAs (DecidablePred (· ∈ μ.cells))
 #align young_diagram.decidable_mem YoungDiagram.decidableMem
 
 /-- In "English notation", a Young diagram is drawn so that (i1, j1) ≤ (i2, j2)

Co-authored-by: Moritz Firsching <firsching@google.com> Co-authored-by: Komyyy <pol_tta@outlook.jp> Co-authored-by: Pol_tta <52843868+Komyyy@users.noreply.github.com>