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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
 -/
 import Algebra.Group.InjSurj
-import Data.List.BigOperators.Basic
+import Algebra.BigOperators.List.Basic
 import Data.List.FinRange
 import GroupTheory.GroupAction.Defs
 import GroupTheory.Submonoid.Basic
@@ -167,7 +167,7 @@ variable {A} [AddMonoid ι] [GMul A] [GOne A]
 `gmonoid.gnpow` should be used instead. -/
 def gnpowRec : ∀ (n : ℕ) {i}, A i → A (n • i)
   | 0, i, a => cast (congr_arg A (zero_nsmul i).symm) GOne.one
-  | n + 1, i, a => cast (congr_arg A (succ_nsmul i n).symm) (GMul.mul a <| gnpow_rec _ a)
+  | n + 1, i, a => cast (congr_arg A (succ_nsmul' i n).symm) (GMul.mul a <| gnpow_rec _ a)
 #align graded_monoid.gmonoid.gnpow_rec GradedMonoid.GMonoid.gnpowRec
 -/
 
@@ -189,7 +189,7 @@ unsafe def apply_gnpow_rec_zero_tac : tactic Unit :=
 @[simp]
 theorem gnpowRec_succ (n : ℕ) (a : GradedMonoid A) :
     (GradedMonoid.mk _ <| gnpowRec n.succ a.snd) = a * ⟨_, gnpowRec n a.snd⟩ :=
-  Sigma.ext (succ_nsmul _ _) (heq_of_cast_eq _ rfl).symm
+  Sigma.ext (succ_nsmul' _ _) (heq_of_cast_eq _ rfl).symm
 #align graded_monoid.gmonoid.gnpow_rec_succ GradedMonoid.GMonoid.gnpowRec_succ
 -/
 
@@ -247,7 +247,7 @@ theorem mk_pow [AddMonoid ι] [GMonoid A] {i} (a : A i) (n : ℕ) :
   induction' n with n
   · rw [pow_zero]
     exact (gmonoid.gnpow_zero' ⟨_, a⟩).symm
-  · rw [pow_succ, n_ih, mk_mul_mk]
+  · rw [pow_succ', n_ih, mk_mul_mk]
     exact (gmonoid.gnpow_succ' n ⟨_, a⟩).symm
 #align graded_monoid.mk_pow GradedMonoid.mk_pow
 -/
@@ -531,7 +531,7 @@ instance Monoid.gMonoid [AddMonoid ι] [Monoid R] : GradedMonoid.GMonoid fun i :
     mul_assoc := fun a b c => Sigma.ext (add_assoc _ _ _) (hEq_of_eq (mul_assoc _ _ _))
     gnpow := fun n i a => a ^ n
     gnpow_zero' := fun a => Sigma.ext (zero_nsmul _) (hEq_of_eq (Monoid.npow_zero _))
-    gnpow_succ' := fun n ⟨i, a⟩ => Sigma.ext (succ_nsmul _ _) (hEq_of_eq (Monoid.npow_succ _ _)) }
+    gnpow_succ' := fun n ⟨i, a⟩ => Sigma.ext (succ_nsmul' _ _) (hEq_of_eq (Monoid.npow_succ _ _)) }
 #align monoid.gmonoid Monoid.gMonoid
 -/
 
@@ -643,7 +643,7 @@ theorem pow_mem_graded (n : ℕ) {r : R} {i : ι} (h : r ∈ A i) : r ^ n ∈ A
   by
   induction n
   · rw [pow_zero, zero_nsmul]; exact one_mem_graded _
-  · rw [pow_succ', succ_nsmul']; exact mul_mem_graded n_ih h
+  · rw [pow_succ, succ_nsmul]; exact mul_mem_graded n_ih h
 #align set_like.pow_mem_graded SetLike.pow_mem_graded
 -/
 
@@ -685,7 +685,7 @@ instance SetLike.gMonoid {S : Type _} [SetLike S R] [Monoid R] [AddMonoid ι] (A
       Sigma.subtype_ext (add_assoc _ _ _) (mul_assoc _ _ _)
     gnpow := fun n i a => ⟨a ^ n, SetLike.pow_mem_graded n a.Prop⟩
     gnpow_zero' := fun n => Sigma.subtype_ext (zero_nsmul _) (pow_zero _)
-    gnpow_succ' := fun n a => Sigma.subtype_ext (succ_nsmul _ _) (pow_succ _ _) }
+    gnpow_succ' := fun n a => Sigma.subtype_ext (succ_nsmul' _ _) (pow_succ' _ _) }
 #align set_like.gmonoid SetLike.gMonoid
 -/
 

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

@@ -3,13 +3,13 @@ Copyright (c) 2021 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
 -/
-import Mathbin.Algebra.Group.InjSurj
-import Mathbin.Data.List.BigOperators.Basic
-import Mathbin.Data.List.FinRange
-import Mathbin.GroupTheory.GroupAction.Defs
-import Mathbin.GroupTheory.Submonoid.Basic
-import Mathbin.Data.SetLike.Basic
-import Mathbin.Data.Sigma.Basic
+import Algebra.Group.InjSurj
+import Data.List.BigOperators.Basic
+import Data.List.FinRange
+import GroupTheory.GroupAction.Defs
+import GroupTheory.Submonoid.Basic
+import Data.SetLike.Basic
+import Data.Sigma.Basic
 
 #align_import algebra.graded_monoid from "leanprover-community/mathlib"@"fac369018417f980cec5fcdafc766a69f88d8cfe"
 
@@ -178,7 +178,7 @@ theorem gnpowRec_zero (a : GradedMonoid A) : GradedMonoid.mk _ (gnpowRec 0 a.snd
 #align graded_monoid.gmonoid.gnpow_rec_zero GradedMonoid.GMonoid.gnpowRec_zero
 -/
 
-/- ./././Mathport/Syntax/Translate/Expr.lean:336:4: warning: unsupported (TODO): `[tacs] -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:337:4: warning: unsupported (TODO): `[tacs] -/
 /-- Tactic used to autofill `graded_monoid.gmonoid.gnpow_zero'` when the default
 `graded_monoid.gmonoid.gnpow_rec` is used. -/
 unsafe def apply_gnpow_rec_zero_tac : tactic Unit :=
@@ -193,7 +193,7 @@ theorem gnpowRec_succ (n : ℕ) (a : GradedMonoid A) :
 #align graded_monoid.gmonoid.gnpow_rec_succ GradedMonoid.GMonoid.gnpowRec_succ
 -/
 
-/- ./././Mathport/Syntax/Translate/Expr.lean:336:4: warning: unsupported (TODO): `[tacs] -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:337:4: warning: unsupported (TODO): `[tacs] -/
 /-- Tactic used to autofill `graded_monoid.gmonoid.gnpow_succ'` when the default
 `graded_monoid.gmonoid.gnpow_rec` is used. -/
 unsafe def apply_gnpow_rec_succ_tac : tactic Unit :=

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

@@ -234,9 +234,9 @@ instance GMonoid.toMonoid [AddMonoid ι] [GMonoid A] : Monoid (GradedMonoid A)
   npow n a := GradedMonoid.mk _ (GMonoid.gnpow n a.snd)
   npow_zero a := GMonoid.gnpow_zero' a
   npow_succ n a := GMonoid.gnpow_succ' n a
-  one_mul := GMonoid.one_mul
-  mul_one := GMonoid.mul_one
-  mul_assoc := GMonoid.mul_assoc
+  one_mul := GMonoid.one_hMul
+  mul_one := GMonoid.hMul_one
+  mul_assoc := GMonoid.hMul_assoc
 #align graded_monoid.gmonoid.to_monoid GradedMonoid.GMonoid.toMonoid
 -/
 
@@ -263,7 +263,7 @@ class GCommMonoid [AddCommMonoid ι] extends GMonoid A where
 /-- `gcomm_monoid` implies a `comm_monoid (graded_monoid A)`, although this is only used as an
 instance locally to define notation in `gmonoid` and similar typeclasses. -/
 instance GCommMonoid.toCommMonoid [AddCommMonoid ι] [GCommMonoid A] : CommMonoid (GradedMonoid A) :=
-  { GMonoid.toMonoid A with mul_comm := GCommMonoid.mul_comm }
+  { GMonoid.toMonoid A with mul_comm := GCommMonoid.hMul_comm }
 #align graded_monoid.gcomm_monoid.to_comm_monoid GradedMonoid.GCommMonoid.toCommMonoid
 -/
 
@@ -598,14 +598,14 @@ theorem SetLike.coe_gOne {S : Type _} [SetLike S R] [One R] [Zero ι] (A : ι 
 #print SetLike.GradedMul /-
 /-- A version of `graded_monoid.ghas_one` for internally graded objects. -/
 class SetLike.GradedMul {S : Type _} [SetLike S R] [Mul R] [Add ι] (A : ι → S) : Prop where
-  mul_mem : ∀ ⦃i j⦄ {gi gj}, gi ∈ A i → gj ∈ A j → gi * gj ∈ A (i + j)
+  hMul_mem : ∀ ⦃i j⦄ {gi gj}, gi ∈ A i → gj ∈ A j → gi * gj ∈ A (i + j)
 #align set_like.has_graded_mul SetLike.GradedMul
 -/
 
 #print SetLike.mul_mem_graded /-
 theorem SetLike.mul_mem_graded {S : Type _} [SetLike S R] [Mul R] [Add ι] {A : ι → S}
     [SetLike.GradedMul A] ⦃i j⦄ {gi gj} (hi : gi ∈ A i) (hj : gj ∈ A j) : gi * gj ∈ A (i + j) :=
-  SetLike.GradedMul.mul_mem hi hj
+  SetLike.GradedMul.hMul_mem hi hj
 #align set_like.mul_mem_graded SetLike.mul_mem_graded
 -/
 
@@ -781,7 +781,7 @@ def SetLike.homogeneousSubmonoid [AddMonoid ι] [Monoid R] (A : ι → S) [SetLi
     Submonoid R where
   carrier := {a | SetLike.Homogeneous A a}
   one_mem' := SetLike.homogeneous_one A
-  mul_mem' a b := SetLike.homogeneous_mul
+  hMul_mem' a b := SetLike.homogeneous_mul
 #align set_like.homogeneous_submonoid SetLike.homogeneousSubmonoid
 -/
 

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

@@ -2,11 +2,6 @@
 Copyright (c) 2021 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
-
-! This file was ported from Lean 3 source module algebra.graded_monoid
-! leanprover-community/mathlib commit fac369018417f980cec5fcdafc766a69f88d8cfe
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Group.InjSurj
 import Mathbin.Data.List.BigOperators.Basic
@@ -16,6 +11,8 @@ import Mathbin.GroupTheory.Submonoid.Basic
 import Mathbin.Data.SetLike.Basic
 import Mathbin.Data.Sigma.Basic
 
+#align_import algebra.graded_monoid from "leanprover-community/mathlib"@"fac369018417f980cec5fcdafc766a69f88d8cfe"
+
 /-!
 # Additively-graded multiplicative structures
 

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

@@ -154,26 +154,32 @@ instance GMul.toMul [Add ι] [GMul A] : Mul (GradedMonoid A) :=
 #align graded_monoid.ghas_mul.to_has_mul GradedMonoid.GMul.toMul
 -/
 
+#print GradedMonoid.mk_mul_mk /-
 theorem mk_mul_mk [Add ι] [GMul A] {i j} (a : A i) (b : A j) :
     mk i a * mk j b = mk (i + j) (GMul.mul a b) :=
   rfl
 #align graded_monoid.mk_mul_mk GradedMonoid.mk_mul_mk
+-/
 
 namespace Gmonoid
 
 variable {A} [AddMonoid ι] [GMul A] [GOne A]
 
+#print GradedMonoid.GMonoid.gnpowRec /-
 /-- A default implementation of power on a graded monoid, like `npow_rec`.
 `gmonoid.gnpow` should be used instead. -/
 def gnpowRec : ∀ (n : ℕ) {i}, A i → A (n • i)
   | 0, i, a => cast (congr_arg A (zero_nsmul i).symm) GOne.one
   | n + 1, i, a => cast (congr_arg A (succ_nsmul i n).symm) (GMul.mul a <| gnpow_rec _ a)
 #align graded_monoid.gmonoid.gnpow_rec GradedMonoid.GMonoid.gnpowRec
+-/
 
+#print GradedMonoid.GMonoid.gnpowRec_zero /-
 @[simp]
 theorem gnpowRec_zero (a : GradedMonoid A) : GradedMonoid.mk _ (gnpowRec 0 a.snd) = 1 :=
   Sigma.ext (zero_nsmul _) (heq_of_cast_eq _ rfl).symm
 #align graded_monoid.gmonoid.gnpow_rec_zero GradedMonoid.GMonoid.gnpowRec_zero
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:336:4: warning: unsupported (TODO): `[tacs] -/
 /-- Tactic used to autofill `graded_monoid.gmonoid.gnpow_zero'` when the default
@@ -182,11 +188,13 @@ unsafe def apply_gnpow_rec_zero_tac : tactic Unit :=
   sorry
 #align graded_monoid.gmonoid.apply_gnpow_rec_zero_tac graded_monoid.gmonoid.apply_gnpow_rec_zero_tac
 
+#print GradedMonoid.GMonoid.gnpowRec_succ /-
 @[simp]
 theorem gnpowRec_succ (n : ℕ) (a : GradedMonoid A) :
     (GradedMonoid.mk _ <| gnpowRec n.succ a.snd) = a * ⟨_, gnpowRec n a.snd⟩ :=
   Sigma.ext (succ_nsmul _ _) (heq_of_cast_eq _ rfl).symm
 #align graded_monoid.gmonoid.gnpow_rec_succ GradedMonoid.GMonoid.gnpowRec_succ
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:336:4: warning: unsupported (TODO): `[tacs] -/
 /-- Tactic used to autofill `graded_monoid.gmonoid.gnpow_succ'` when the default
@@ -235,6 +243,7 @@ instance GMonoid.toMonoid [AddMonoid ι] [GMonoid A] : Monoid (GradedMonoid A)
 #align graded_monoid.gmonoid.to_monoid GradedMonoid.GMonoid.toMonoid
 -/
 
+#print GradedMonoid.mk_pow /-
 theorem mk_pow [AddMonoid ι] [GMonoid A] {i} (a : A i) (n : ℕ) :
     mk i a ^ n = mk (n • i) (GMonoid.gnpow _ a) :=
   by
@@ -244,6 +253,7 @@ theorem mk_pow [AddMonoid ι] [GMonoid A] {i} (a : A i) (n : ℕ) :
   · rw [pow_succ, n_ih, mk_mul_mk]
     exact (gmonoid.gnpow_succ' n ⟨_, a⟩).symm
 #align graded_monoid.mk_pow GradedMonoid.mk_pow
+-/
 
 #print GradedMonoid.GCommMonoid /-
 /-- A graded version of `comm_monoid`. -/
@@ -291,29 +301,37 @@ section Mul
 
 variable [AddZeroClass ι] [GMul A]
 
+#print GradedMonoid.GradeZero.smul /-
 /-- `(•) : A 0 → A i → A i` is the value provided in `graded_monoid.ghas_mul.mul`, composed with
 an `eq.rec` to turn `A (0 + i)` into `A i`.
 -/
 instance GradeZero.smul (i : ι) : SMul (A 0) (A i) where smul x y := (zero_add i).rec (GMul.mul x y)
 #align graded_monoid.grade_zero.has_smul GradedMonoid.GradeZero.smul
+-/
 
+#print GradedMonoid.GradeZero.mul /-
 /-- `(*) : A 0 → A 0 → A 0` is the value provided in `graded_monoid.ghas_mul.mul`, composed with
 an `eq.rec` to turn `A (0 + 0)` into `A 0`.
 -/
 instance GradeZero.mul : Mul (A 0) where mul := (· • ·)
 #align graded_monoid.grade_zero.has_mul GradedMonoid.GradeZero.mul
+-/
 
 variable {A}
 
+#print GradedMonoid.mk_zero_smul /-
 @[simp]
 theorem mk_zero_smul {i} (a : A 0) (b : A i) : mk _ (a • b) = mk _ a * mk _ b :=
   Sigma.ext (zero_add _).symm <| eq_rec_hEq _ _
 #align graded_monoid.mk_zero_smul GradedMonoid.mk_zero_smul
+-/
 
+#print GradedMonoid.GradeZero.smul_eq_mul /-
 @[simp]
 theorem GradeZero.smul_eq_mul (a b : A 0) : a • b = a * b :=
   rfl
 #align graded_monoid.grade_zero.smul_eq_mul GradedMonoid.GradeZero.smul_eq_mul
+-/
 
 end Mul
 
@@ -325,17 +343,21 @@ instance : Pow (A 0) ℕ where pow x n := (nsmul_zero n).rec (GMonoid.gnpow n x
 
 variable {A}
 
+#print GradedMonoid.mk_zero_pow /-
 @[simp]
 theorem mk_zero_pow (a : A 0) (n : ℕ) : mk _ (a ^ n) = mk _ a ^ n :=
   Sigma.ext (nsmul_zero n).symm <| eq_rec_hEq _ _
 #align graded_monoid.mk_zero_pow GradedMonoid.mk_zero_pow
+-/
 
 variable (A)
 
+#print GradedMonoid.GradeZero.monoid /-
 /-- The `monoid` structure derived from `gmonoid A`. -/
 instance GradeZero.monoid : Monoid (A 0) :=
   Function.Injective.monoid (mk 0) sigma_mk_injective rfl mk_zero_smul mk_zero_pow
 #align graded_monoid.grade_zero.monoid GradedMonoid.GradeZero.monoid
+-/
 
 end Monoid
 
@@ -343,10 +365,12 @@ section Monoid
 
 variable [AddCommMonoid ι] [GCommMonoid A]
 
+#print GradedMonoid.GradeZero.commMonoid /-
 /-- The `comm_monoid` structure derived from `gcomm_monoid A`. -/
 instance GradeZero.commMonoid : CommMonoid (A 0) :=
   Function.Injective.commMonoid (mk 0) sigma_mk_injective rfl mk_zero_smul mk_zero_pow
 #align graded_monoid.grade_zero.comm_monoid GradedMonoid.GradeZero.commMonoid
+-/
 
 end Monoid
 
@@ -354,6 +378,7 @@ section MulAction
 
 variable [AddMonoid ι] [GMonoid A]
 
+#print GradedMonoid.mkZeroMonoidHom /-
 /-- `graded_monoid.mk 0` is a `monoid_hom`, using the `graded_monoid.grade_zero.monoid` structure.
 -/
 def mkZeroMonoidHom : A 0 →* GradedMonoid A
@@ -362,12 +387,15 @@ def mkZeroMonoidHom : A 0 →* GradedMonoid A
   map_one' := rfl
   map_mul' := mk_zero_smul
 #align graded_monoid.mk_zero_monoid_hom GradedMonoid.mkZeroMonoidHom
+-/
 
+#print GradedMonoid.GradeZero.mulAction /-
 /-- Each grade `A i` derives a `A 0`-action structure from `gmonoid A`. -/
 instance GradeZero.mulAction {i} : MulAction (A 0) (A i) :=
   letI := MulAction.compHom (GradedMonoid A) (mk_zero_monoid_hom A)
   Function.Injective.mulAction (mk i) sigma_mk_injective mk_zero_smul
 #align graded_monoid.grade_zero.mul_action GradedMonoid.GradeZero.mulAction
+-/
 
 end MulAction
 
@@ -390,17 +418,22 @@ def List.dProdIndex (l : List α) (fι : α → ι) : ι :=
 #align list.dprod_index List.dProdIndex
 -/
 
+#print List.dProdIndex_nil /-
 @[simp]
 theorem List.dProdIndex_nil (fι : α → ι) : ([] : List α).dProdIndex fι = 0 :=
   rfl
 #align list.dprod_index_nil List.dProdIndex_nil
+-/
 
+#print List.dProdIndex_cons /-
 @[simp]
 theorem List.dProdIndex_cons (a : α) (l : List α) (fι : α → ι) :
     (a :: l).dProdIndex fι = fι a + l.dProdIndex fι :=
   rfl
 #align list.dprod_index_cons List.dProdIndex_cons
+-/
 
+#print List.dProdIndex_eq_map_sum /-
 theorem List.dProdIndex_eq_map_sum (l : List α) (fι : α → ι) : l.dProdIndex fι = (l.map fι).Sum :=
   by
   dsimp only [List.dProdIndex]
@@ -408,6 +441,7 @@ theorem List.dProdIndex_eq_map_sum (l : List α) (fι : α → ι) : l.dProdInde
   · simp
   · simp [l_ih]
 #align list.dprod_index_eq_map_sum List.dProdIndex_eq_map_sum
+-/
 
 #print List.dProd /-
 /-- A dependent product for graded monoids represented by the indexed family of types `A i`.
@@ -420,12 +454,15 @@ def List.dProd (l : List α) (fι : α → ι) (fA : ∀ a, A (fι a)) : A (l.dP
 #align list.dprod List.dProd
 -/
 
+#print List.dProd_nil /-
 @[simp]
 theorem List.dProd_nil (fι : α → ι) (fA : ∀ a, A (fι a)) :
     (List.nil : List α).dProd fι fA = GradedMonoid.GOne.one :=
   rfl
 #align list.dprod_nil List.dProd_nil
+-/
 
+#print List.dProd_cons /-
 -- the `( : _)` in this lemma statement results in the type on the RHS not being unfolded, which
 -- is nicer in the goal view.
 @[simp]
@@ -433,7 +470,9 @@ theorem List.dProd_cons (fι : α → ι) (fA : ∀ a, A (fι a)) (a : α) (l :
     (a :: l).dProd fι fA = (GradedMonoid.GMul.mul (fA a) (l.dProd fι fA) : _) :=
   rfl
 #align list.dprod_cons List.dProd_cons
+-/
 
+#print GradedMonoid.mk_list_dProd /-
 theorem GradedMonoid.mk_list_dProd (l : List α) (fι : α → ι) (fA : ∀ a, A (fι a)) :
     GradedMonoid.mk _ (l.dProd fι fA) = (l.map fun a => GradedMonoid.mk (fι a) (fA a)).Prod :=
   by
@@ -442,7 +481,9 @@ theorem GradedMonoid.mk_list_dProd (l : List α) (fι : α → ι) (fA : ∀ a,
   · simp [← l_ih, GradedMonoid.mk_mul_mk, List.prod_cons]
     rfl
 #align graded_monoid.mk_list_dprod GradedMonoid.mk_list_dProd
+-/
 
+#print GradedMonoid.list_prod_map_eq_dProd /-
 /-- A variant of `graded_monoid.mk_list_dprod` for rewriting in the other direction. -/
 theorem GradedMonoid.list_prod_map_eq_dProd (l : List α) (f : α → GradedMonoid A) :
     (l.map f).Prod = GradedMonoid.mk _ (l.dProd (fun i => (f i).1) fun i => (f i).2) :=
@@ -450,12 +491,15 @@ theorem GradedMonoid.list_prod_map_eq_dProd (l : List α) (f : α → GradedMono
   rw [GradedMonoid.mk_list_dProd, GradedMonoid.mk]
   simp_rw [Sigma.eta]
 #align graded_monoid.list_prod_map_eq_dprod GradedMonoid.list_prod_map_eq_dProd
+-/
 
+#print GradedMonoid.list_prod_ofFn_eq_dProd /-
 theorem GradedMonoid.list_prod_ofFn_eq_dProd {n : ℕ} (f : Fin n → GradedMonoid A) :
     (List.ofFn f).Prod =
       GradedMonoid.mk _ ((List.finRange n).dProd (fun i => (f i).1) fun i => (f i).2) :=
   by rw [List.ofFn_eq_map, GradedMonoid.list_prod_map_eq_dProd]
 #align graded_monoid.list_prod_of_fn_eq_dprod GradedMonoid.list_prod_ofFn_eq_dProd
+-/
 
 end Dprod
 
@@ -504,6 +548,7 @@ instance CommMonoid.gCommMonoid [AddCommMonoid ι] [CommMonoid R] :
 #align comm_monoid.gcomm_monoid CommMonoid.gCommMonoid
 -/
 
+#print List.dProd_monoid /-
 /-- When all the indexed types are the same, the dependent product is just the regular product. -/
 @[simp]
 theorem List.dProd_monoid {α} [AddMonoid ι] [Monoid R] (l : List α) (fι : α → ι) (fA : α → R) :
@@ -513,6 +558,7 @@ theorem List.dProd_monoid {α} [AddMonoid ι] [Monoid R] (l : List α) (fι : α
   · rw [List.dProd_nil, List.map_nil, List.prod_nil]; rfl
   · rw [List.dProd_cons, List.map_cons, List.prod_cons, l_ih]; rfl
 #align list.dprod_monoid List.dProd_monoid
+-/
 
 end
 
@@ -595,13 +641,16 @@ variable {S : Type _} [SetLike S R] [Monoid R] [AddMonoid ι]
 
 variable {A : ι → S} [SetLike.GradedMonoid A]
 
+#print SetLike.pow_mem_graded /-
 theorem pow_mem_graded (n : ℕ) {r : R} {i : ι} (h : r ∈ A i) : r ^ n ∈ A (n • i) :=
   by
   induction n
   · rw [pow_zero, zero_nsmul]; exact one_mem_graded _
   · rw [pow_succ', succ_nsmul']; exact mul_mem_graded n_ih h
 #align set_like.pow_mem_graded SetLike.pow_mem_graded
+-/
 
+#print SetLike.list_prod_map_mem_graded /-
 theorem list_prod_map_mem_graded {ι'} (l : List ι') (i : ι' → ι) (r : ι' → R)
     (h : ∀ j ∈ l, r j ∈ A (i j)) : (l.map r).Prod ∈ A (l.map i).Sum :=
   by
@@ -613,13 +662,16 @@ theorem list_prod_map_mem_graded {ι'} (l : List ι') (i : ι' → ι) (r : ι'
       mul_mem_graded (h _ <| List.mem_cons_self _ _)
         (l_ih fun j hj => h _ <| List.mem_cons_of_mem _ hj)
 #align set_like.list_prod_map_mem_graded SetLike.list_prod_map_mem_graded
+-/
 
+#print SetLike.list_prod_ofFn_mem_graded /-
 theorem list_prod_ofFn_mem_graded {n} (i : Fin n → ι) (r : Fin n → R) (h : ∀ j, r j ∈ A (i j)) :
     (List.ofFn r).Prod ∈ A (List.ofFn i).Sum :=
   by
   rw [List.ofFn_eq_map, List.ofFn_eq_map]
   exact list_prod_map_mem_graded _ _ _ fun _ _ => h _
 #align set_like.list_prod_of_fn_mem_graded SetLike.list_prod_ofFn_mem_graded
+-/
 
 end SetLike
 
@@ -664,6 +716,7 @@ open SetLike SetLike.GradedMonoid
 
 variable {α S : Type _} [SetLike S R] [Monoid R] [AddMonoid ι]
 
+#print SetLike.coe_list_dProd /-
 /-- Coercing a dependent product of subtypes is the same as taking the regular product of the
 coercions. -/
 @[simp]
@@ -675,9 +728,9 @@ theorem SetLike.coe_list_dProd (A : ι → S) [SetLike.GradedMonoid A] (fι : α
   · rw [List.dProd_nil, coe_ghas_one, List.map_nil, List.prod_nil]
   · rw [List.dProd_cons, coe_ghas_mul, List.map_cons, List.prod_cons, l_ih]
 #align set_like.coe_list_dprod SetLike.coe_list_dProd
+-/
 
-include R
-
+#print SetLike.list_dProd_eq /-
 /-- A version of `list.coe_dprod_set_like` with `subtype.mk`. -/
 theorem SetLike.list_dProd_eq (A : ι → S) [SetLike.GradedMonoid A] (fι : α → ι) (fA : ∀ a, A (fι a))
     (l : List α) :
@@ -687,6 +740,7 @@ theorem SetLike.list_dProd_eq (A : ι → S) [SetLike.GradedMonoid A] (fι : α
           list_prod_map_mem_graded l _ _ fun i hi => (fA i).Prop⟩ :=
   Subtype.ext <| SetLike.coe_list_dProd _ _ _ _
 #align set_like.list_dprod_eq SetLike.list_dProd_eq
+-/
 
 end Dprod
 
@@ -703,20 +757,26 @@ def SetLike.Homogeneous (A : ι → S) (a : R) : Prop :=
 #align set_like.is_homogeneous SetLike.Homogeneous
 -/
 
+#print SetLike.homogeneous_coe /-
 @[simp]
 theorem SetLike.homogeneous_coe {A : ι → S} {i} (x : A i) : SetLike.Homogeneous A (x : R) :=
   ⟨i, x.Prop⟩
 #align set_like.is_homogeneous_coe SetLike.homogeneous_coe
+-/
 
+#print SetLike.homogeneous_one /-
 theorem SetLike.homogeneous_one [Zero ι] [One R] (A : ι → S) [SetLike.GradedOne A] :
     SetLike.Homogeneous A (1 : R) :=
   ⟨0, SetLike.one_mem_graded _⟩
 #align set_like.is_homogeneous_one SetLike.homogeneous_one
+-/
 
+#print SetLike.homogeneous_mul /-
 theorem SetLike.homogeneous_mul [Add ι] [Mul R] {A : ι → S} [SetLike.GradedMul A] {a b : R} :
     SetLike.Homogeneous A a → SetLike.Homogeneous A b → SetLike.Homogeneous A (a * b)
   | ⟨i, hi⟩, ⟨j, hj⟩ => ⟨i + j, SetLike.mul_mem_graded hi hj⟩
 #align set_like.is_homogeneous.mul SetLike.homogeneous_mul
+-/
 
 #print SetLike.homogeneousSubmonoid /-
 /-- When `A` is a `set_like.graded_monoid A`, then the homogeneous elements forms a submonoid. -/

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

@@ -175,7 +175,7 @@ theorem gnpowRec_zero (a : GradedMonoid A) : GradedMonoid.mk _ (gnpowRec 0 a.snd
   Sigma.ext (zero_nsmul _) (heq_of_cast_eq _ rfl).symm
 #align graded_monoid.gmonoid.gnpow_rec_zero GradedMonoid.GMonoid.gnpowRec_zero
 
-/- ./././Mathport/Syntax/Translate/Expr.lean:330:4: warning: unsupported (TODO): `[tacs] -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:336:4: warning: unsupported (TODO): `[tacs] -/
 /-- Tactic used to autofill `graded_monoid.gmonoid.gnpow_zero'` when the default
 `graded_monoid.gmonoid.gnpow_rec` is used. -/
 unsafe def apply_gnpow_rec_zero_tac : tactic Unit :=
@@ -188,7 +188,7 @@ theorem gnpowRec_succ (n : ℕ) (a : GradedMonoid A) :
   Sigma.ext (succ_nsmul _ _) (heq_of_cast_eq _ rfl).symm
 #align graded_monoid.gmonoid.gnpow_rec_succ GradedMonoid.GMonoid.gnpowRec_succ
 
-/- ./././Mathport/Syntax/Translate/Expr.lean:330:4: warning: unsupported (TODO): `[tacs] -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:336:4: warning: unsupported (TODO): `[tacs] -/
 /-- Tactic used to autofill `graded_monoid.gmonoid.gnpow_succ'` when the default
 `graded_monoid.gmonoid.gnpow_rec` is used. -/
 unsafe def apply_gnpow_rec_succ_tac : tactic Unit :=

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

@@ -722,7 +722,7 @@ theorem SetLike.homogeneous_mul [Add ι] [Mul R] {A : ι → S} [SetLike.GradedM
 /-- When `A` is a `set_like.graded_monoid A`, then the homogeneous elements forms a submonoid. -/
 def SetLike.homogeneousSubmonoid [AddMonoid ι] [Monoid R] (A : ι → S) [SetLike.GradedMonoid A] :
     Submonoid R where
-  carrier := { a | SetLike.Homogeneous A a }
+  carrier := {a | SetLike.Homogeneous A a}
   one_mem' := SetLike.homogeneous_one A
   mul_mem' a b := SetLike.homogeneous_mul
 #align set_like.homogeneous_submonoid SetLike.homogeneousSubmonoid

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

@@ -585,7 +585,7 @@ theorem SetLike.coe_gMul {S : Type _} [SetLike S R] [Mul R] [Add ι] (A : ι →
 #print SetLike.GradedMonoid /-
 /-- A version of `graded_monoid.gmonoid` for internally graded objects. -/
 class SetLike.GradedMonoid {S : Type _} [SetLike S R] [Monoid R] [AddMonoid ι] (A : ι → S) extends
-  SetLike.GradedOne A, SetLike.GradedMul A : Prop
+    SetLike.GradedOne A, SetLike.GradedMul A : Prop
 #align set_like.graded_monoid SetLike.GradedMonoid
 -/
 

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

@@ -154,12 +154,6 @@ instance GMul.toMul [Add ι] [GMul A] : Mul (GradedMonoid A) :=
 #align graded_monoid.ghas_mul.to_has_mul GradedMonoid.GMul.toMul
 -/
 
-/- warning: graded_monoid.mk_mul_mk -> GradedMonoid.mk_mul_mk is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} (A : ι -> Type.{u2}) [_inst_1 : Add.{u1} ι] [_inst_2 : GradedMonoid.GMul.{u1, u2} ι A _inst_1] {i : ι} {j : ι} (a : A i) (b : A j), Eq.{succ (max u1 u2)} (GradedMonoid.{u1, u2} ι (fun {i : ι} => A i)) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (GradedMonoid.{u1, u2} ι (fun {i : ι} => A i)) (GradedMonoid.{u1, u2} ι (fun {i : ι} => A i)) (GradedMonoid.{u1, u2} ι (fun {i : ι} => A i)) (instHMul.{max u1 u2} (GradedMonoid.{u1, u2} ι (fun {i : ι} => A i)) (GradedMonoid.GMul.toMul.{u1, u2} ι (fun {i : ι} => A i) _inst_1 _inst_2)) (GradedMonoid.mk.{u1, u2} ι (fun {i : ι} => A i) i a) (GradedMonoid.mk.{u1, u2} ι (fun {i : ι} => A i) j b)) (GradedMonoid.mk.{u1, u2} ι (fun {i : ι} => A i) (HAdd.hAdd.{u1, u1, u1} ι ι ι (instHAdd.{u1} ι _inst_1) i j) (GradedMonoid.GMul.mul.{u1, u2} ι A _inst_1 _inst_2 i j a b))
-but is expected to have type
-  forall {ι : Type.{u2}} (A : ι -> Type.{u1}) [_inst_1 : Add.{u2} ι] [_inst_2 : GradedMonoid.GMul.{u2, u1} ι A _inst_1] {i : ι} {j : ι} (a : A i) (b : A j), Eq.{max (succ u2) (succ u1)} (GradedMonoid.{u2, u1} ι A) (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (GradedMonoid.{u2, u1} ι A) (GradedMonoid.{u2, u1} ι A) (GradedMonoid.{u2, u1} ι A) (instHMul.{max u2 u1} (GradedMonoid.{u2, u1} ι A) (GradedMonoid.GMul.toMul.{u2, u1} ι A _inst_1 _inst_2)) (GradedMonoid.mk.{u2, u1} ι A i a) (GradedMonoid.mk.{u2, u1} ι A j b)) (GradedMonoid.mk.{u2, u1} ι A (HAdd.hAdd.{u2, u2, u2} ι ι ι (instHAdd.{u2} ι _inst_1) i j) (GradedMonoid.GMul.mul.{u2, u1} ι A _inst_1 _inst_2 i j a b))
-Case conversion may be inaccurate. Consider using '#align graded_monoid.mk_mul_mk GradedMonoid.mk_mul_mkₓ'. -/
 theorem mk_mul_mk [Add ι] [GMul A] {i j} (a : A i) (b : A j) :
     mk i a * mk j b = mk (i + j) (GMul.mul a b) :=
   rfl
@@ -169,12 +163,6 @@ namespace Gmonoid
 
 variable {A} [AddMonoid ι] [GMul A] [GOne A]
 
-/- warning: graded_monoid.gmonoid.gnpow_rec -> GradedMonoid.GMonoid.gnpowRec is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {A : ι -> Type.{u2}} [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : GradedMonoid.GMul.{u1, u2} ι A (AddZeroClass.toHasAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1))] [_inst_3 : GradedMonoid.GOne.{u1, u2} ι A (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1))] (n : Nat) {i : ι}, (A i) -> (A (SMul.smul.{0, u1} Nat ι (AddMonoid.SMul.{u1} ι _inst_1) n i))
-but is expected to have type
-  forall {ι : Type.{u1}} {A : ι -> Type.{u2}} [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : GradedMonoid.GMul.{u1, u2} ι A (AddZeroClass.toAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1))] [_inst_3 : GradedMonoid.GOne.{u1, u2} ι A (AddMonoid.toZero.{u1} ι _inst_1)] (n : Nat) {i : ι}, (A i) -> (A (HSMul.hSMul.{0, u1, u1} Nat ι ι (instHSMul.{0, u1} Nat ι (AddMonoid.SMul.{u1} ι _inst_1)) n i))
-Case conversion may be inaccurate. Consider using '#align graded_monoid.gmonoid.gnpow_rec GradedMonoid.GMonoid.gnpowRecₓ'. -/
 /-- A default implementation of power on a graded monoid, like `npow_rec`.
 `gmonoid.gnpow` should be used instead. -/
 def gnpowRec : ∀ (n : ℕ) {i}, A i → A (n • i)
@@ -182,12 +170,6 @@ def gnpowRec : ∀ (n : ℕ) {i}, A i → A (n • i)
   | n + 1, i, a => cast (congr_arg A (succ_nsmul i n).symm) (GMul.mul a <| gnpow_rec _ a)
 #align graded_monoid.gmonoid.gnpow_rec GradedMonoid.GMonoid.gnpowRec
 
-/- warning: graded_monoid.gmonoid.gnpow_rec_zero -> GradedMonoid.GMonoid.gnpowRec_zero is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {A : ι -> Type.{u2}} [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : GradedMonoid.GMul.{u1, u2} ι A (AddZeroClass.toHasAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1))] [_inst_3 : GradedMonoid.GOne.{u1, u2} ι A (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1))] (a : GradedMonoid.{u1, u2} ι A), Eq.{max (succ u1) (succ u2)} (GradedMonoid.{u1, u2} ι A) (GradedMonoid.mk.{u1, u2} ι A (SMul.smul.{0, u1} Nat ι (AddMonoid.SMul.{u1} ι _inst_1) (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) (Sigma.fst.{u1, u2} ι A a)) (GradedMonoid.GMonoid.gnpowRec.{u1, u2} ι A _inst_1 _inst_2 _inst_3 (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) (Sigma.fst.{u1, u2} ι A a) (Sigma.snd.{u1, u2} ι A a))) (OfNat.ofNat.{max u1 u2} (GradedMonoid.{u1, u2} ι A) 1 (OfNat.mk.{max u1 u2} (GradedMonoid.{u1, u2} ι A) 1 (One.one.{max u1 u2} (GradedMonoid.{u1, u2} ι A) (GradedMonoid.GOne.toOne.{u1, u2} ι A (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)) _inst_3))))
-but is expected to have type
-  forall {ι : Type.{u2}} {A : ι -> Type.{u1}} [_inst_1 : AddMonoid.{u2} ι] [_inst_2 : GradedMonoid.GMul.{u2, u1} ι A (AddZeroClass.toAdd.{u2} ι (AddMonoid.toAddZeroClass.{u2} ι _inst_1))] [_inst_3 : GradedMonoid.GOne.{u2, u1} ι A (AddMonoid.toZero.{u2} ι _inst_1)] (a : GradedMonoid.{u2, u1} ι A), Eq.{max (succ u2) (succ u1)} (GradedMonoid.{u2, u1} ι A) (GradedMonoid.mk.{u2, u1} ι A (HSMul.hSMul.{0, u2, u2} Nat ι ι (instHSMul.{0, u2} Nat ι (AddMonoid.SMul.{u2} ι _inst_1)) (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) (Sigma.fst.{u2, u1} ι A a)) (GradedMonoid.GMonoid.gnpowRec.{u2, u1} ι A _inst_1 _inst_2 _inst_3 (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) (Sigma.fst.{u2, u1} ι A a) (Sigma.snd.{u2, u1} ι A a))) (OfNat.ofNat.{max u2 u1} (GradedMonoid.{u2, u1} ι A) 1 (One.toOfNat1.{max u2 u1} (GradedMonoid.{u2, u1} ι A) (GradedMonoid.GOne.toOne.{u2, u1} ι A (AddMonoid.toZero.{u2} ι _inst_1) _inst_3)))
-Case conversion may be inaccurate. Consider using '#align graded_monoid.gmonoid.gnpow_rec_zero GradedMonoid.GMonoid.gnpowRec_zeroₓ'. -/
 @[simp]
 theorem gnpowRec_zero (a : GradedMonoid A) : GradedMonoid.mk _ (gnpowRec 0 a.snd) = 1 :=
   Sigma.ext (zero_nsmul _) (heq_of_cast_eq _ rfl).symm
@@ -200,12 +182,6 @@ unsafe def apply_gnpow_rec_zero_tac : tactic Unit :=
   sorry
 #align graded_monoid.gmonoid.apply_gnpow_rec_zero_tac graded_monoid.gmonoid.apply_gnpow_rec_zero_tac
 
-/- warning: graded_monoid.gmonoid.gnpow_rec_succ -> GradedMonoid.GMonoid.gnpowRec_succ is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {A : ι -> Type.{u2}} [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : GradedMonoid.GMul.{u1, u2} ι A (AddZeroClass.toHasAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1))] [_inst_3 : GradedMonoid.GOne.{u1, u2} ι A (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1))] (n : Nat) (a : GradedMonoid.{u1, u2} ι A), Eq.{max (succ u1) (succ u2)} (GradedMonoid.{u1, u2} ι A) (GradedMonoid.mk.{u1, u2} ι A (SMul.smul.{0, u1} Nat ι (AddMonoid.SMul.{u1} ι _inst_1) (Nat.succ n) (Sigma.fst.{u1, u2} ι A a)) (GradedMonoid.GMonoid.gnpowRec.{u1, u2} ι A _inst_1 _inst_2 _inst_3 (Nat.succ n) (Sigma.fst.{u1, u2} ι A a) (Sigma.snd.{u1, u2} ι A a))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (GradedMonoid.{u1, u2} ι A) (GradedMonoid.{u1, u2} ι A) (GradedMonoid.{u1, u2} ι A) (instHMul.{max u1 u2} (GradedMonoid.{u1, u2} ι A) (GradedMonoid.GMul.toMul.{u1, u2} ι A (AddZeroClass.toHasAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)) _inst_2)) a (Sigma.mk.{u1, u2} ι A (SMul.smul.{0, u1} Nat ι (AddMonoid.SMul.{u1} ι _inst_1) n (Sigma.fst.{u1, u2} ι A a)) (GradedMonoid.GMonoid.gnpowRec.{u1, u2} ι A _inst_1 _inst_2 _inst_3 n (Sigma.fst.{u1, u2} ι A a) (Sigma.snd.{u1, u2} ι A a))))
-but is expected to have type
-  forall {ι : Type.{u2}} {A : ι -> Type.{u1}} [_inst_1 : AddMonoid.{u2} ι] [_inst_2 : GradedMonoid.GMul.{u2, u1} ι A (AddZeroClass.toAdd.{u2} ι (AddMonoid.toAddZeroClass.{u2} ι _inst_1))] [_inst_3 : GradedMonoid.GOne.{u2, u1} ι A (AddMonoid.toZero.{u2} ι _inst_1)] (n : Nat) (a : GradedMonoid.{u2, u1} ι A), Eq.{max (succ u2) (succ u1)} (GradedMonoid.{u2, u1} ι A) (GradedMonoid.mk.{u2, u1} ι A (HSMul.hSMul.{0, u2, u2} Nat ι ι (instHSMul.{0, u2} Nat ι (AddMonoid.SMul.{u2} ι _inst_1)) (Nat.succ n) (Sigma.fst.{u2, u1} ι A a)) (GradedMonoid.GMonoid.gnpowRec.{u2, u1} ι A _inst_1 _inst_2 _inst_3 (Nat.succ n) (Sigma.fst.{u2, u1} ι A a) (Sigma.snd.{u2, u1} ι A a))) (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (GradedMonoid.{u2, u1} ι A) (GradedMonoid.{u2, u1} ι A) (GradedMonoid.{u2, u1} ι A) (instHMul.{max u2 u1} (GradedMonoid.{u2, u1} ι A) (GradedMonoid.GMul.toMul.{u2, u1} ι A (AddZeroClass.toAdd.{u2} ι (AddMonoid.toAddZeroClass.{u2} ι _inst_1)) _inst_2)) a (Sigma.mk.{u2, u1} ι A (HSMul.hSMul.{0, u2, u2} Nat ι ι (instHSMul.{0, u2} Nat ι (AddMonoid.SMul.{u2} ι _inst_1)) n (Sigma.fst.{u2, u1} ι A a)) (GradedMonoid.GMonoid.gnpowRec.{u2, u1} ι A _inst_1 _inst_2 _inst_3 n (Sigma.fst.{u2, u1} ι A a) (Sigma.snd.{u2, u1} ι A a))))
-Case conversion may be inaccurate. Consider using '#align graded_monoid.gmonoid.gnpow_rec_succ GradedMonoid.GMonoid.gnpowRec_succₓ'. -/
 @[simp]
 theorem gnpowRec_succ (n : ℕ) (a : GradedMonoid A) :
     (GradedMonoid.mk _ <| gnpowRec n.succ a.snd) = a * ⟨_, gnpowRec n a.snd⟩ :=
@@ -259,12 +235,6 @@ instance GMonoid.toMonoid [AddMonoid ι] [GMonoid A] : Monoid (GradedMonoid A)
 #align graded_monoid.gmonoid.to_monoid GradedMonoid.GMonoid.toMonoid
 -/
 
-/- warning: graded_monoid.mk_pow -> GradedMonoid.mk_pow is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} (A : ι -> Type.{u2}) [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : GradedMonoid.GMonoid.{u1, u2} ι A _inst_1] {i : ι} (a : A i) (n : Nat), Eq.{succ (max u1 u2)} (GradedMonoid.{u1, u2} ι (fun {i : ι} => A i)) (HPow.hPow.{max u1 u2, 0, max u1 u2} (GradedMonoid.{u1, u2} ι (fun {i : ι} => A i)) Nat (GradedMonoid.{u1, u2} ι (fun {i : ι} => A i)) (instHPow.{max u1 u2, 0} (GradedMonoid.{u1, u2} ι (fun {i : ι} => A i)) Nat (Monoid.Pow.{max u1 u2} (GradedMonoid.{u1, u2} ι (fun {i : ι} => A i)) (GradedMonoid.GMonoid.toMonoid.{u1, u2} ι (fun {i : ι} => A i) _inst_1 _inst_2))) (GradedMonoid.mk.{u1, u2} ι (fun {i : ι} => A i) i a) n) (GradedMonoid.mk.{u1, u2} ι (fun {i : ι} => A i) (SMul.smul.{0, u1} Nat ι (AddMonoid.SMul.{u1} ι _inst_1) n i) (GradedMonoid.GMonoid.gnpow.{u1, u2} ι A _inst_1 _inst_2 n i a))
-but is expected to have type
-  forall {ι : Type.{u2}} (A : ι -> Type.{u1}) [_inst_1 : AddMonoid.{u2} ι] [_inst_2 : GradedMonoid.GMonoid.{u2, u1} ι A _inst_1] {i : ι} (a : A i) (n : Nat), Eq.{max (succ u2) (succ u1)} (GradedMonoid.{u2, u1} ι A) (HPow.hPow.{max u2 u1, 0, max u2 u1} (GradedMonoid.{u2, u1} ι A) Nat (GradedMonoid.{u2, u1} ι A) (instHPow.{max u2 u1, 0} (GradedMonoid.{u2, u1} ι A) Nat (Monoid.Pow.{max u2 u1} (GradedMonoid.{u2, u1} ι A) (GradedMonoid.GMonoid.toMonoid.{u2, u1} ι A _inst_1 _inst_2))) (GradedMonoid.mk.{u2, u1} ι A i a) n) (GradedMonoid.mk.{u2, u1} ι A (HSMul.hSMul.{0, u2, u2} Nat ι ι (instHSMul.{0, u2} Nat ι (AddMonoid.SMul.{u2} ι _inst_1)) n i) (GradedMonoid.GMonoid.gnpow.{u2, u1} ι A _inst_1 _inst_2 n i a))
-Case conversion may be inaccurate. Consider using '#align graded_monoid.mk_pow GradedMonoid.mk_powₓ'. -/
 theorem mk_pow [AddMonoid ι] [GMonoid A] {i} (a : A i) (n : ℕ) :
     mk i a ^ n = mk (n • i) (GMonoid.gnpow _ a) :=
   by
@@ -321,24 +291,12 @@ section Mul
 
 variable [AddZeroClass ι] [GMul A]
 
-/- warning: graded_monoid.grade_zero.has_smul -> GradedMonoid.GradeZero.smul is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} (A : ι -> Type.{u2}) [_inst_1 : AddZeroClass.{u1} ι] [_inst_2 : GradedMonoid.GMul.{u1, u2} ι A (AddZeroClass.toHasAdd.{u1} ι _inst_1)] (i : ι), SMul.{u2, u2} (A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι _inst_1))))) (A i)
-but is expected to have type
-  forall {ι : Type.{u1}} (A : ι -> Type.{u2}) [_inst_1 : AddZeroClass.{u1} ι] [_inst_2 : GradedMonoid.GMul.{u1, u2} ι A (AddZeroClass.toAdd.{u1} ι _inst_1)] (i : ι), SMul.{u2, u2} (A (OfNat.ofNat.{u1} ι 0 (Zero.toOfNat0.{u1} ι (AddZeroClass.toZero.{u1} ι _inst_1)))) (A i)
-Case conversion may be inaccurate. Consider using '#align graded_monoid.grade_zero.has_smul GradedMonoid.GradeZero.smulₓ'. -/
 /-- `(•) : A 0 → A i → A i` is the value provided in `graded_monoid.ghas_mul.mul`, composed with
 an `eq.rec` to turn `A (0 + i)` into `A i`.
 -/
 instance GradeZero.smul (i : ι) : SMul (A 0) (A i) where smul x y := (zero_add i).rec (GMul.mul x y)
 #align graded_monoid.grade_zero.has_smul GradedMonoid.GradeZero.smul
 
-/- warning: graded_monoid.grade_zero.has_mul -> GradedMonoid.GradeZero.mul is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} (A : ι -> Type.{u2}) [_inst_1 : AddZeroClass.{u1} ι] [_inst_2 : GradedMonoid.GMul.{u1, u2} ι A (AddZeroClass.toHasAdd.{u1} ι _inst_1)], Mul.{u2} (A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι _inst_1)))))
-but is expected to have type
-  forall {ι : Type.{u1}} (A : ι -> Type.{u2}) [_inst_1 : AddZeroClass.{u1} ι] [_inst_2 : GradedMonoid.GMul.{u1, u2} ι A (AddZeroClass.toAdd.{u1} ι _inst_1)], Mul.{u2} (A (OfNat.ofNat.{u1} ι 0 (Zero.toOfNat0.{u1} ι (AddZeroClass.toZero.{u1} ι _inst_1))))
-Case conversion may be inaccurate. Consider using '#align graded_monoid.grade_zero.has_mul GradedMonoid.GradeZero.mulₓ'. -/
 /-- `(*) : A 0 → A 0 → A 0` is the value provided in `graded_monoid.ghas_mul.mul`, composed with
 an `eq.rec` to turn `A (0 + 0)` into `A 0`.
 -/
@@ -347,23 +305,11 @@ instance GradeZero.mul : Mul (A 0) where mul := (· • ·)
 
 variable {A}
 
-/- warning: graded_monoid.mk_zero_smul -> GradedMonoid.mk_zero_smul is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {A : ι -> Type.{u2}} [_inst_1 : AddZeroClass.{u1} ι] [_inst_2 : GradedMonoid.GMul.{u1, u2} ι A (AddZeroClass.toHasAdd.{u1} ι _inst_1)] {i : ι} (a : A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι _inst_1))))) (b : A i), Eq.{max (succ u1) (succ u2)} (GradedMonoid.{u1, u2} ι A) (GradedMonoid.mk.{u1, u2} ι A i (SMul.smul.{u2, u2} (A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι _inst_1))))) (A i) (GradedMonoid.GradeZero.smul.{u1, u2} ι A _inst_1 _inst_2 i) a b)) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (GradedMonoid.{u1, u2} ι A) (GradedMonoid.{u1, u2} ι A) (GradedMonoid.{u1, u2} ι A) (instHMul.{max u1 u2} (GradedMonoid.{u1, u2} ι A) (GradedMonoid.GMul.toMul.{u1, u2} ι A (AddZeroClass.toHasAdd.{u1} ι _inst_1) _inst_2)) (GradedMonoid.mk.{u1, u2} ι A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι _inst_1)))) a) (GradedMonoid.mk.{u1, u2} ι A i b))
-but is expected to have type
-  forall {ι : Type.{u2}} {A : ι -> Type.{u1}} [_inst_1 : AddZeroClass.{u2} ι] [_inst_2 : GradedMonoid.GMul.{u2, u1} ι A (AddZeroClass.toAdd.{u2} ι _inst_1)] {i : ι} (a : A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddZeroClass.toZero.{u2} ι _inst_1)))) (b : A i), Eq.{max (succ u2) (succ u1)} (GradedMonoid.{u2, u1} ι A) (GradedMonoid.mk.{u2, u1} ι A i (HSMul.hSMul.{u1, u1, u1} (A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddZeroClass.toZero.{u2} ι _inst_1)))) (A i) (A i) (instHSMul.{u1, u1} (A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddZeroClass.toZero.{u2} ι _inst_1)))) (A i) (GradedMonoid.GradeZero.smul.{u2, u1} ι A _inst_1 _inst_2 i)) a b)) (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (GradedMonoid.{u2, u1} ι A) (GradedMonoid.{u2, u1} ι A) (GradedMonoid.{u2, u1} ι A) (instHMul.{max u2 u1} (GradedMonoid.{u2, u1} ι A) (GradedMonoid.GMul.toMul.{u2, u1} ι A (AddZeroClass.toAdd.{u2} ι _inst_1) _inst_2)) (GradedMonoid.mk.{u2, u1} ι A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddZeroClass.toZero.{u2} ι _inst_1))) a) (GradedMonoid.mk.{u2, u1} ι A i b))
-Case conversion may be inaccurate. Consider using '#align graded_monoid.mk_zero_smul GradedMonoid.mk_zero_smulₓ'. -/
 @[simp]
 theorem mk_zero_smul {i} (a : A 0) (b : A i) : mk _ (a • b) = mk _ a * mk _ b :=
   Sigma.ext (zero_add _).symm <| eq_rec_hEq _ _
 #align graded_monoid.mk_zero_smul GradedMonoid.mk_zero_smul
 
-/- warning: graded_monoid.grade_zero.smul_eq_mul -> GradedMonoid.GradeZero.smul_eq_mul is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {A : ι -> Type.{u2}} [_inst_1 : AddZeroClass.{u1} ι] [_inst_2 : GradedMonoid.GMul.{u1, u2} ι A (AddZeroClass.toHasAdd.{u1} ι _inst_1)] (a : A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι _inst_1))))) (b : A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι _inst_1))))), Eq.{succ u2} (A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι _inst_1))))) (SMul.smul.{u2, u2} (A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι _inst_1))))) (A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι _inst_1))))) (GradedMonoid.GradeZero.smul.{u1, u2} ι A _inst_1 _inst_2 (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι _inst_1))))) a b) (HMul.hMul.{u2, u2, u2} (A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι _inst_1))))) (A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι _inst_1))))) (A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι _inst_1))))) (instHMul.{u2} (A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι _inst_1))))) (GradedMonoid.GradeZero.mul.{u1, u2} ι A _inst_1 _inst_2)) a b)
-but is expected to have type
-  forall {ι : Type.{u2}} {A : ι -> Type.{u1}} [_inst_1 : AddZeroClass.{u2} ι] [_inst_2 : GradedMonoid.GMul.{u2, u1} ι A (AddZeroClass.toAdd.{u2} ι _inst_1)] (a : A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddZeroClass.toZero.{u2} ι _inst_1)))) (b : A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddZeroClass.toZero.{u2} ι _inst_1)))), Eq.{succ u1} (A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddZeroClass.toZero.{u2} ι _inst_1)))) (HSMul.hSMul.{u1, u1, u1} (A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddZeroClass.toZero.{u2} ι _inst_1)))) (A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddZeroClass.toZero.{u2} ι _inst_1)))) (A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddZeroClass.toZero.{u2} ι _inst_1)))) (instHSMul.{u1, u1} (A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddZeroClass.toZero.{u2} ι _inst_1)))) (A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddZeroClass.toZero.{u2} ι _inst_1)))) (GradedMonoid.GradeZero.smul.{u2, u1} ι A _inst_1 _inst_2 (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddZeroClass.toZero.{u2} ι _inst_1))))) a b) (HMul.hMul.{u1, u1, u1} (A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddZeroClass.toZero.{u2} ι _inst_1)))) (A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddZeroClass.toZero.{u2} ι _inst_1)))) (A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddZeroClass.toZero.{u2} ι _inst_1)))) (instHMul.{u1} (A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddZeroClass.toZero.{u2} ι _inst_1)))) (GradedMonoid.GradeZero.mul.{u2, u1} ι A _inst_1 _inst_2)) a b)
-Case conversion may be inaccurate. Consider using '#align graded_monoid.grade_zero.smul_eq_mul GradedMonoid.GradeZero.smul_eq_mulₓ'. -/
 @[simp]
 theorem GradeZero.smul_eq_mul (a b : A 0) : a • b = a * b :=
   rfl
@@ -379,12 +325,6 @@ instance : Pow (A 0) ℕ where pow x n := (nsmul_zero n).rec (GMonoid.gnpow n x
 
 variable {A}
 
-/- warning: graded_monoid.mk_zero_pow -> GradedMonoid.mk_zero_pow is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {A : ι -> Type.{u2}} [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : GradedMonoid.GMonoid.{u1, u2} ι A _inst_1] (a : A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)))))) (n : Nat), Eq.{max (succ u1) (succ u2)} (GradedMonoid.{u1, u2} ι A) (GradedMonoid.mk.{u1, u2} ι A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1))))) (HPow.hPow.{u2, 0, u2} (A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)))))) Nat (A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)))))) (instHPow.{u2, 0} (A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)))))) Nat (GradedMonoid.Nat.hasPow.{u1, u2} ι A _inst_1 _inst_2)) a n)) (HPow.hPow.{max u1 u2, 0, max u1 u2} (GradedMonoid.{u1, u2} ι A) Nat (GradedMonoid.{u1, u2} ι A) (instHPow.{max u1 u2, 0} (GradedMonoid.{u1, u2} ι A) Nat (Monoid.Pow.{max u1 u2} (GradedMonoid.{u1, u2} ι A) (GradedMonoid.GMonoid.toMonoid.{u1, u2} ι A _inst_1 _inst_2))) (GradedMonoid.mk.{u1, u2} ι A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1))))) a) n)
-but is expected to have type
-  forall {ι : Type.{u2}} {A : ι -> Type.{u1}} [_inst_1 : AddMonoid.{u2} ι] [_inst_2 : GradedMonoid.GMonoid.{u2, u1} ι A _inst_1] (a : A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddMonoid.toZero.{u2} ι _inst_1)))) (n : Nat), Eq.{max (succ u2) (succ u1)} (GradedMonoid.{u2, u1} ι A) (GradedMonoid.mk.{u2, u1} ι A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddMonoid.toZero.{u2} ι _inst_1))) (HPow.hPow.{u1, 0, u1} (A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddMonoid.toZero.{u2} ι _inst_1)))) Nat (A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddMonoid.toZero.{u2} ι _inst_1)))) (instHPow.{u1, 0} (A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddMonoid.toZero.{u2} ι _inst_1)))) Nat (GradedMonoid.instPowOfNatToOfNat0ToZeroNat.{u2, u1} ι A _inst_1 _inst_2)) a n)) (HPow.hPow.{max u2 u1, 0, max u2 u1} (GradedMonoid.{u2, u1} ι A) Nat (GradedMonoid.{u2, u1} ι A) (instHPow.{max u2 u1, 0} (GradedMonoid.{u2, u1} ι A) Nat (Monoid.Pow.{max u2 u1} (GradedMonoid.{u2, u1} ι A) (GradedMonoid.GMonoid.toMonoid.{u2, u1} ι A _inst_1 _inst_2))) (GradedMonoid.mk.{u2, u1} ι A (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddMonoid.toZero.{u2} ι _inst_1))) a) n)
-Case conversion may be inaccurate. Consider using '#align graded_monoid.mk_zero_pow GradedMonoid.mk_zero_powₓ'. -/
 @[simp]
 theorem mk_zero_pow (a : A 0) (n : ℕ) : mk _ (a ^ n) = mk _ a ^ n :=
   Sigma.ext (nsmul_zero n).symm <| eq_rec_hEq _ _
@@ -392,12 +332,6 @@ theorem mk_zero_pow (a : A 0) (n : ℕ) : mk _ (a ^ n) = mk _ a ^ n :=
 
 variable (A)
 
-/- warning: graded_monoid.grade_zero.monoid -> GradedMonoid.GradeZero.monoid is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} (A : ι -> Type.{u2}) [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : GradedMonoid.GMonoid.{u1, u2} ι A _inst_1], Monoid.{u2} (A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1))))))
-but is expected to have type
-  forall {ι : Type.{u1}} (A : ι -> Type.{u2}) [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : GradedMonoid.GMonoid.{u1, u2} ι A _inst_1], Monoid.{u2} (A (OfNat.ofNat.{u1} ι 0 (Zero.toOfNat0.{u1} ι (AddMonoid.toZero.{u1} ι _inst_1))))
-Case conversion may be inaccurate. Consider using '#align graded_monoid.grade_zero.monoid GradedMonoid.GradeZero.monoidₓ'. -/
 /-- The `monoid` structure derived from `gmonoid A`. -/
 instance GradeZero.monoid : Monoid (A 0) :=
   Function.Injective.monoid (mk 0) sigma_mk_injective rfl mk_zero_smul mk_zero_pow
@@ -409,12 +343,6 @@ section Monoid
 
 variable [AddCommMonoid ι] [GCommMonoid A]
 
-/- warning: graded_monoid.grade_zero.comm_monoid -> GradedMonoid.GradeZero.commMonoid is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} (A : ι -> Type.{u2}) [_inst_1 : AddCommMonoid.{u1} ι] [_inst_2 : GradedMonoid.GCommMonoid.{u1, u2} ι A _inst_1], CommMonoid.{u2} (A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι (AddCommMonoid.toAddMonoid.{u1} ι _inst_1)))))))
-but is expected to have type
-  forall {ι : Type.{u1}} (A : ι -> Type.{u2}) [_inst_1 : AddCommMonoid.{u1} ι] [_inst_2 : GradedMonoid.GCommMonoid.{u1, u2} ι A _inst_1], CommMonoid.{u2} (A (OfNat.ofNat.{u1} ι 0 (Zero.toOfNat0.{u1} ι (AddMonoid.toZero.{u1} ι (AddCommMonoid.toAddMonoid.{u1} ι _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align graded_monoid.grade_zero.comm_monoid GradedMonoid.GradeZero.commMonoidₓ'. -/
 /-- The `comm_monoid` structure derived from `gcomm_monoid A`. -/
 instance GradeZero.commMonoid : CommMonoid (A 0) :=
   Function.Injective.commMonoid (mk 0) sigma_mk_injective rfl mk_zero_smul mk_zero_pow
@@ -426,12 +354,6 @@ section MulAction
 
 variable [AddMonoid ι] [GMonoid A]
 
-/- warning: graded_monoid.mk_zero_monoid_hom -> GradedMonoid.mkZeroMonoidHom is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} (A : ι -> Type.{u2}) [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : GradedMonoid.GMonoid.{u1, u2} ι A _inst_1], MonoidHom.{u2, max u1 u2} (A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)))))) (GradedMonoid.{u1, u2} ι A) (Monoid.toMulOneClass.{u2} (A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)))))) (GradedMonoid.GradeZero.monoid.{u1, u2} ι A _inst_1 _inst_2)) (Monoid.toMulOneClass.{max u1 u2} (GradedMonoid.{u1, u2} ι A) (GradedMonoid.GMonoid.toMonoid.{u1, u2} ι A _inst_1 _inst_2))
-but is expected to have type
-  forall {ι : Type.{u1}} (A : ι -> Type.{u2}) [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : GradedMonoid.GMonoid.{u1, u2} ι A _inst_1], MonoidHom.{u2, max u2 u1} (A (OfNat.ofNat.{u1} ι 0 (Zero.toOfNat0.{u1} ι (AddMonoid.toZero.{u1} ι _inst_1)))) (GradedMonoid.{u1, u2} ι A) (Monoid.toMulOneClass.{u2} (A (OfNat.ofNat.{u1} ι 0 (Zero.toOfNat0.{u1} ι (AddMonoid.toZero.{u1} ι _inst_1)))) (GradedMonoid.GradeZero.monoid.{u1, u2} ι A _inst_1 _inst_2)) (Monoid.toMulOneClass.{max u1 u2} (GradedMonoid.{u1, u2} ι A) (GradedMonoid.GMonoid.toMonoid.{u1, u2} ι A _inst_1 _inst_2))
-Case conversion may be inaccurate. Consider using '#align graded_monoid.mk_zero_monoid_hom GradedMonoid.mkZeroMonoidHomₓ'. -/
 /-- `graded_monoid.mk 0` is a `monoid_hom`, using the `graded_monoid.grade_zero.monoid` structure.
 -/
 def mkZeroMonoidHom : A 0 →* GradedMonoid A
@@ -441,12 +363,6 @@ def mkZeroMonoidHom : A 0 →* GradedMonoid A
   map_mul' := mk_zero_smul
 #align graded_monoid.mk_zero_monoid_hom GradedMonoid.mkZeroMonoidHom
 
-/- warning: graded_monoid.grade_zero.mul_action -> GradedMonoid.GradeZero.mulAction is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} (A : ι -> Type.{u2}) [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : GradedMonoid.GMonoid.{u1, u2} ι A _inst_1] {i : ι}, MulAction.{u2, u2} (A (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)))))) (A i) (GradedMonoid.GradeZero.monoid.{u1, u2} ι A _inst_1 _inst_2)
-but is expected to have type
-  forall {ι : Type.{u1}} (A : ι -> Type.{u2}) [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : GradedMonoid.GMonoid.{u1, u2} ι A _inst_1] {i : ι}, MulAction.{u2, u2} (A (OfNat.ofNat.{u1} ι 0 (Zero.toOfNat0.{u1} ι (AddMonoid.toZero.{u1} ι _inst_1)))) (A i) (GradedMonoid.GradeZero.monoid.{u1, u2} ι A _inst_1 _inst_2)
-Case conversion may be inaccurate. Consider using '#align graded_monoid.grade_zero.mul_action GradedMonoid.GradeZero.mulActionₓ'. -/
 /-- Each grade `A i` derives a `A 0`-action structure from `gmonoid A`. -/
 instance GradeZero.mulAction {i} : MulAction (A 0) (A i) :=
   letI := MulAction.compHom (GradedMonoid A) (mk_zero_monoid_hom A)
@@ -474,35 +390,17 @@ def List.dProdIndex (l : List α) (fι : α → ι) : ι :=
 #align list.dprod_index List.dProdIndex
 -/
 
-/- warning: list.dprod_index_nil -> List.dProdIndex_nil is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : AddMonoid.{u1} ι] (fι : α -> ι), Eq.{succ u1} ι (List.dProdIndex.{u1, u2} ι α _inst_1 (List.nil.{u2} α) fι) (OfNat.ofNat.{u1} ι 0 (OfNat.mk.{u1} ι 0 (Zero.zero.{u1} ι (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)))))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : AddMonoid.{u2} ι] (fι : α -> ι), Eq.{succ u2} ι (List.dProdIndex.{u2, u1} ι α _inst_1 (List.nil.{u1} α) fι) (OfNat.ofNat.{u2} ι 0 (Zero.toOfNat0.{u2} ι (AddMonoid.toZero.{u2} ι _inst_1)))
-Case conversion may be inaccurate. Consider using '#align list.dprod_index_nil List.dProdIndex_nilₓ'. -/
 @[simp]
 theorem List.dProdIndex_nil (fι : α → ι) : ([] : List α).dProdIndex fι = 0 :=
   rfl
 #align list.dprod_index_nil List.dProdIndex_nil
 
-/- warning: list.dprod_index_cons -> List.dProdIndex_cons is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : AddMonoid.{u1} ι] (a : α) (l : List.{u2} α) (fι : α -> ι), Eq.{succ u1} ι (List.dProdIndex.{u1, u2} ι α _inst_1 (List.cons.{u2} α a l) fι) (HAdd.hAdd.{u1, u1, u1} ι ι ι (instHAdd.{u1} ι (AddZeroClass.toHasAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1))) (fι a) (List.dProdIndex.{u1, u2} ι α _inst_1 l fι))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : AddMonoid.{u1} ι] (a : α) (l : List.{u2} α) (fι : α -> ι), Eq.{succ u1} ι (List.dProdIndex.{u1, u2} ι α _inst_1 (List.cons.{u2} α a l) fι) (HAdd.hAdd.{u1, u1, u1} ι ι ι (instHAdd.{u1} ι (AddZeroClass.toAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1))) (fι a) (List.dProdIndex.{u1, u2} ι α _inst_1 l fι))
-Case conversion may be inaccurate. Consider using '#align list.dprod_index_cons List.dProdIndex_consₓ'. -/
 @[simp]
 theorem List.dProdIndex_cons (a : α) (l : List α) (fι : α → ι) :
     (a :: l).dProdIndex fι = fι a + l.dProdIndex fι :=
   rfl
 #align list.dprod_index_cons List.dProdIndex_cons
 
-/- warning: list.dprod_index_eq_map_sum -> List.dProdIndex_eq_map_sum is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : AddMonoid.{u1} ι] (l : List.{u2} α) (fι : α -> ι), Eq.{succ u1} ι (List.dProdIndex.{u1, u2} ι α _inst_1 l fι) (List.sum.{u1} ι (AddZeroClass.toHasAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)) (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)) (List.map.{u2, u1} α ι fι l))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : AddMonoid.{u1} ι] (l : List.{u2} α) (fι : α -> ι), Eq.{succ u1} ι (List.dProdIndex.{u1, u2} ι α _inst_1 l fι) (List.sum.{u1} ι (AddZeroClass.toAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)) (AddMonoid.toZero.{u1} ι _inst_1) (List.map.{u2, u1} α ι fι l))
-Case conversion may be inaccurate. Consider using '#align list.dprod_index_eq_map_sum List.dProdIndex_eq_map_sumₓ'. -/
 theorem List.dProdIndex_eq_map_sum (l : List α) (fι : α → ι) : l.dProdIndex fι = (l.map fι).Sum :=
   by
   dsimp only [List.dProdIndex]
@@ -522,24 +420,12 @@ def List.dProd (l : List α) (fι : α → ι) (fA : ∀ a, A (fι a)) : A (l.dP
 #align list.dprod List.dProd
 -/
 
-/- warning: list.dprod_nil -> List.dProd_nil is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} {A : ι -> Type.{u3}} [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : GradedMonoid.GMonoid.{u1, u3} ι A _inst_1] (fι : α -> ι) (fA : forall (a : α), A (fι a)), Eq.{succ u3} (A (List.dProdIndex.{u1, u2} ι α _inst_1 (List.nil.{u2} α) fι)) (List.dProd.{u1, u2, u3} ι α A _inst_1 _inst_2 (List.nil.{u2} α) fι fA) (GradedMonoid.GOne.one.{u1, u3} ι A (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)) (GradedMonoid.GMonoid.toGhasOne.{u1, u3} ι A _inst_1 _inst_2))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} {A : ι -> Type.{u3}} [_inst_1 : AddMonoid.{u2} ι] [_inst_2 : GradedMonoid.GMonoid.{u2, u3} ι A _inst_1] (fι : α -> ι) (fA : forall (a : α), A (fι a)), Eq.{succ u3} (A (List.dProdIndex.{u2, u1} ι α _inst_1 (List.nil.{u1} α) fι)) (List.dProd.{u2, u1, u3} ι α A _inst_1 _inst_2 (List.nil.{u1} α) fι fA) (GradedMonoid.GOne.one.{u2, u3} ι A (AddMonoid.toZero.{u2} ι _inst_1) (GradedMonoid.GMonoid.toGOne.{u2, u3} ι A _inst_1 _inst_2))
-Case conversion may be inaccurate. Consider using '#align list.dprod_nil List.dProd_nilₓ'. -/
 @[simp]
 theorem List.dProd_nil (fι : α → ι) (fA : ∀ a, A (fι a)) :
     (List.nil : List α).dProd fι fA = GradedMonoid.GOne.one :=
   rfl
 #align list.dprod_nil List.dProd_nil
 
-/- warning: list.dprod_cons -> List.dProd_cons is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} {A : ι -> Type.{u3}} [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : GradedMonoid.GMonoid.{u1, u3} ι A _inst_1] (fι : α -> ι) (fA : forall (a : α), A (fι a)) (a : α) (l : List.{u2} α), Eq.{succ u3} (A (List.dProdIndex.{u1, u2} ι α _inst_1 (List.cons.{u2} α a l) fι)) (List.dProd.{u1, u2, u3} ι α A _inst_1 _inst_2 (List.cons.{u2} α a l) fι fA) (GradedMonoid.GMul.mul.{u1, u3} ι A (AddZeroClass.toHasAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)) (GradedMonoid.GMonoid.toGhasMul.{u1, u3} ι A _inst_1 _inst_2) (fι a) (List.dProdIndex.{u1, u2} ι α _inst_1 l fι) (fA a) (List.dProd.{u1, u2, u3} ι α A _inst_1 _inst_2 l fι fA))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : Type.{u3}} {A : ι -> Type.{u2}} [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : GradedMonoid.GMonoid.{u1, u2} ι A _inst_1] (fι : α -> ι) (fA : forall (a : α), A (fι a)) (a : α) (l : List.{u3} α), Eq.{succ u2} (A (List.dProdIndex.{u1, u3} ι α _inst_1 (List.cons.{u3} α a l) fι)) (List.dProd.{u1, u3, u2} ι α A _inst_1 _inst_2 (List.cons.{u3} α a l) fι fA) (GradedMonoid.GMul.mul.{u1, u2} ι A (AddZeroClass.toAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)) (GradedMonoid.GMonoid.toGMul.{u1, u2} ι A _inst_1 _inst_2) (fι a) (List.dProdIndex.{u1, u3} ι α _inst_1 l fι) (fA a) (List.dProd.{u1, u3, u2} ι α A _inst_1 _inst_2 l fι fA))
-Case conversion may be inaccurate. Consider using '#align list.dprod_cons List.dProd_consₓ'. -/
 -- the `( : _)` in this lemma statement results in the type on the RHS not being unfolded, which
 -- is nicer in the goal view.
 @[simp]
@@ -548,12 +434,6 @@ theorem List.dProd_cons (fι : α → ι) (fA : ∀ a, A (fι a)) (a : α) (l :
   rfl
 #align list.dprod_cons List.dProd_cons
 
-/- warning: graded_monoid.mk_list_dprod -> GradedMonoid.mk_list_dProd is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} {A : ι -> Type.{u3}} [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : GradedMonoid.GMonoid.{u1, u3} ι A _inst_1] (l : List.{u2} α) (fι : α -> ι) (fA : forall (a : α), A (fι a)), Eq.{max (succ u1) (succ u3)} (GradedMonoid.{u1, u3} ι A) (GradedMonoid.mk.{u1, u3} ι A (List.dProdIndex.{u1, u2} ι α _inst_1 l fι) (List.dProd.{u1, u2, u3} ι α A _inst_1 _inst_2 l fι fA)) (List.prod.{max u1 u3} (GradedMonoid.{u1, u3} ι A) (GradedMonoid.GMul.toMul.{u1, u3} ι A (AddZeroClass.toHasAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)) (GradedMonoid.GMonoid.toGhasMul.{u1, u3} ι A _inst_1 _inst_2)) (GradedMonoid.GOne.toOne.{u1, u3} ι A (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)) (GradedMonoid.GMonoid.toGhasOne.{u1, u3} ι A _inst_1 _inst_2)) (List.map.{u2, max u1 u3} α (GradedMonoid.{u1, u3} ι A) (fun (a : α) => GradedMonoid.mk.{u1, u3} ι A (fι a) (fA a)) l))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u3}} {A : ι -> Type.{u1}} [_inst_1 : AddMonoid.{u2} ι] [_inst_2 : GradedMonoid.GMonoid.{u2, u1} ι A _inst_1] (l : List.{u3} α) (fι : α -> ι) (fA : forall (a : α), A (fι a)), Eq.{max (succ u2) (succ u1)} (GradedMonoid.{u2, u1} ι A) (GradedMonoid.mk.{u2, u1} ι A (List.dProdIndex.{u2, u3} ι α _inst_1 l fι) (List.dProd.{u2, u3, u1} ι α A _inst_1 _inst_2 l fι fA)) (List.prod.{max u2 u1} (GradedMonoid.{u2, u1} ι A) (GradedMonoid.GMul.toMul.{u2, u1} ι A (AddZeroClass.toAdd.{u2} ι (AddMonoid.toAddZeroClass.{u2} ι _inst_1)) (GradedMonoid.GMonoid.toGMul.{u2, u1} ι A _inst_1 _inst_2)) (GradedMonoid.GOne.toOne.{u2, u1} ι A (AddMonoid.toZero.{u2} ι _inst_1) (GradedMonoid.GMonoid.toGOne.{u2, u1} ι A _inst_1 _inst_2)) (List.map.{u3, max u1 u2} α (GradedMonoid.{u2, u1} ι A) (fun (a : α) => GradedMonoid.mk.{u2, u1} ι A (fι a) (fA a)) l))
-Case conversion may be inaccurate. Consider using '#align graded_monoid.mk_list_dprod GradedMonoid.mk_list_dProdₓ'. -/
 theorem GradedMonoid.mk_list_dProd (l : List α) (fι : α → ι) (fA : ∀ a, A (fι a)) :
     GradedMonoid.mk _ (l.dProd fι fA) = (l.map fun a => GradedMonoid.mk (fι a) (fA a)).Prod :=
   by
@@ -563,12 +443,6 @@ theorem GradedMonoid.mk_list_dProd (l : List α) (fι : α → ι) (fA : ∀ a,
     rfl
 #align graded_monoid.mk_list_dprod GradedMonoid.mk_list_dProd
 
-/- warning: graded_monoid.list_prod_map_eq_dprod -> GradedMonoid.list_prod_map_eq_dProd is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} {A : ι -> Type.{u3}} [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : GradedMonoid.GMonoid.{u1, u3} ι A _inst_1] (l : List.{u2} α) (f : α -> (GradedMonoid.{u1, u3} ι A)), Eq.{max (succ u1) (succ u3)} (GradedMonoid.{u1, u3} ι A) (List.prod.{max u1 u3} (GradedMonoid.{u1, u3} ι A) (GradedMonoid.GMul.toMul.{u1, u3} ι A (AddZeroClass.toHasAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)) (GradedMonoid.GMonoid.toGhasMul.{u1, u3} ι A _inst_1 _inst_2)) (GradedMonoid.GOne.toOne.{u1, u3} ι A (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)) (GradedMonoid.GMonoid.toGhasOne.{u1, u3} ι A _inst_1 _inst_2)) (List.map.{u2, max u1 u3} α (GradedMonoid.{u1, u3} ι A) f l)) (GradedMonoid.mk.{u1, u3} ι A (List.dProdIndex.{u1, u2} ι α _inst_1 l (fun (i : α) => Sigma.fst.{u1, u3} ι A (f i))) (List.dProd.{u1, u2, u3} ι α A _inst_1 _inst_2 l (fun (i : α) => Sigma.fst.{u1, u3} ι A (f i)) (fun (i : α) => Sigma.snd.{u1, u3} ι A (f i))))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u3}} {A : ι -> Type.{u1}} [_inst_1 : AddMonoid.{u2} ι] [_inst_2 : GradedMonoid.GMonoid.{u2, u1} ι A _inst_1] (l : List.{u3} α) (f : α -> (GradedMonoid.{u2, u1} ι A)), Eq.{max (succ u2) (succ u1)} (GradedMonoid.{u2, u1} ι A) (List.prod.{max u2 u1} (GradedMonoid.{u2, u1} ι A) (GradedMonoid.GMul.toMul.{u2, u1} ι A (AddZeroClass.toAdd.{u2} ι (AddMonoid.toAddZeroClass.{u2} ι _inst_1)) (GradedMonoid.GMonoid.toGMul.{u2, u1} ι A _inst_1 _inst_2)) (GradedMonoid.GOne.toOne.{u2, u1} ι A (AddMonoid.toZero.{u2} ι _inst_1) (GradedMonoid.GMonoid.toGOne.{u2, u1} ι A _inst_1 _inst_2)) (List.map.{u3, max u2 u1} α (GradedMonoid.{u2, u1} ι A) f l)) (GradedMonoid.mk.{u2, u1} ι A (List.dProdIndex.{u2, u3} ι α _inst_1 l (fun (i : α) => Sigma.fst.{u2, u1} ι A (f i))) (List.dProd.{u2, u3, u1} ι α A _inst_1 _inst_2 l (fun (i : α) => Sigma.fst.{u2, u1} ι A (f i)) (fun (i : α) => Sigma.snd.{u2, u1} ι A (f i))))
-Case conversion may be inaccurate. Consider using '#align graded_monoid.list_prod_map_eq_dprod GradedMonoid.list_prod_map_eq_dProdₓ'. -/
 /-- A variant of `graded_monoid.mk_list_dprod` for rewriting in the other direction. -/
 theorem GradedMonoid.list_prod_map_eq_dProd (l : List α) (f : α → GradedMonoid A) :
     (l.map f).Prod = GradedMonoid.mk _ (l.dProd (fun i => (f i).1) fun i => (f i).2) :=
@@ -577,12 +451,6 @@ theorem GradedMonoid.list_prod_map_eq_dProd (l : List α) (f : α → GradedMono
   simp_rw [Sigma.eta]
 #align graded_monoid.list_prod_map_eq_dprod GradedMonoid.list_prod_map_eq_dProd
 
-/- warning: graded_monoid.list_prod_of_fn_eq_dprod -> GradedMonoid.list_prod_ofFn_eq_dProd is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {A : ι -> Type.{u2}} [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : GradedMonoid.GMonoid.{u1, u2} ι A _inst_1] {n : Nat} (f : (Fin n) -> (GradedMonoid.{u1, u2} ι A)), Eq.{max (succ u1) (succ u2)} (GradedMonoid.{u1, u2} ι A) (List.prod.{max u1 u2} (GradedMonoid.{u1, u2} ι A) (GradedMonoid.GMul.toMul.{u1, u2} ι A (AddZeroClass.toHasAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)) (GradedMonoid.GMonoid.toGhasMul.{u1, u2} ι A _inst_1 _inst_2)) (GradedMonoid.GOne.toOne.{u1, u2} ι A (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)) (GradedMonoid.GMonoid.toGhasOne.{u1, u2} ι A _inst_1 _inst_2)) (List.ofFn.{max u1 u2} (GradedMonoid.{u1, u2} ι A) n f)) (GradedMonoid.mk.{u1, u2} ι A (List.dProdIndex.{u1, 0} ι (Fin n) _inst_1 (List.finRange n) (fun (i : Fin n) => Sigma.fst.{u1, u2} ι A (f i))) (List.dProd.{u1, 0, u2} ι (Fin n) A _inst_1 _inst_2 (List.finRange n) (fun (i : Fin n) => Sigma.fst.{u1, u2} ι A (f i)) (fun (i : Fin n) => Sigma.snd.{u1, u2} ι A (f i))))
-but is expected to have type
-  forall {ι : Type.{u2}} {A : ι -> Type.{u1}} [_inst_1 : AddMonoid.{u2} ι] [_inst_2 : GradedMonoid.GMonoid.{u2, u1} ι A _inst_1] {n : Nat} (f : (Fin n) -> (GradedMonoid.{u2, u1} ι A)), Eq.{max (succ u2) (succ u1)} (GradedMonoid.{u2, u1} ι A) (List.prod.{max u2 u1} (GradedMonoid.{u2, u1} ι A) (GradedMonoid.GMul.toMul.{u2, u1} ι A (AddZeroClass.toAdd.{u2} ι (AddMonoid.toAddZeroClass.{u2} ι _inst_1)) (GradedMonoid.GMonoid.toGMul.{u2, u1} ι A _inst_1 _inst_2)) (GradedMonoid.GOne.toOne.{u2, u1} ι A (AddMonoid.toZero.{u2} ι _inst_1) (GradedMonoid.GMonoid.toGOne.{u2, u1} ι A _inst_1 _inst_2)) (List.ofFn.{max u2 u1} (GradedMonoid.{u2, u1} ι A) n f)) (GradedMonoid.mk.{u2, u1} ι A (List.dProdIndex.{u2, 0} ι (Fin n) _inst_1 (List.finRange n) (fun (i : Fin n) => Sigma.fst.{u2, u1} ι A (f i))) (List.dProd.{u2, 0, u1} ι (Fin n) A _inst_1 _inst_2 (List.finRange n) (fun (i : Fin n) => Sigma.fst.{u2, u1} ι A (f i)) (fun (i : Fin n) => Sigma.snd.{u2, u1} ι A (f i))))
-Case conversion may be inaccurate. Consider using '#align graded_monoid.list_prod_of_fn_eq_dprod GradedMonoid.list_prod_ofFn_eq_dProdₓ'. -/
 theorem GradedMonoid.list_prod_ofFn_eq_dProd {n : ℕ} (f : Fin n → GradedMonoid A) :
     (List.ofFn f).Prod =
       GradedMonoid.mk _ ((List.finRange n).dProd (fun i => (f i).1) fun i => (f i).2) :=
@@ -636,12 +504,6 @@ instance CommMonoid.gCommMonoid [AddCommMonoid ι] [CommMonoid R] :
 #align comm_monoid.gcomm_monoid CommMonoid.gCommMonoid
 -/
 
-/- warning: list.dprod_monoid -> List.dProd_monoid is a dubious translation:
-lean 3 declaration is
-  forall (ι : Type.{u1}) {R : Type.{u2}} {α : Type.{u3}} [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : Monoid.{u2} R] (l : List.{u3} α) (fι : α -> ι) (fA : α -> R), Eq.{succ u2} R (List.dProd.{u1, u3, u2} ι α (fun (i : ι) => R) _inst_1 (Monoid.gMonoid.{u1, u2} ι R _inst_1 _inst_2) l fι fA) (List.prod.{u2} R (MulOneClass.toHasMul.{u2} R (Monoid.toMulOneClass.{u2} R _inst_2)) (MulOneClass.toHasOne.{u2} R (Monoid.toMulOneClass.{u2} R _inst_2)) (List.map.{u3, u2} α R fA l))
-but is expected to have type
-  forall (ι : Type.{u2}) {R : Type.{u1}} {α : Type.{u3}} [_inst_1 : AddMonoid.{u2} ι] [_inst_2 : Monoid.{u1} R] (l : List.{u3} α) (fι : α -> ι) (fA : α -> R), Eq.{succ u1} R (List.dProd.{u2, u3, u1} ι α (fun (i : ι) => R) _inst_1 (Monoid.gMonoid.{u2, u1} ι R _inst_1 _inst_2) l fι fA) (List.prod.{u1} R (MulOneClass.toMul.{u1} R (Monoid.toMulOneClass.{u1} R _inst_2)) (Monoid.toOne.{u1} R _inst_2) (List.map.{u3, u1} α R fA l))
-Case conversion may be inaccurate. Consider using '#align list.dprod_monoid List.dProd_monoidₓ'. -/
 /-- When all the indexed types are the same, the dependent product is just the regular product. -/
 @[simp]
 theorem List.dProd_monoid {α} [AddMonoid ι] [Monoid R] (l : List α) (fι : α → ι) (fA : α → R) :
@@ -733,12 +595,6 @@ variable {S : Type _} [SetLike S R] [Monoid R] [AddMonoid ι]
 
 variable {A : ι → S} [SetLike.GradedMonoid A]
 
-/- warning: set_like.pow_mem_graded -> SetLike.pow_mem_graded is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {R : Type.{u2}} {S : Type.{u3}} [_inst_1 : SetLike.{u3, u2} S R] [_inst_2 : Monoid.{u2} R] [_inst_3 : AddMonoid.{u1} ι] {A : ι -> S} [_inst_4 : SetLike.GradedMonoid.{u1, u2, u3} ι R S _inst_1 _inst_2 _inst_3 A] (n : Nat) {r : R} {i : ι}, (Membership.Mem.{u2, u3} R S (SetLike.hasMem.{u3, u2} S R _inst_1) r (A i)) -> (Membership.Mem.{u2, u3} R S (SetLike.hasMem.{u3, u2} S R _inst_1) (HPow.hPow.{u2, 0, u2} R Nat R (instHPow.{u2, 0} R Nat (Monoid.Pow.{u2} R _inst_2)) r n) (A (SMul.smul.{0, u1} Nat ι (AddMonoid.SMul.{u1} ι _inst_3) n i)))
-but is expected to have type
-  forall {ι : Type.{u1}} {R : Type.{u3}} {S : Type.{u2}} [_inst_1 : SetLike.{u2, u3} S R] [_inst_2 : Monoid.{u3} R] [_inst_3 : AddMonoid.{u1} ι] {A : ι -> S} [_inst_4 : SetLike.GradedMonoid.{u1, u3, u2} ι R S _inst_1 _inst_2 _inst_3 A] (n : Nat) {r : R} {i : ι}, (Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) r (A i)) -> (Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) (HPow.hPow.{u3, 0, u3} R Nat R (instHPow.{u3, 0} R Nat (Monoid.Pow.{u3} R _inst_2)) r n) (A (HSMul.hSMul.{0, u1, u1} Nat ι ι (instHSMul.{0, u1} Nat ι (AddMonoid.SMul.{u1} ι _inst_3)) n i)))
-Case conversion may be inaccurate. Consider using '#align set_like.pow_mem_graded SetLike.pow_mem_gradedₓ'. -/
 theorem pow_mem_graded (n : ℕ) {r : R} {i : ι} (h : r ∈ A i) : r ^ n ∈ A (n • i) :=
   by
   induction n
@@ -746,12 +602,6 @@ theorem pow_mem_graded (n : ℕ) {r : R} {i : ι} (h : r ∈ A i) : r ^ n ∈ A
   · rw [pow_succ', succ_nsmul']; exact mul_mem_graded n_ih h
 #align set_like.pow_mem_graded SetLike.pow_mem_graded
 
-/- warning: set_like.list_prod_map_mem_graded -> SetLike.list_prod_map_mem_graded is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {R : Type.{u2}} {S : Type.{u3}} [_inst_1 : SetLike.{u3, u2} S R] [_inst_2 : Monoid.{u2} R] [_inst_3 : AddMonoid.{u1} ι] {A : ι -> S} [_inst_4 : SetLike.GradedMonoid.{u1, u2, u3} ι R S _inst_1 _inst_2 _inst_3 A] {ι' : Type.{u4}} (l : List.{u4} ι') (i : ι' -> ι) (r : ι' -> R), (forall (j : ι'), (Membership.Mem.{u4, u4} ι' (List.{u4} ι') (List.hasMem.{u4} ι') j l) -> (Membership.Mem.{u2, u3} R S (SetLike.hasMem.{u3, u2} S R _inst_1) (r j) (A (i j)))) -> (Membership.Mem.{u2, u3} R S (SetLike.hasMem.{u3, u2} S R _inst_1) (List.prod.{u2} R (MulOneClass.toHasMul.{u2} R (Monoid.toMulOneClass.{u2} R _inst_2)) (MulOneClass.toHasOne.{u2} R (Monoid.toMulOneClass.{u2} R _inst_2)) (List.map.{u4, u2} ι' R r l)) (A (List.sum.{u1} ι (AddZeroClass.toHasAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_3)) (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_3)) (List.map.{u4, u1} ι' ι i l))))
-but is expected to have type
-  forall {ι : Type.{u1}} {R : Type.{u3}} {S : Type.{u2}} [_inst_1 : SetLike.{u2, u3} S R] [_inst_2 : Monoid.{u3} R] [_inst_3 : AddMonoid.{u1} ι] {A : ι -> S} [_inst_4 : SetLike.GradedMonoid.{u1, u3, u2} ι R S _inst_1 _inst_2 _inst_3 A] {ι' : Type.{u4}} (l : List.{u4} ι') (i : ι' -> ι) (r : ι' -> R), (forall (j : ι'), (Membership.mem.{u4, u4} ι' (List.{u4} ι') (List.instMembershipList.{u4} ι') j l) -> (Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) (r j) (A (i j)))) -> (Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) (List.prod.{u3} R (MulOneClass.toMul.{u3} R (Monoid.toMulOneClass.{u3} R _inst_2)) (Monoid.toOne.{u3} R _inst_2) (List.map.{u4, u3} ι' R r l)) (A (List.sum.{u1} ι (AddZeroClass.toAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_3)) (AddMonoid.toZero.{u1} ι _inst_3) (List.map.{u4, u1} ι' ι i l))))
-Case conversion may be inaccurate. Consider using '#align set_like.list_prod_map_mem_graded SetLike.list_prod_map_mem_gradedₓ'. -/
 theorem list_prod_map_mem_graded {ι'} (l : List ι') (i : ι' → ι) (r : ι' → R)
     (h : ∀ j ∈ l, r j ∈ A (i j)) : (l.map r).Prod ∈ A (l.map i).Sum :=
   by
@@ -764,12 +614,6 @@ theorem list_prod_map_mem_graded {ι'} (l : List ι') (i : ι' → ι) (r : ι'
         (l_ih fun j hj => h _ <| List.mem_cons_of_mem _ hj)
 #align set_like.list_prod_map_mem_graded SetLike.list_prod_map_mem_graded
 
-/- warning: set_like.list_prod_of_fn_mem_graded -> SetLike.list_prod_ofFn_mem_graded is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {R : Type.{u2}} {S : Type.{u3}} [_inst_1 : SetLike.{u3, u2} S R] [_inst_2 : Monoid.{u2} R] [_inst_3 : AddMonoid.{u1} ι] {A : ι -> S} [_inst_4 : SetLike.GradedMonoid.{u1, u2, u3} ι R S _inst_1 _inst_2 _inst_3 A] {n : Nat} (i : (Fin n) -> ι) (r : (Fin n) -> R), (forall (j : Fin n), Membership.Mem.{u2, u3} R S (SetLike.hasMem.{u3, u2} S R _inst_1) (r j) (A (i j))) -> (Membership.Mem.{u2, u3} R S (SetLike.hasMem.{u3, u2} S R _inst_1) (List.prod.{u2} R (MulOneClass.toHasMul.{u2} R (Monoid.toMulOneClass.{u2} R _inst_2)) (MulOneClass.toHasOne.{u2} R (Monoid.toMulOneClass.{u2} R _inst_2)) (List.ofFn.{u2} R n r)) (A (List.sum.{u1} ι (AddZeroClass.toHasAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_3)) (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_3)) (List.ofFn.{u1} ι n i))))
-but is expected to have type
-  forall {ι : Type.{u1}} {R : Type.{u3}} {S : Type.{u2}} [_inst_1 : SetLike.{u2, u3} S R] [_inst_2 : Monoid.{u3} R] [_inst_3 : AddMonoid.{u1} ι] {A : ι -> S} [_inst_4 : SetLike.GradedMonoid.{u1, u3, u2} ι R S _inst_1 _inst_2 _inst_3 A] {n : Nat} (i : (Fin n) -> ι) (r : (Fin n) -> R), (forall (j : Fin n), Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) (r j) (A (i j))) -> (Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) (List.prod.{u3} R (MulOneClass.toMul.{u3} R (Monoid.toMulOneClass.{u3} R _inst_2)) (Monoid.toOne.{u3} R _inst_2) (List.ofFn.{u3} R n r)) (A (List.sum.{u1} ι (AddZeroClass.toAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_3)) (AddMonoid.toZero.{u1} ι _inst_3) (List.ofFn.{u1} ι n i))))
-Case conversion may be inaccurate. Consider using '#align set_like.list_prod_of_fn_mem_graded SetLike.list_prod_ofFn_mem_gradedₓ'. -/
 theorem list_prod_ofFn_mem_graded {n} (i : Fin n → ι) (r : Fin n → R) (h : ∀ j, r j ∈ A (i j)) :
     (List.ofFn r).Prod ∈ A (List.ofFn i).Sum :=
   by
@@ -820,12 +664,6 @@ open SetLike SetLike.GradedMonoid
 
 variable {α S : Type _} [SetLike S R] [Monoid R] [AddMonoid ι]
 
-/- warning: set_like.coe_list_dprod -> SetLike.coe_list_dProd is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {R : Type.{u2}} {α : Type.{u3}} {S : Type.{u4}} [_inst_1 : SetLike.{u4, u2} S R] [_inst_2 : Monoid.{u2} R] [_inst_3 : AddMonoid.{u1} ι] (A : ι -> S) [_inst_4 : SetLike.GradedMonoid.{u1, u2, u4} ι R S _inst_1 _inst_2 _inst_3 A] (fι : α -> ι) (fA : forall (a : α), coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) (l : List.{u3} α), Eq.{succ u2} R ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (List.dProdIndex.{u1, u3} ι α _inst_3 l fι))) R (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (List.dProdIndex.{u1, u3} ι α _inst_3 l fι))) R (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (List.dProdIndex.{u1, u3} ι α _inst_3 l fι))) R (coeBase.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (List.dProdIndex.{u1, u3} ι α _inst_3 l fι))) R (coeSubtype.{succ u2} R (fun (x : R) => Membership.Mem.{u2, u4} R S (SetLike.hasMem.{u4, u2} S R _inst_1) x (A (List.dProdIndex.{u1, u3} ι α _inst_3 l fι))))))) (List.dProd.{u1, u3, u2} ι α (fun (i : ι) => coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A i)) _inst_3 (SetLike.gMonoid.{u1, u2, u4} ι R S _inst_1 _inst_2 _inst_3 (fun (i : ι) => A i) _inst_4) l fι fA)) (List.prod.{u2} R (MulOneClass.toHasMul.{u2} R (Monoid.toMulOneClass.{u2} R _inst_2)) (MulOneClass.toHasOne.{u2} R (Monoid.toMulOneClass.{u2} R _inst_2)) (List.map.{u3, u2} α R (fun (a : α) => (fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (coeBase.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (coeSubtype.{succ u2} R (fun (x : R) => Membership.Mem.{u2, u4} R S (SetLike.hasMem.{u4, u2} S R _inst_1) x (A (fι a))))))) (fA a)) l))
-but is expected to have type
-  forall {ι : Type.{u4}} {R : Type.{u3}} {α : Type.{u1}} {S : Type.{u2}} [_inst_1 : SetLike.{u2, u3} S R] [_inst_2 : Monoid.{u3} R] [_inst_3 : AddMonoid.{u4} ι] (A : ι -> S) [_inst_4 : SetLike.GradedMonoid.{u4, u3, u2} ι R S _inst_1 _inst_2 _inst_3 A] (fι : α -> ι) (fA : forall (a : α), Subtype.{succ u3} R (fun (x : R) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) x (A (fι a)))) (l : List.{u1} α), Eq.{succ u3} R (Subtype.val.{succ u3} R (fun (x : R) => Membership.mem.{u3, u3} R (Set.{u3} R) (Set.instMembershipSet.{u3} R) x (SetLike.coe.{u2, u3} S R _inst_1 (A (List.dProdIndex.{u4, u1} ι α _inst_3 l fι)))) (List.dProd.{u4, u1, u3} ι α (fun (i : ι) => Subtype.{succ u3} R (fun (x : R) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) x (A i))) _inst_3 (SetLike.gMonoid.{u4, u3, u2} ι R S _inst_1 _inst_2 _inst_3 (fun (i : ι) => A i) _inst_4) l fι fA)) (List.prod.{u3} R (MulOneClass.toMul.{u3} R (Monoid.toMulOneClass.{u3} R _inst_2)) (Monoid.toOne.{u3} R _inst_2) (List.map.{u1, u3} α R (fun (a : α) => Subtype.val.{succ u3} R (fun (x : R) => Membership.mem.{u3, u3} R (Set.{u3} R) (Set.instMembershipSet.{u3} R) x (SetLike.coe.{u2, u3} S R _inst_1 (A (fι a)))) (fA a)) l))
-Case conversion may be inaccurate. Consider using '#align set_like.coe_list_dprod SetLike.coe_list_dProdₓ'. -/
 /-- Coercing a dependent product of subtypes is the same as taking the regular product of the
 coercions. -/
 @[simp]
@@ -840,9 +678,6 @@ theorem SetLike.coe_list_dProd (A : ι → S) [SetLike.GradedMonoid A] (fι : α
 
 include R
 
-/- warning: set_like.list_dprod_eq -> SetLike.list_dProd_eq is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align set_like.list_dprod_eq SetLike.list_dProd_eqₓ'. -/
 /-- A version of `list.coe_dprod_set_like` with `subtype.mk`. -/
 theorem SetLike.list_dProd_eq (A : ι → S) [SetLike.GradedMonoid A] (fι : α → ι) (fA : ∀ a, A (fι a))
     (l : List α) :
@@ -868,34 +703,16 @@ def SetLike.Homogeneous (A : ι → S) (a : R) : Prop :=
 #align set_like.is_homogeneous SetLike.Homogeneous
 -/
 
-/- warning: set_like.is_homogeneous_coe -> SetLike.homogeneous_coe is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {R : Type.{u2}} {S : Type.{u3}} [_inst_1 : SetLike.{u3, u2} S R] {A : ι -> S} {i : ι} (x : coeSort.{succ u3, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u3, u2} S R _inst_1) (A i)), SetLike.Homogeneous.{u1, u2, u3} ι R S _inst_1 A ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u3, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u3, u2} S R _inst_1) (A i)) R (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u3, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u3, u2} S R _inst_1) (A i)) R (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u3, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u3, u2} S R _inst_1) (A i)) R (coeBase.{succ u2, succ u2} (coeSort.{succ u3, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u3, u2} S R _inst_1) (A i)) R (coeSubtype.{succ u2} R (fun (x : R) => Membership.Mem.{u2, u3} R S (SetLike.hasMem.{u3, u2} S R _inst_1) x (A i)))))) x)
-but is expected to have type
-  forall {ι : Type.{u1}} {R : Type.{u3}} {S : Type.{u2}} [_inst_1 : SetLike.{u2, u3} S R] {A : ι -> S} {i : ι} (x : Subtype.{succ u3} R (fun (x : R) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) x (A i))), SetLike.Homogeneous.{u1, u3, u2} ι R S _inst_1 A (Subtype.val.{succ u3} R (fun (x : R) => Membership.mem.{u3, u3} R (Set.{u3} R) (Set.instMembershipSet.{u3} R) x (SetLike.coe.{u2, u3} S R _inst_1 (A i))) x)
-Case conversion may be inaccurate. Consider using '#align set_like.is_homogeneous_coe SetLike.homogeneous_coeₓ'. -/
 @[simp]
 theorem SetLike.homogeneous_coe {A : ι → S} {i} (x : A i) : SetLike.Homogeneous A (x : R) :=
   ⟨i, x.Prop⟩
 #align set_like.is_homogeneous_coe SetLike.homogeneous_coe
 
-/- warning: set_like.is_homogeneous_one -> SetLike.homogeneous_one is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {R : Type.{u2}} {S : Type.{u3}} [_inst_1 : SetLike.{u3, u2} S R] [_inst_2 : Zero.{u1} ι] [_inst_3 : One.{u2} R] (A : ι -> S) [_inst_4 : SetLike.GradedOne.{u1, u2, u3} ι R S _inst_1 _inst_3 _inst_2 A], SetLike.Homogeneous.{u1, u2, u3} ι R S _inst_1 A (OfNat.ofNat.{u2} R 1 (OfNat.mk.{u2} R 1 (One.one.{u2} R _inst_3)))
-but is expected to have type
-  forall {ι : Type.{u3}} {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : SetLike.{u1, u2} S R] [_inst_2 : Zero.{u3} ι] [_inst_3 : One.{u2} R] (A : ι -> S) [_inst_4 : SetLike.GradedOne.{u3, u2, u1} ι R S _inst_1 _inst_3 _inst_2 A], SetLike.Homogeneous.{u3, u2, u1} ι R S _inst_1 A (OfNat.ofNat.{u2} R 1 (One.toOfNat1.{u2} R _inst_3))
-Case conversion may be inaccurate. Consider using '#align set_like.is_homogeneous_one SetLike.homogeneous_oneₓ'. -/
 theorem SetLike.homogeneous_one [Zero ι] [One R] (A : ι → S) [SetLike.GradedOne A] :
     SetLike.Homogeneous A (1 : R) :=
   ⟨0, SetLike.one_mem_graded _⟩
 #align set_like.is_homogeneous_one SetLike.homogeneous_one
 
-/- warning: set_like.is_homogeneous.mul -> SetLike.homogeneous_mul is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {R : Type.{u2}} {S : Type.{u3}} [_inst_1 : SetLike.{u3, u2} S R] [_inst_2 : Add.{u1} ι] [_inst_3 : Mul.{u2} R] {A : ι -> S} [_inst_4 : SetLike.GradedMul.{u1, u2, u3} ι R S _inst_1 _inst_3 _inst_2 A] {a : R} {b : R}, (SetLike.Homogeneous.{u1, u2, u3} ι R S _inst_1 A a) -> (SetLike.Homogeneous.{u1, u2, u3} ι R S _inst_1 A b) -> (SetLike.Homogeneous.{u1, u2, u3} ι R S _inst_1 A (HMul.hMul.{u2, u2, u2} R R R (instHMul.{u2} R _inst_3) a b))
-but is expected to have type
-  forall {ι : Type.{u3}} {R : Type.{u2}} {S : Type.{u1}} [_inst_1 : SetLike.{u1, u2} S R] [_inst_2 : Add.{u3} ι] [_inst_3 : Mul.{u2} R] {A : ι -> S} [_inst_4 : SetLike.GradedMul.{u3, u2, u1} ι R S _inst_1 _inst_3 _inst_2 A] {a : R} {b : R}, (SetLike.Homogeneous.{u3, u2, u1} ι R S _inst_1 A a) -> (SetLike.Homogeneous.{u3, u2, u1} ι R S _inst_1 A b) -> (SetLike.Homogeneous.{u3, u2, u1} ι R S _inst_1 A (HMul.hMul.{u2, u2, u2} R R R (instHMul.{u2} R _inst_3) a b))
-Case conversion may be inaccurate. Consider using '#align set_like.is_homogeneous.mul SetLike.homogeneous_mulₓ'. -/
 theorem SetLike.homogeneous_mul [Add ι] [Mul R] {A : ι → S} [SetLike.GradedMul A] {a b : R} :
     SetLike.Homogeneous A a → SetLike.Homogeneous A b → SetLike.Homogeneous A (a * b)
   | ⟨i, hi⟩, ⟨j, hj⟩ => ⟨i + j, SetLike.mul_mem_graded hi hj⟩

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

@@ -558,8 +558,7 @@ theorem GradedMonoid.mk_list_dProd (l : List α) (fι : α → ι) (fA : ∀ a,
     GradedMonoid.mk _ (l.dProd fι fA) = (l.map fun a => GradedMonoid.mk (fι a) (fA a)).Prod :=
   by
   induction l
-  · simp
-    rfl
+  · simp; rfl
   · simp [← l_ih, GradedMonoid.mk_mul_mk, List.prod_cons]
     rfl
 #align graded_monoid.mk_list_dprod GradedMonoid.mk_list_dProd
@@ -649,10 +648,8 @@ theorem List.dProd_monoid {α} [AddMonoid ι] [Monoid R] (l : List α) (fι : α
     (l.dProd fι fA : (fun i : ι => R) _) = ((l.map fA).Prod : _) :=
   by
   induction l
-  · rw [List.dProd_nil, List.map_nil, List.prod_nil]
-    rfl
-  · rw [List.dProd_cons, List.map_cons, List.prod_cons, l_ih]
-    rfl
+  · rw [List.dProd_nil, List.map_nil, List.prod_nil]; rfl
+  · rw [List.dProd_cons, List.map_cons, List.prod_cons, l_ih]; rfl
 #align list.dprod_monoid List.dProd_monoid
 
 end
@@ -745,10 +742,8 @@ Case conversion may be inaccurate. Consider using '#align set_like.pow_mem_grade
 theorem pow_mem_graded (n : ℕ) {r : R} {i : ι} (h : r ∈ A i) : r ^ n ∈ A (n • i) :=
   by
   induction n
-  · rw [pow_zero, zero_nsmul]
-    exact one_mem_graded _
-  · rw [pow_succ', succ_nsmul']
-    exact mul_mem_graded n_ih h
+  · rw [pow_zero, zero_nsmul]; exact one_mem_graded _
+  · rw [pow_succ', succ_nsmul']; exact mul_mem_graded n_ih h
 #align set_like.pow_mem_graded SetLike.pow_mem_graded
 
 /- warning: set_like.list_prod_map_mem_graded -> SetLike.list_prod_map_mem_graded is a dubious translation:

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

@@ -846,10 +846,7 @@ theorem SetLike.coe_list_dProd (A : ι → S) [SetLike.GradedMonoid A] (fι : α
 include R
 
 /- warning: set_like.list_dprod_eq -> SetLike.list_dProd_eq is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {R : Type.{u2}} {α : Type.{u3}} {S : Type.{u4}} [_inst_1 : SetLike.{u4, u2} S R] [_inst_2 : Monoid.{u2} R] [_inst_3 : AddMonoid.{u1} ι] (A : ι -> S) [_inst_4 : SetLike.GradedMonoid.{u1, u2, u4} ι R S _inst_1 _inst_2 _inst_3 A] (fι : α -> ι) (fA : forall (a : α), coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) (l : List.{u3} α), Eq.{succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (List.dProdIndex.{u1, u3} ι α _inst_3 l fι))) (List.dProd.{u1, u3, u2} ι α (fun (i : ι) => coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A i)) _inst_3 (SetLike.gMonoid.{u1, u2, u4} ι R S _inst_1 _inst_2 _inst_3 (fun (i : ι) => A i) _inst_4) l fι fA) (Subtype.mk.{succ u2} R (fun (x : R) => Membership.Mem.{u2, u4} R S (SetLike.hasMem.{u4, u2} S R _inst_1) x (A (List.dProdIndex.{u1, u3} ι α _inst_3 l fι))) (List.prod.{u2} R (MulOneClass.toHasMul.{u2} R (Monoid.toMulOneClass.{u2} R _inst_2)) (MulOneClass.toHasOne.{u2} R (Monoid.toMulOneClass.{u2} R _inst_2)) (List.map.{u3, u2} α R (fun (a : α) => (fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (coeBase.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (coeSubtype.{succ u2} R (fun (x : R) => Membership.Mem.{u2, u4} R S (SetLike.hasMem.{u4, u2} S R _inst_1) x (A (fι a))))))) (fA a)) l)) (Eq.subst.{succ u1} ι (fun (_x : ι) => Membership.Mem.{u2, u4} R S (SetLike.hasMem.{u4, u2} S R _inst_1) (List.prod.{u2} R (MulOneClass.toHasMul.{u2} R (Monoid.toMulOneClass.{u2} R _inst_2)) (MulOneClass.toHasOne.{u2} R (Monoid.toMulOneClass.{u2} R _inst_2)) (List.map.{u3, u2} α R (fun (a : α) => (fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (coeBase.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (coeSubtype.{succ u2} R (fun (x : R) => Membership.Mem.{u2, u4} R S (SetLike.hasMem.{u4, u2} S R _inst_1) x (A (fι a))))))) (fA a)) l)) (A _x)) (List.sum.{u1} ι (AddZeroClass.toHasAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_3)) (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_3)) (List.map.{u3, u1} α ι fι l)) (List.dProdIndex.{u1, u3} ι α _inst_3 l fι) (Eq.symm.{succ u1} ι (List.dProdIndex.{u1, u3} ι α _inst_3 l fι) (List.sum.{u1} ι (AddZeroClass.toHasAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_3)) (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_3)) (List.map.{u3, u1} α ι fι l)) (List.dProdIndex_eq_map_sum.{u1, u3} ι α _inst_3 l fι)) (SetLike.list_prod_map_mem_graded.{u1, u2, u4, u3} ι R S _inst_1 _inst_2 _inst_3 A _inst_4 α l fι (fun (a : α) => (fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (coeBase.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (coeSubtype.{succ u2} R (fun (x : R) => Membership.Mem.{u2, u4} R S (SetLike.hasMem.{u4, u2} S R _inst_1) x (A (fι a))))))) (fA a)) (fun (i : α) (hi : Membership.Mem.{u3, u3} α (List.{u3} α) (List.hasMem.{u3} α) i l) => Subtype.prop.{succ u2} R (fun (x : R) => Membership.Mem.{u2, u4} R S (SetLike.hasMem.{u4, u2} S R _inst_1) x (A (fι i))) (fA i)))))
-but is expected to have type
-  forall {ι : Type.{u4}} {R : Type.{u3}} {α : Type.{u1}} {S : Type.{u2}} [_inst_1 : SetLike.{u2, u3} S R] [_inst_2 : Monoid.{u3} R] [_inst_3 : AddMonoid.{u4} ι] (A : ι -> S) [_inst_4 : SetLike.GradedMonoid.{u4, u3, u2} ι R S _inst_1 _inst_2 _inst_3 A] (fι : α -> ι) (fA : forall (a : α), Subtype.{succ u3} R (fun (x : R) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) x (A (fι a)))) (l : List.{u1} α), Eq.{succ u3} (Subtype.{succ u3} R (fun (x : R) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) x (A (List.dProdIndex.{u4, u1} ι α _inst_3 l fι)))) (List.dProd.{u4, u1, u3} ι α (fun (i : ι) => Subtype.{succ u3} R (fun (x : R) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) x (A i))) _inst_3 (SetLike.gMonoid.{u4, u3, u2} ι R S _inst_1 _inst_2 _inst_3 (fun (i : ι) => A i) _inst_4) l fι fA) (Subtype.mk.{succ u3} R (fun (x : R) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) x (A (List.dProdIndex.{u4, u1} ι α _inst_3 l fι))) (List.prod.{u3} R (MulOneClass.toMul.{u3} R (Monoid.toMulOneClass.{u3} R _inst_2)) (Monoid.toOne.{u3} R _inst_2) (List.map.{u1, u3} α R (fun (a : α) => Subtype.val.{succ u3} R (fun (x : R) => Membership.mem.{u3, u3} R (Set.{u3} R) (Set.instMembershipSet.{u3} R) x (SetLike.coe.{u2, u3} S R _inst_1 (A (fι a)))) (fA a)) l)) (Eq.rec.{0, succ u4} ι (List.sum.{u4} ι (AddZeroClass.toAdd.{u4} ι (AddMonoid.toAddZeroClass.{u4} ι _inst_3)) (AddMonoid.toZero.{u4} ι _inst_3) (List.map.{u1, u4} α ι fι l)) (fun (x._@.Mathlib.Algebra.GradedMonoid._hyg.4834 : ι) (h._@.Mathlib.Algebra.GradedMonoid._hyg.4835 : Eq.{succ u4} ι (List.sum.{u4} ι (AddZeroClass.toAdd.{u4} ι (AddMonoid.toAddZeroClass.{u4} ι _inst_3)) (AddMonoid.toZero.{u4} ι _inst_3) (List.map.{u1, u4} α ι fι l)) x._@.Mathlib.Algebra.GradedMonoid._hyg.4834) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) (List.prod.{u3} R (MulOneClass.toMul.{u3} R (Monoid.toMulOneClass.{u3} R _inst_2)) (Monoid.toOne.{u3} R _inst_2) (List.map.{u1, u3} α R (fun (a : α) => Subtype.val.{succ u3} R (fun (x : R) => Membership.mem.{u3, u3} R (Set.{u3} R) (Set.instMembershipSet.{u3} R) x (SetLike.coe.{u2, u3} S R _inst_1 (A (fι a)))) (fA a)) l)) (A x._@.Mathlib.Algebra.GradedMonoid._hyg.4834)) (SetLike.list_prod_map_mem_graded.{u4, u2, u3, u1} ι R S _inst_1 _inst_2 _inst_3 A _inst_4 α l fι (fun (a : α) => Subtype.val.{succ u3} R (fun (x : R) => Membership.mem.{u3, u3} R (Set.{u3} R) (Set.instMembershipSet.{u3} R) x (SetLike.coe.{u2, u3} S R _inst_1 (A (fι a)))) (fA a)) (fun (i : α) (x._@.Mathlib.Algebra.GradedMonoid._hyg.4827 : Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) i l) => Subtype.prop.{succ u3} R (fun (x : R) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) x (A (fι i))) (fA i))) (List.dProdIndex.{u4, u1} ι α _inst_3 l fι) (Eq.symm.{succ u4} ι (List.dProdIndex.{u4, u1} ι α _inst_3 l fι) (List.sum.{u4} ι (AddZeroClass.toAdd.{u4} ι (AddMonoid.toAddZeroClass.{u4} ι _inst_3)) (AddMonoid.toZero.{u4} ι _inst_3) (List.map.{u1, u4} α ι fι l)) (List.dProdIndex_eq_map_sum.{u4, u1} ι α _inst_3 l fι))))
+<too large>
 Case conversion may be inaccurate. Consider using '#align set_like.list_dprod_eq SetLike.list_dProd_eqₓ'. -/
 /-- A version of `list.coe_dprod_set_like` with `subtype.mk`. -/
 theorem SetLike.list_dProd_eq (A : ι → S) [SetLike.GradedMonoid A] (fι : α → ι) (fA : ∀ a, A (fι a))

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

@@ -849,7 +849,7 @@ include R
 lean 3 declaration is
   forall {ι : Type.{u1}} {R : Type.{u2}} {α : Type.{u3}} {S : Type.{u4}} [_inst_1 : SetLike.{u4, u2} S R] [_inst_2 : Monoid.{u2} R] [_inst_3 : AddMonoid.{u1} ι] (A : ι -> S) [_inst_4 : SetLike.GradedMonoid.{u1, u2, u4} ι R S _inst_1 _inst_2 _inst_3 A] (fι : α -> ι) (fA : forall (a : α), coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) (l : List.{u3} α), Eq.{succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (List.dProdIndex.{u1, u3} ι α _inst_3 l fι))) (List.dProd.{u1, u3, u2} ι α (fun (i : ι) => coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A i)) _inst_3 (SetLike.gMonoid.{u1, u2, u4} ι R S _inst_1 _inst_2 _inst_3 (fun (i : ι) => A i) _inst_4) l fι fA) (Subtype.mk.{succ u2} R (fun (x : R) => Membership.Mem.{u2, u4} R S (SetLike.hasMem.{u4, u2} S R _inst_1) x (A (List.dProdIndex.{u1, u3} ι α _inst_3 l fι))) (List.prod.{u2} R (MulOneClass.toHasMul.{u2} R (Monoid.toMulOneClass.{u2} R _inst_2)) (MulOneClass.toHasOne.{u2} R (Monoid.toMulOneClass.{u2} R _inst_2)) (List.map.{u3, u2} α R (fun (a : α) => (fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (coeBase.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (coeSubtype.{succ u2} R (fun (x : R) => Membership.Mem.{u2, u4} R S (SetLike.hasMem.{u4, u2} S R _inst_1) x (A (fι a))))))) (fA a)) l)) (Eq.subst.{succ u1} ι (fun (_x : ι) => Membership.Mem.{u2, u4} R S (SetLike.hasMem.{u4, u2} S R _inst_1) (List.prod.{u2} R (MulOneClass.toHasMul.{u2} R (Monoid.toMulOneClass.{u2} R _inst_2)) (MulOneClass.toHasOne.{u2} R (Monoid.toMulOneClass.{u2} R _inst_2)) (List.map.{u3, u2} α R (fun (a : α) => (fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (coeBase.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (coeSubtype.{succ u2} R (fun (x : R) => Membership.Mem.{u2, u4} R S (SetLike.hasMem.{u4, u2} S R _inst_1) x (A (fι a))))))) (fA a)) l)) (A _x)) (List.sum.{u1} ι (AddZeroClass.toHasAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_3)) (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_3)) (List.map.{u3, u1} α ι fι l)) (List.dProdIndex.{u1, u3} ι α _inst_3 l fι) (Eq.symm.{succ u1} ι (List.dProdIndex.{u1, u3} ι α _inst_3 l fι) (List.sum.{u1} ι (AddZeroClass.toHasAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_3)) (AddZeroClass.toHasZero.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_3)) (List.map.{u3, u1} α ι fι l)) (List.dProdIndex_eq_map_sum.{u1, u3} ι α _inst_3 l fι)) (SetLike.list_prod_map_mem_graded.{u1, u2, u4, u3} ι R S _inst_1 _inst_2 _inst_3 A _inst_4 α l fι (fun (a : α) => (fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (coeBase.{succ u2, succ u2} (coeSort.{succ u4, succ (succ u2)} S Type.{u2} (SetLike.hasCoeToSort.{u4, u2} S R _inst_1) (A (fι a))) R (coeSubtype.{succ u2} R (fun (x : R) => Membership.Mem.{u2, u4} R S (SetLike.hasMem.{u4, u2} S R _inst_1) x (A (fι a))))))) (fA a)) (fun (i : α) (hi : Membership.Mem.{u3, u3} α (List.{u3} α) (List.hasMem.{u3} α) i l) => Subtype.prop.{succ u2} R (fun (x : R) => Membership.Mem.{u2, u4} R S (SetLike.hasMem.{u4, u2} S R _inst_1) x (A (fι i))) (fA i)))))
 but is expected to have type
-  forall {ι : Type.{u4}} {R : Type.{u3}} {α : Type.{u1}} {S : Type.{u2}} [_inst_1 : SetLike.{u2, u3} S R] [_inst_2 : Monoid.{u3} R] [_inst_3 : AddMonoid.{u4} ι] (A : ι -> S) [_inst_4 : SetLike.GradedMonoid.{u4, u3, u2} ι R S _inst_1 _inst_2 _inst_3 A] (fι : α -> ι) (fA : forall (a : α), Subtype.{succ u3} R (fun (x : R) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) x (A (fι a)))) (l : List.{u1} α), Eq.{succ u3} (Subtype.{succ u3} R (fun (x : R) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) x (A (List.dProdIndex.{u4, u1} ι α _inst_3 l fι)))) (List.dProd.{u4, u1, u3} ι α (fun (i : ι) => Subtype.{succ u3} R (fun (x : R) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) x (A i))) _inst_3 (SetLike.gMonoid.{u4, u3, u2} ι R S _inst_1 _inst_2 _inst_3 (fun (i : ι) => A i) _inst_4) l fι fA) (Subtype.mk.{succ u3} R (fun (x : R) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) x (A (List.dProdIndex.{u4, u1} ι α _inst_3 l fι))) (List.prod.{u3} R (MulOneClass.toMul.{u3} R (Monoid.toMulOneClass.{u3} R _inst_2)) (Monoid.toOne.{u3} R _inst_2) (List.map.{u1, u3} α R (fun (a : α) => Subtype.val.{succ u3} R (fun (x : R) => Membership.mem.{u3, u3} R (Set.{u3} R) (Set.instMembershipSet.{u3} R) x (SetLike.coe.{u2, u3} S R _inst_1 (A (fι a)))) (fA a)) l)) (Eq.rec.{0, succ u4} ι (List.sum.{u4} ι (AddZeroClass.toAdd.{u4} ι (AddMonoid.toAddZeroClass.{u4} ι _inst_3)) (AddMonoid.toZero.{u4} ι _inst_3) (List.map.{u1, u4} α ι fι l)) (fun (x._@.Mathlib.Algebra.GradedMonoid._hyg.4836 : ι) (h._@.Mathlib.Algebra.GradedMonoid._hyg.4837 : Eq.{succ u4} ι (List.sum.{u4} ι (AddZeroClass.toAdd.{u4} ι (AddMonoid.toAddZeroClass.{u4} ι _inst_3)) (AddMonoid.toZero.{u4} ι _inst_3) (List.map.{u1, u4} α ι fι l)) x._@.Mathlib.Algebra.GradedMonoid._hyg.4836) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) (List.prod.{u3} R (MulOneClass.toMul.{u3} R (Monoid.toMulOneClass.{u3} R _inst_2)) (Monoid.toOne.{u3} R _inst_2) (List.map.{u1, u3} α R (fun (a : α) => Subtype.val.{succ u3} R (fun (x : R) => Membership.mem.{u3, u3} R (Set.{u3} R) (Set.instMembershipSet.{u3} R) x (SetLike.coe.{u2, u3} S R _inst_1 (A (fι a)))) (fA a)) l)) (A x._@.Mathlib.Algebra.GradedMonoid._hyg.4836)) (SetLike.list_prod_map_mem_graded.{u4, u2, u3, u1} ι R S _inst_1 _inst_2 _inst_3 A _inst_4 α l fι (fun (a : α) => Subtype.val.{succ u3} R (fun (x : R) => Membership.mem.{u3, u3} R (Set.{u3} R) (Set.instMembershipSet.{u3} R) x (SetLike.coe.{u2, u3} S R _inst_1 (A (fι a)))) (fA a)) (fun (i : α) (x._@.Mathlib.Algebra.GradedMonoid._hyg.4829 : Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) i l) => Subtype.prop.{succ u3} R (fun (x : R) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) x (A (fι i))) (fA i))) (List.dProdIndex.{u4, u1} ι α _inst_3 l fι) (Eq.symm.{succ u4} ι (List.dProdIndex.{u4, u1} ι α _inst_3 l fι) (List.sum.{u4} ι (AddZeroClass.toAdd.{u4} ι (AddMonoid.toAddZeroClass.{u4} ι _inst_3)) (AddMonoid.toZero.{u4} ι _inst_3) (List.map.{u1, u4} α ι fι l)) (List.dProdIndex_eq_map_sum.{u4, u1} ι α _inst_3 l fι))))
+  forall {ι : Type.{u4}} {R : Type.{u3}} {α : Type.{u1}} {S : Type.{u2}} [_inst_1 : SetLike.{u2, u3} S R] [_inst_2 : Monoid.{u3} R] [_inst_3 : AddMonoid.{u4} ι] (A : ι -> S) [_inst_4 : SetLike.GradedMonoid.{u4, u3, u2} ι R S _inst_1 _inst_2 _inst_3 A] (fι : α -> ι) (fA : forall (a : α), Subtype.{succ u3} R (fun (x : R) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) x (A (fι a)))) (l : List.{u1} α), Eq.{succ u3} (Subtype.{succ u3} R (fun (x : R) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) x (A (List.dProdIndex.{u4, u1} ι α _inst_3 l fι)))) (List.dProd.{u4, u1, u3} ι α (fun (i : ι) => Subtype.{succ u3} R (fun (x : R) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) x (A i))) _inst_3 (SetLike.gMonoid.{u4, u3, u2} ι R S _inst_1 _inst_2 _inst_3 (fun (i : ι) => A i) _inst_4) l fι fA) (Subtype.mk.{succ u3} R (fun (x : R) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) x (A (List.dProdIndex.{u4, u1} ι α _inst_3 l fι))) (List.prod.{u3} R (MulOneClass.toMul.{u3} R (Monoid.toMulOneClass.{u3} R _inst_2)) (Monoid.toOne.{u3} R _inst_2) (List.map.{u1, u3} α R (fun (a : α) => Subtype.val.{succ u3} R (fun (x : R) => Membership.mem.{u3, u3} R (Set.{u3} R) (Set.instMembershipSet.{u3} R) x (SetLike.coe.{u2, u3} S R _inst_1 (A (fι a)))) (fA a)) l)) (Eq.rec.{0, succ u4} ι (List.sum.{u4} ι (AddZeroClass.toAdd.{u4} ι (AddMonoid.toAddZeroClass.{u4} ι _inst_3)) (AddMonoid.toZero.{u4} ι _inst_3) (List.map.{u1, u4} α ι fι l)) (fun (x._@.Mathlib.Algebra.GradedMonoid._hyg.4834 : ι) (h._@.Mathlib.Algebra.GradedMonoid._hyg.4835 : Eq.{succ u4} ι (List.sum.{u4} ι (AddZeroClass.toAdd.{u4} ι (AddMonoid.toAddZeroClass.{u4} ι _inst_3)) (AddMonoid.toZero.{u4} ι _inst_3) (List.map.{u1, u4} α ι fι l)) x._@.Mathlib.Algebra.GradedMonoid._hyg.4834) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) (List.prod.{u3} R (MulOneClass.toMul.{u3} R (Monoid.toMulOneClass.{u3} R _inst_2)) (Monoid.toOne.{u3} R _inst_2) (List.map.{u1, u3} α R (fun (a : α) => Subtype.val.{succ u3} R (fun (x : R) => Membership.mem.{u3, u3} R (Set.{u3} R) (Set.instMembershipSet.{u3} R) x (SetLike.coe.{u2, u3} S R _inst_1 (A (fι a)))) (fA a)) l)) (A x._@.Mathlib.Algebra.GradedMonoid._hyg.4834)) (SetLike.list_prod_map_mem_graded.{u4, u2, u3, u1} ι R S _inst_1 _inst_2 _inst_3 A _inst_4 α l fι (fun (a : α) => Subtype.val.{succ u3} R (fun (x : R) => Membership.mem.{u3, u3} R (Set.{u3} R) (Set.instMembershipSet.{u3} R) x (SetLike.coe.{u2, u3} S R _inst_1 (A (fι a)))) (fA a)) (fun (i : α) (x._@.Mathlib.Algebra.GradedMonoid._hyg.4827 : Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) i l) => Subtype.prop.{succ u3} R (fun (x : R) => Membership.mem.{u3, u2} R S (SetLike.instMembership.{u2, u3} S R _inst_1) x (A (fι i))) (fA i))) (List.dProdIndex.{u4, u1} ι α _inst_3 l fι) (Eq.symm.{succ u4} ι (List.dProdIndex.{u4, u1} ι α _inst_3 l fι) (List.sum.{u4} ι (AddZeroClass.toAdd.{u4} ι (AddMonoid.toAddZeroClass.{u4} ι _inst_3)) (AddMonoid.toZero.{u4} ι _inst_3) (List.map.{u1, u4} α ι fι l)) (List.dProdIndex_eq_map_sum.{u4, u1} ι α _inst_3 l fι))))
 Case conversion may be inaccurate. Consider using '#align set_like.list_dprod_eq SetLike.list_dProd_eqₓ'. -/
 /-- A version of `list.coe_dprod_set_like` with `subtype.mk`. -/
 theorem SetLike.list_dProd_eq (A : ι → S) [SetLike.GradedMonoid A] (fι : α → ι) (fA : ∀ a, A (fι a))

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

@@ -193,7 +193,7 @@ theorem gnpowRec_zero (a : GradedMonoid A) : GradedMonoid.mk _ (gnpowRec 0 a.snd
   Sigma.ext (zero_nsmul _) (heq_of_cast_eq _ rfl).symm
 #align graded_monoid.gmonoid.gnpow_rec_zero GradedMonoid.GMonoid.gnpowRec_zero
 
-/- ./././Mathport/Syntax/Translate/Expr.lean:334:4: warning: unsupported (TODO): `[tacs] -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:330:4: warning: unsupported (TODO): `[tacs] -/
 /-- Tactic used to autofill `graded_monoid.gmonoid.gnpow_zero'` when the default
 `graded_monoid.gmonoid.gnpow_rec` is used. -/
 unsafe def apply_gnpow_rec_zero_tac : tactic Unit :=
@@ -212,7 +212,7 @@ theorem gnpowRec_succ (n : ℕ) (a : GradedMonoid A) :
   Sigma.ext (succ_nsmul _ _) (heq_of_cast_eq _ rfl).symm
 #align graded_monoid.gmonoid.gnpow_rec_succ GradedMonoid.GMonoid.gnpowRec_succ
 
-/- ./././Mathport/Syntax/Translate/Expr.lean:334:4: warning: unsupported (TODO): `[tacs] -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:330:4: warning: unsupported (TODO): `[tacs] -/
 /-- Tactic used to autofill `graded_monoid.gmonoid.gnpow_succ'` when the default
 `graded_monoid.gmonoid.gnpow_rec` is used. -/
 unsafe def apply_gnpow_rec_succ_tac : tactic Unit :=
@@ -222,8 +222,8 @@ unsafe def apply_gnpow_rec_succ_tac : tactic Unit :=
 end Gmonoid
 
 #print GradedMonoid.GMonoid /-
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic gmonoid.apply_gnpow_rec_zero_tac -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic gmonoid.apply_gnpow_rec_succ_tac -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic gmonoid.apply_gnpow_rec_zero_tac -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic gmonoid.apply_gnpow_rec_succ_tac -/
 /-- A graded version of `monoid`.
 
 Like `monoid.npow`, this has an optional `gmonoid.gnpow` field to allow definitional control of

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

This is algebra and should be foldered as such.

@@ -3,8 +3,8 @@ Copyright (c) 2021 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
 -/
+import Mathlib.Algebra.BigOperators.List.Basic
 import Mathlib.Algebra.Group.InjSurj
-import Mathlib.Data.List.BigOperators.Basic
 import Mathlib.Data.List.FinRange
 import Mathlib.GroupTheory.GroupAction.Defs
 import Mathlib.GroupTheory.Submonoid.Basic

We change the following field in the definition of an additive commutative monoid:

 nsmul_succ : ∀ (n : ℕ) (x : G),
-  AddMonoid.nsmul (n + 1) x = x + AddMonoid.nsmul n x
+  AddMonoid.nsmul (n + 1) x = AddMonoid.nsmul n x + x

where the latter is more natural

We adjust the definitions of ^ in monoids, groups, etc. Originally there was a warning comment about why this natural order was preferred

use x * npowRec n x and not npowRec n x * x in the definition to make sure that definitional unfolding of npowRec is blocked, to avoid deep recursion issues.

but it seems to no longer apply.

Remarks on the PR :

• pow_succ and pow_succ' have switched their meanings.
• Most of the time, the proofs were adjusted by priming/unpriming one lemma, or exchanging left and right; a few proofs were more complicated to adjust.
• In particular, [Mathlib/NumberTheory/RamificationInertia.lean] used Ideal.IsPrime.mul_mem_pow which is defined in [Mathlib/RingTheory/DedekindDomain/Ideal.lean]. Changing the order of operation forced me to add the symmetric lemma Ideal.IsPrime.mem_pow_mul.
• the docstring for Cauchy condensation test in [Mathlib/Analysis/PSeries.lean] was mathematically incorrect, I added the mention that the function is antitone.

@@ -197,7 +197,7 @@ variable {A} [AddMonoid ι] [GMul A] [GOne A]
 `GMonoid.gnpow` should be used instead. -/
 def gnpowRec : ∀ (n : ℕ) {i}, A i → A (n • i)
   | 0, i, _ => cast (congr_arg A (zero_nsmul i).symm) GOne.one
-  | n + 1, i, a => cast (congr_arg A (succ_nsmul i n).symm) (GMul.mul a <| gnpowRec _ a)
+  | n + 1, i, a => cast (congr_arg A (succ_nsmul i n).symm) (GMul.mul (gnpowRec _ a) a)
 #align graded_monoid.gmonoid.gnpow_rec GradedMonoid.GMonoid.gnpowRec
 
 @[simp]
@@ -207,7 +207,7 @@ theorem gnpowRec_zero (a : GradedMonoid A) : GradedMonoid.mk _ (gnpowRec 0 a.snd
 
 @[simp]
 theorem gnpowRec_succ (n : ℕ) (a : GradedMonoid A) :
-    (GradedMonoid.mk _ <| gnpowRec n.succ a.snd) = a * ⟨_, gnpowRec n a.snd⟩ :=
+    (GradedMonoid.mk _ <| gnpowRec n.succ a.snd) = ⟨_, gnpowRec n a.snd⟩ * a :=
   Sigma.ext (succ_nsmul _ _) (heq_of_cast_eq _ rfl).symm
 #align graded_monoid.gmonoid.gnpow_rec_succ GradedMonoid.GMonoid.gnpowRec_succ
 
@@ -237,7 +237,7 @@ class GMonoid [AddMonoid ι] extends GMul A, GOne A where
   /-- Successor powers behave as expected -/
   gnpow_succ' :
     ∀ (n : ℕ) (a : GradedMonoid A),
-      (GradedMonoid.mk _ <| gnpow n.succ a.snd) = a * ⟨_, gnpow n a.snd⟩ := by
+      (GradedMonoid.mk _ <| gnpow n.succ a.snd) = ⟨_, gnpow n a.snd⟩ * a:= by
     apply_gmonoid_gnpowRec_succ_tac
 #align graded_monoid.gmonoid GradedMonoid.GMonoid
 
@@ -602,7 +602,7 @@ theorem pow_mem_graded (n : ℕ) {r : R} {i : ι} (h : r ∈ A i) : r ^ n ∈ A
     exact one_mem_graded _
   | n+1 =>
     rw [pow_succ', succ_nsmul']
-    exact mul_mem_graded (pow_mem_graded n h) h
+    exact mul_mem_graded h (pow_mem_graded n h)
 #align set_like.pow_mem_graded SetLike.pow_mem_graded
 
 theorem list_prod_map_mem_graded {ι'} (l : List ι') (i : ι' → ι) (r : ι' → R)

After the (d)simp and rw tactics - hints to find further occurrences welcome.

zulip discussion

Co-authored-by: @sven-manthe

@@ -448,7 +448,7 @@ theorem GradedMonoid.mk_list_dProd (l : List α) (fι : α → ι) (fA : ∀ a,
   match l with
   | [] => simp only [List.dProdIndex_nil, List.dProd_nil, List.map_nil, List.prod_nil]; rfl
   | head::tail =>
-    simp[← GradedMonoid.mk_list_dProd tail _ _, GradedMonoid.mk_mul_mk, List.prod_cons]
+    simp [← GradedMonoid.mk_list_dProd tail _ _, GradedMonoid.mk_mul_mk, List.prod_cons]
 #align graded_monoid.mk_list_dprod GradedMonoid.mk_list_dProd
 
 /-- A variant of `GradedMonoid.mk_list_dProd` for rewriting in the other direction. -/

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

@@ -593,7 +593,6 @@ class SetLike.GradedMonoid {S : Type*} [SetLike S R] [Monoid R] [AddMonoid ι] (
 namespace SetLike
 
 variable {S : Type*} [SetLike S R] [Monoid R] [AddMonoid ι]
-
 variable {A : ι → S} [SetLike.GradedMonoid A]
 
 theorem pow_mem_graded (n : ℕ) {r : R} {i : ι} (h : r ∈ A i) : r ^ n ∈ A (n • i) := by

This PR accompanies #11246, squeezing some non-terminal simps highlighted by the linter until I decided to stop!

@@ -446,7 +446,7 @@ theorem List.dProd_cons (fι : α → ι) (fA : ∀ a, A (fι a)) (a : α) (l :
 theorem GradedMonoid.mk_list_dProd (l : List α) (fι : α → ι) (fA : ∀ a, A (fι a)) :
     GradedMonoid.mk _ (l.dProd fι fA) = (l.map fun a => GradedMonoid.mk (fι a) (fA a)).prod := by
   match l with
-  | [] => simp; rfl
+  | [] => simp only [List.dProdIndex_nil, List.dProd_nil, List.map_nil, List.prod_nil]; rfl
   | head::tail =>
     simp[← GradedMonoid.mk_list_dProd tail _ _, GradedMonoid.mk_mul_mk, List.prod_cons]
 #align graded_monoid.mk_list_dprod GradedMonoid.mk_list_dProd

Fix 1 typo, 5 lowercase, 4 header depths

@@ -86,7 +86,7 @@ This file also defines:
 * `SetLike.homogeneousSubmonoid A`, which is, as the name suggests, the submonoid consisting of
   all the homogeneous elements.
 
-## tags
+## Tags
 
 graded monoid
 -/

Subset of #9319

@@ -616,7 +616,7 @@ theorem list_prod_map_mem_graded {ι'} (l : List ι') (i : ι' → ι) (r : ι'
     rw [List.map_cons, List.map_cons, List.prod_cons, List.sum_cons]
     exact
       mul_mem_graded (h _ <| List.mem_cons_self _ _)
-        (list_prod_map_mem_graded tail _ _ <| fun j hj => h _ <| List.mem_cons_of_mem _ hj)
+        (list_prod_map_mem_graded tail _ _ fun j hj => h _ <| List.mem_cons_of_mem _ hj)
 #align set_like.list_prod_map_mem_graded SetLike.list_prod_map_mem_graded
 
 theorem list_prod_ofFn_mem_graded {n} (i : Fin n → ι) (r : Fin n → R) (h : ∀ j, r j ∈ A (i j)) :

@@ -112,26 +112,33 @@ def mk {A : ι → Type*} : ∀ i, A i → GradedMonoid A :=
 /-! ### Actions -/
 
 section actions
+variable {α β} {A : ι → Type*}
 
 /-- If `R` acts on each `A i`, then it acts on `GradedMonoid A` via the `.2` projection. -/
-instance {α} {A : ι → Type*} [∀ i, SMul α (A i)] : SMul α (GradedMonoid A) where
+instance [∀ i, SMul α (A i)] : SMul α (GradedMonoid A) where
   smul r g := GradedMonoid.mk g.1 (r • g.2)
 
-theorem smul_mk {α} {A : ι → Type*} [∀ i, SMul α (A i)] {i} (c : α) (a : A i) :
+@[simp] theorem fst_smul [∀ i, SMul α (A i)] (a : α) (x : GradedMonoid A) :
+    (a • x).fst = x.fst := rfl
+
+@[simp] theorem snd_smul [∀ i, SMul α (A i)] (a : α) (x : GradedMonoid A) :
+    (a • x).snd = a • x.snd := rfl
+
+theorem smul_mk [∀ i, SMul α (A i)] {i} (c : α) (a : A i) :
     c • mk i a = mk i (c • a) :=
   rfl
 
-instance {α β} {A : ι → Type*} [∀ i, SMul α (A i)] [∀ i, SMul β (A i)]
+instance [∀ i, SMul α (A i)] [∀ i, SMul β (A i)]
     [∀ i, SMulCommClass α β (A i)] :
     SMulCommClass α β (GradedMonoid A) where
   smul_comm a b g := Sigma.ext rfl <| heq_of_eq <| smul_comm a b g.2
 
-instance {α β} {A : ι → Type*} [SMul α β] [∀ i, SMul α (A i)] [∀ i, SMul β (A i)]
+instance [SMul α β] [∀ i, SMul α (A i)] [∀ i, SMul β (A i)]
     [∀ i, IsScalarTower α β (A i)] :
     IsScalarTower α β (GradedMonoid A) where
   smul_assoc a b g := Sigma.ext rfl <| heq_of_eq <| smul_assoc a b g.2
 
-instance {α} {A : ι → Type*} [Monoid α] [∀ i, MulAction α (A i)] :
+instance [Monoid α] [∀ i, MulAction α (A i)] :
     MulAction α (GradedMonoid A) where
   one_smul g := Sigma.ext rfl <| heq_of_eq <| one_smul _ g.2
   mul_smul r₁ r₂ g := Sigma.ext rfl <| heq_of_eq <| mul_smul r₁ r₂ g.2
@@ -155,6 +162,10 @@ instance GOne.toOne [Zero ι] [GOne A] : One (GradedMonoid A) :=
   ⟨⟨_, GOne.one⟩⟩
 #align graded_monoid.ghas_one.to_has_one GradedMonoid.GOne.toOne
 
+@[simp] theorem fst_one [Zero ι] [GOne A] : (1 : GradedMonoid A).fst = 0 := rfl
+
+@[simp] theorem snd_one [Zero ι] [GOne A] : (1 : GradedMonoid A).snd = GOne.one := rfl
+
 /-- A graded version of `Mul`. Multiplication combines grades additively, like
 `AddMonoidAlgebra`. -/
 class GMul [Add ι] where
@@ -167,6 +178,12 @@ instance GMul.toMul [Add ι] [GMul A] : Mul (GradedMonoid A) :=
   ⟨fun x y : GradedMonoid A => ⟨_, GMul.mul x.snd y.snd⟩⟩
 #align graded_monoid.ghas_mul.to_has_mul GradedMonoid.GMul.toMul
 
+@[simp] theorem fst_mul [Add ι] [GMul A] (x y : GradedMonoid A) :
+    (x * y).fst = x.fst + y.fst := rfl
+
+@[simp] theorem snd_mul [Add ι] [GMul A] (x y : GradedMonoid A) :
+    (x * y).snd = GMul.mul x.snd y.snd := rfl
+
 theorem mk_mul_mk [Add ι] [GMul A] {i j} (a : A i) (b : A j) :
     mk i a * mk j b = mk (i + j) (GMul.mul a b) :=
   rfl
@@ -225,8 +242,7 @@ class GMonoid [AddMonoid ι] extends GMul A, GOne A where
 #align graded_monoid.gmonoid GradedMonoid.GMonoid
 
 /-- `GMonoid` implies a `Monoid (GradedMonoid A)`. -/
-instance GMonoid.toMonoid [AddMonoid ι] [GMonoid A] : Monoid (GradedMonoid A)
-    where
+instance GMonoid.toMonoid [AddMonoid ι] [GMonoid A] : Monoid (GradedMonoid A) where
   one := 1
   mul := (· * ·)
   npow n a := GradedMonoid.mk _ (GMonoid.gnpow n a.snd)
@@ -237,15 +253,14 @@ instance GMonoid.toMonoid [AddMonoid ι] [GMonoid A] : Monoid (GradedMonoid A)
   mul_assoc := GMonoid.mul_assoc
 #align graded_monoid.gmonoid.to_monoid GradedMonoid.GMonoid.toMonoid
 
+@[simp] theorem fst_pow [AddMonoid ι] [GMonoid A] (x : GradedMonoid A) (n : ℕ) :
+    (x ^ n).fst = n • x.fst := rfl
+
+@[simp] theorem snd_pow [AddMonoid ι] [GMonoid A] (x : GradedMonoid A) (n : ℕ) :
+    (x ^ n).snd = GMonoid.gnpow n x.snd := rfl
+
 theorem mk_pow [AddMonoid ι] [GMonoid A] {i} (a : A i) (n : ℕ) :
-    mk i a ^ n = mk (n • i) (GMonoid.gnpow _ a) := by
-  match n with
-  | 0 =>
-    rw [pow_zero]
-    exact (GMonoid.gnpow_zero' ⟨_, a⟩).symm
-  | n+1 =>
-    rw [pow_succ, mk_pow a n, mk_mul_mk]
-    exact (GMonoid.gnpow_succ' n ⟨_, a⟩).symm
+    mk i a ^ n = mk (n • i) (GMonoid.gnpow _ a) := rfl
 #align graded_monoid.mk_pow GradedMonoid.mk_pow
 
 /-- A graded version of `CommMonoid`. -/
@@ -356,8 +371,7 @@ variable [AddMonoid ι] [GMonoid A]
 
 /-- `GradedMonoid.mk 0` is a `MonoidHom`, using the `GradedMonoid.GradeZero.monoid` structure.
 -/
-def mkZeroMonoidHom : A 0 →* GradedMonoid A
-    where
+def mkZeroMonoidHom : A 0 →* GradedMonoid A where
   toFun := mk 0
   map_one' := rfl
   map_mul' := mk_zero_smul

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>

@@ -320,7 +320,7 @@ section Monoid
 
 variable [AddMonoid ι] [GMonoid A]
 
-instance : Pow (A 0) ℕ where
+instance : NatPow (A 0) where
   pow x n := @Eq.rec ι (n • (0:ι)) (fun a _ => A a) (GMonoid.gnpow n x) 0 (nsmul_zero n)
 
 variable {A}

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

@@ -446,8 +446,8 @@ theorem GradedMonoid.list_prod_map_eq_dProd (l : List α) (f : α → GradedMono
 
 theorem GradedMonoid.list_prod_ofFn_eq_dProd {n : ℕ} (f : Fin n → GradedMonoid A) :
     (List.ofFn f).prod =
-      GradedMonoid.mk _ ((List.finRange n).dProd (fun i => (f i).1) fun i => (f i).2) :=
-  by rw [List.ofFn_eq_map, GradedMonoid.list_prod_map_eq_dProd]
+      GradedMonoid.mk _ ((List.finRange n).dProd (fun i => (f i).1) fun i => (f i).2) := by
+  rw [List.ofFn_eq_map, GradedMonoid.list_prod_map_eq_dProd]
 #align graded_monoid.list_prod_of_fn_eq_dprod GradedMonoid.list_prod_ofFn_eq_dProd
 
 end DProd

Also adds some missing actions on GradedMonoid which cleans up the definition of DirectSum.GAlgebra slightly.

This also replaces (⟨i, x⟩ : GradedMonoid _) with .mk i x as the former uses Sigma.mk instead of GradedMonoid.mk, which is annoying for rw.

@@ -26,7 +26,7 @@ forms an additively-graded monoid. The typeclasses are:
 * `GradedMonoid.GMonoid A`
 * `GradedMonoid.GCommMonoid A`
 
-With the `SigmaGraded` locale open, these respectively imbue:
+These respectively imbue:
 
 * `One (GradedMonoid A)`
 * `Mul (GradedMonoid A)`
@@ -109,6 +109,35 @@ def mk {A : ι → Type*} : ∀ i, A i → GradedMonoid A :=
   Sigma.mk
 #align graded_monoid.mk GradedMonoid.mk
 
+/-! ### Actions -/
+
+section actions
+
+/-- If `R` acts on each `A i`, then it acts on `GradedMonoid A` via the `.2` projection. -/
+instance {α} {A : ι → Type*} [∀ i, SMul α (A i)] : SMul α (GradedMonoid A) where
+  smul r g := GradedMonoid.mk g.1 (r • g.2)
+
+theorem smul_mk {α} {A : ι → Type*} [∀ i, SMul α (A i)] {i} (c : α) (a : A i) :
+    c • mk i a = mk i (c • a) :=
+  rfl
+
+instance {α β} {A : ι → Type*} [∀ i, SMul α (A i)] [∀ i, SMul β (A i)]
+    [∀ i, SMulCommClass α β (A i)] :
+    SMulCommClass α β (GradedMonoid A) where
+  smul_comm a b g := Sigma.ext rfl <| heq_of_eq <| smul_comm a b g.2
+
+instance {α β} {A : ι → Type*} [SMul α β] [∀ i, SMul α (A i)] [∀ i, SMul β (A i)]
+    [∀ i, IsScalarTower α β (A i)] :
+    IsScalarTower α β (GradedMonoid A) where
+  smul_assoc a b g := Sigma.ext rfl <| heq_of_eq <| smul_assoc a b g.2
+
+instance {α} {A : ι → Type*} [Monoid α] [∀ i, MulAction α (A i)] :
+    MulAction α (GradedMonoid A) where
+  one_smul g := Sigma.ext rfl <| heq_of_eq <| one_smul _ g.2
+  mul_smul r₁ r₂ g := Sigma.ext rfl <| heq_of_eq <| mul_smul r₁ r₂ g.2
+
+end actions
+
 /-! ### Typeclasses -/
 
 section Defs

Purely cosmetic PR.

@@ -658,7 +658,7 @@ theorem SetLike.coe_list_dProd (A : ι → S) [SetLike.GradedMonoid A] (fι : α
 /-- A version of `List.coe_dProd_set_like` with `Subtype.mk`. -/
 theorem SetLike.list_dProd_eq (A : ι → S) [SetLike.GradedMonoid A] (fι : α → ι) (fA : ∀ a, A (fι a))
     (l : List α) :
-    (@List.dProd _ _ (fun i => ↥(A i)) _ _ l fι fA ) =
+    (@List.dProd _ _ (fun i => ↥(A i)) _ _ l fι fA) =
       ⟨List.prod (l.map fun a => fA a),
         (l.dProdIndex_eq_map_sum fι).symm ▸
           list_prod_map_mem_graded l _ _ fun i _ => (fA i).prop⟩ :=

@@ -263,8 +263,8 @@ variable [AddZeroClass ι] [GMul A]
 /-- `(•) : A 0 → A i → A i` is the value provided in `GradedMonoid.GMul.mul`, composed with
 an `Eq.rec` to turn `A (0 + i)` into `A i`.
 -/
-instance GradeZero.smul (i : ι) : SMul (A 0) (A i)
-    where smul x y := @Eq.rec ι (0+i) (fun a _ => A a) (GMul.mul x y) i (zero_add i)
+instance GradeZero.smul (i : ι) : SMul (A 0) (A i) where
+  smul x y := @Eq.rec ι (0+i) (fun a _ => A a) (GMul.mul x y) i (zero_add i)
 #align graded_monoid.grade_zero.has_smul GradedMonoid.GradeZero.smul
 
 /-- `(*) : A 0 → A 0 → A 0` is the value provided in `GradedMonoid.GMul.mul`, composed with
@@ -496,8 +496,8 @@ theorem SetLike.one_mem_graded {S : Type*} [SetLike S R] [One R] [Zero ι] (A :
 #align set_like.one_mem_graded SetLike.one_mem_graded
 
 instance SetLike.gOne {S : Type*} [SetLike S R] [One R] [Zero ι] (A : ι → S)
-    [SetLike.GradedOne A] : GradedMonoid.GOne fun i => A i
-    where one := ⟨1, SetLike.one_mem_graded _⟩
+    [SetLike.GradedOne A] : GradedMonoid.GOne fun i => A i where
+  one := ⟨1, SetLike.one_mem_graded _⟩
 #align set_like.ghas_one SetLike.gOne
 
 @[simp]
@@ -518,8 +518,8 @@ theorem SetLike.mul_mem_graded {S : Type*} [SetLike S R] [Mul R] [Add ι] {A : 
 #align set_like.mul_mem_graded SetLike.mul_mem_graded
 
 instance SetLike.gMul {S : Type*} [SetLike S R] [Mul R] [Add ι] (A : ι → S)
-    [SetLike.GradedMul A] : GradedMonoid.GMul fun i => A i
-    where mul := fun a b => ⟨(a * b : R), SetLike.mul_mem_graded a.prop b.prop⟩
+    [SetLike.GradedMul A] : GradedMonoid.GMul fun i => A i where
+  mul := fun a b => ⟨(a * b : R), SetLike.mul_mem_graded a.prop b.prop⟩
 #align set_like.ghas_mul SetLike.gMul
 
 /-

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

This has nice performance benefits.

@@ -92,20 +92,20 @@ graded monoid
 -/
 
 
-variable {ι : Type _}
+variable {ι : Type*}
 
 /-- A type alias of sigma types for graded monoids. -/
-def GradedMonoid (A : ι → Type _) :=
+def GradedMonoid (A : ι → Type*) :=
   Sigma A
 #align graded_monoid GradedMonoid
 
 namespace GradedMonoid
 
-instance {A : ι → Type _} [Inhabited ι] [Inhabited (A default)] : Inhabited (GradedMonoid A) :=
+instance {A : ι → Type*} [Inhabited ι] [Inhabited (A default)] : Inhabited (GradedMonoid A) :=
   inferInstanceAs <| Inhabited (Sigma _)
 
 /-- Construct an element of a graded monoid. -/
-def mk {A : ι → Type _} : ∀ i, A i → GradedMonoid A :=
+def mk {A : ι → Type*} : ∀ i, A i → GradedMonoid A :=
   Sigma.mk
 #align graded_monoid.mk GradedMonoid.mk
 
@@ -113,7 +113,7 @@ def mk {A : ι → Type _} : ∀ i, A i → GradedMonoid A :=
 
 section Defs
 
-variable (A : ι → Type _)
+variable (A : ι → Type*)
 
 /-- A graded version of `One`, which must be of grade 0. -/
 class GOne [Zero ι] where
@@ -242,7 +242,7 @@ types of multiplicative structure.
 
 section GradeZero
 
-variable (A : ι → Type _)
+variable (A : ι → Type*)
 
 section One
 
@@ -351,7 +351,7 @@ end GradedMonoid
 
 section DProd
 
-variable {α : Type _} {A : ι → Type _} [AddMonoid ι] [GradedMonoid.GMonoid A]
+variable {α : Type*} {A : ι → Type*} [AddMonoid ι] [GradedMonoid.GMonoid A]
 
 /-- The index used by `List.dProd`. Propositionally this is equal to `(l.map fι).Sum`, but
 definitionally it needs to have a different form to avoid introducing `Eq.rec`s in `List.dProd`. -/
@@ -428,7 +428,7 @@ end DProd
 
 section
 
-variable (ι) {R : Type _}
+variable (ι) {R : Type*}
 
 @[simps one]
 instance One.gOne [Zero ι] [One R] : GradedMonoid.GOne fun _ : ι => R where one := 1
@@ -482,42 +482,42 @@ end
 
 section Subobjects
 
-variable {R : Type _}
+variable {R : Type*}
 
 /-- A version of `GradedMonoid.GOne` for internally graded objects. -/
-class SetLike.GradedOne {S : Type _} [SetLike S R] [One R] [Zero ι] (A : ι → S) : Prop where
+class SetLike.GradedOne {S : Type*} [SetLike S R] [One R] [Zero ι] (A : ι → S) : Prop where
   /-- One has grade zero -/
   one_mem : (1 : R) ∈ A 0
 #align set_like.has_graded_one SetLike.GradedOne
 
-theorem SetLike.one_mem_graded {S : Type _} [SetLike S R] [One R] [Zero ι] (A : ι → S)
+theorem SetLike.one_mem_graded {S : Type*} [SetLike S R] [One R] [Zero ι] (A : ι → S)
     [SetLike.GradedOne A] : (1 : R) ∈ A 0 :=
   SetLike.GradedOne.one_mem
 #align set_like.one_mem_graded SetLike.one_mem_graded
 
-instance SetLike.gOne {S : Type _} [SetLike S R] [One R] [Zero ι] (A : ι → S)
+instance SetLike.gOne {S : Type*} [SetLike S R] [One R] [Zero ι] (A : ι → S)
     [SetLike.GradedOne A] : GradedMonoid.GOne fun i => A i
     where one := ⟨1, SetLike.one_mem_graded _⟩
 #align set_like.ghas_one SetLike.gOne
 
 @[simp]
-theorem SetLike.coe_gOne {S : Type _} [SetLike S R] [One R] [Zero ι] (A : ι → S)
+theorem SetLike.coe_gOne {S : Type*} [SetLike S R] [One R] [Zero ι] (A : ι → S)
     [SetLike.GradedOne A] : ↑(@GradedMonoid.GOne.one _ (fun i => A i) _ _) = (1 : R) :=
   rfl
 #align set_like.coe_ghas_one SetLike.coe_gOne
 
 /-- A version of `GradedMonoid.ghas_one` for internally graded objects. -/
-class SetLike.GradedMul {S : Type _} [SetLike S R] [Mul R] [Add ι] (A : ι → S) : Prop where
+class SetLike.GradedMul {S : Type*} [SetLike S R] [Mul R] [Add ι] (A : ι → S) : Prop where
   /-- Multiplication is homogeneous -/
   mul_mem : ∀ ⦃i j⦄ {gi gj}, gi ∈ A i → gj ∈ A j → gi * gj ∈ A (i + j)
 #align set_like.has_graded_mul SetLike.GradedMul
 
-theorem SetLike.mul_mem_graded {S : Type _} [SetLike S R] [Mul R] [Add ι] {A : ι → S}
+theorem SetLike.mul_mem_graded {S : Type*} [SetLike S R] [Mul R] [Add ι] {A : ι → S}
     [SetLike.GradedMul A] ⦃i j⦄ {gi gj} (hi : gi ∈ A i) (hj : gj ∈ A j) : gi * gj ∈ A (i + j) :=
   SetLike.GradedMul.mul_mem hi hj
 #align set_like.mul_mem_graded SetLike.mul_mem_graded
 
-instance SetLike.gMul {S : Type _} [SetLike S R] [Mul R] [Add ι] (A : ι → S)
+instance SetLike.gMul {S : Type*} [SetLike S R] [Mul R] [Add ι] (A : ι → S)
     [SetLike.GradedMul A] : GradedMonoid.GMul fun i => A i
     where mul := fun a b => ⟨(a * b : R), SetLike.mul_mem_graded a.prop b.prop⟩
 #align set_like.ghas_mul SetLike.gMul
@@ -529,13 +529,13 @@ Porting note: simpNF linter returns
 
 However, simp does indeed solve the following. Possibly related std#71,std#78
 
-example {S : Type _} [SetLike S R] [Mul R] [Add ι] (A : ι → S)
+example {S : Type*} [SetLike S R] [Mul R] [Add ι] (A : ι → S)
     [SetLike.GradedMul A] {i j : ι} (x : A i) (y : A j) :
     ↑(@GradedMonoid.GMul.mul _ (fun i => A i) _ _ _ _ x y) = (x * y : R) := by simp
 
 -/
 @[simp,nolint simpNF]
-theorem SetLike.coe_gMul {S : Type _} [SetLike S R] [Mul R] [Add ι] (A : ι → S)
+theorem SetLike.coe_gMul {S : Type*} [SetLike S R] [Mul R] [Add ι] (A : ι → S)
     [SetLike.GradedMul A] {i j : ι} (x : A i) (y : A j) :
     ↑(@GradedMonoid.GMul.mul _ (fun i => A i) _ _ _ _ x y) = (x * y : R) :=
   rfl
@@ -543,13 +543,13 @@ theorem SetLike.coe_gMul {S : Type _} [SetLike S R] [Mul R] [Add ι] (A : ι →
 
 
 /-- A version of `GradedMonoid.GMonoid` for internally graded objects. -/
-class SetLike.GradedMonoid {S : Type _} [SetLike S R] [Monoid R] [AddMonoid ι] (A : ι → S) extends
+class SetLike.GradedMonoid {S : Type*} [SetLike S R] [Monoid R] [AddMonoid ι] (A : ι → S) extends
   SetLike.GradedOne A, SetLike.GradedMul A : Prop
 #align set_like.graded_monoid SetLike.GradedMonoid
 
 namespace SetLike
 
-variable {S : Type _} [SetLike S R] [Monoid R] [AddMonoid ι]
+variable {S : Type*} [SetLike S R] [Monoid R] [AddMonoid ι]
 
 variable {A : ι → S} [SetLike.GradedMonoid A]
 
@@ -585,7 +585,7 @@ theorem list_prod_ofFn_mem_graded {n} (i : Fin n → ι) (r : Fin n → R) (h :
 end SetLike
 
 /-- Build a `GMonoid` instance for a collection of subobjects. -/
-instance SetLike.gMonoid {S : Type _} [SetLike S R] [Monoid R] [AddMonoid ι] (A : ι → S)
+instance SetLike.gMonoid {S : Type*} [SetLike S R] [Monoid R] [AddMonoid ι] (A : ι → S)
     [SetLike.GradedMonoid A] : GradedMonoid.GMonoid fun i => A i :=
   { SetLike.gOne A,
     SetLike.gMul A with
@@ -605,20 +605,20 @@ Porting note: simpNF linter returns
 
 However, simp does indeed solve the following. Possibly related std#71,std#78
 
-example {S : Type _} [SetLike S R] [Monoid R] [AddMonoid ι] (A : ι → S)
+example {S : Type*} [SetLike S R] [Monoid R] [AddMonoid ι] (A : ι → S)
     [SetLike.GradedMonoid A] {i : ι} (x : A i) (n : ℕ) :
     ↑(@GradedMonoid.GMonoid.gnpow _ (fun i => A i) _ _ n _ x) = (x:R)^n := by simp
 
 -/
 @[simp,nolint simpNF]
-theorem SetLike.coe_gnpow {S : Type _} [SetLike S R] [Monoid R] [AddMonoid ι] (A : ι → S)
+theorem SetLike.coe_gnpow {S : Type*} [SetLike S R] [Monoid R] [AddMonoid ι] (A : ι → S)
     [SetLike.GradedMonoid A] {i : ι} (x : A i) (n : ℕ) :
     ↑(@GradedMonoid.GMonoid.gnpow _ (fun i => A i) _ _ n _ x) = (x:R)^n :=
   rfl
 #align set_like.coe_gnpow SetLike.coe_gnpow
 
 /-- Build a `GCommMonoid` instance for a collection of subobjects. -/
-instance SetLike.gCommMonoid {S : Type _} [SetLike S R] [CommMonoid R] [AddCommMonoid ι] (A : ι → S)
+instance SetLike.gCommMonoid {S : Type*} [SetLike S R] [CommMonoid R] [AddCommMonoid ι] (A : ι → S)
     [SetLike.GradedMonoid A] : GradedMonoid.GCommMonoid fun i => A i :=
   { SetLike.gMonoid A with
     mul_comm := fun ⟨_, _, _⟩ ⟨_, _, _⟩ => Sigma.subtype_ext (add_comm _ _) (mul_comm _ _) }
@@ -628,7 +628,7 @@ section DProd
 
 open SetLike SetLike.GradedMonoid
 
-variable {α S : Type _} [SetLike S R] [Monoid R] [AddMonoid ι]
+variable {α S : Type*} [SetLike S R] [Monoid R] [AddMonoid ι]
 
 /-
 Porting note: simpNF linter returns
@@ -671,7 +671,7 @@ end Subobjects
 
 section HomogeneousElements
 
-variable {R S : Type _} [SetLike S R]
+variable {R S : Type*} [SetLike S R]
 
 /-- An element `a : R` is said to be homogeneous if there is some `i : ι` such that `a ∈ A i`. -/
 def SetLike.Homogeneous (A : ι → S) (a : R) : Prop :=

Per https://github.com/leanprover/lean4/issues/2343, we are going to need to change the automatic generation of instance names, as they become too long.

This PR ensures that everywhere in Mathlib that refers to an instance by name, that name is given explicitly, rather than being automatically generated.

There are four exceptions, which are now commented, with links to https://github.com/leanprover/lean4/issues/2343.

This was implemented by running Mathlib against a modified Lean that appended _ᾰ to all automatically generated names, and fixing everything.

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

@@ -101,8 +101,8 @@ def GradedMonoid (A : ι → Type _) :=
 
 namespace GradedMonoid
 
-instance {A : ι → Type _} [Inhabited ι] [Inhabited (A default)] : Inhabited (GradedMonoid A) where
-  default := Sigma.instInhabitedSigma.default
+instance {A : ι → Type _} [Inhabited ι] [Inhabited (A default)] : Inhabited (GradedMonoid A) :=
+  inferInstanceAs <| Inhabited (Sigma _)
 
 /-- Construct an element of a graded monoid. -/
 def mk {A : ι → Type _} : ∀ i, A i → GradedMonoid A :=

• depends on: #5966

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

@@ -2,11 +2,6 @@
 Copyright (c) 2021 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
-
-! This file was ported from Lean 3 source module algebra.graded_monoid
-! leanprover-community/mathlib commit 008205aa645b3f194c1da47025c5f110c8406eab
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Group.InjSurj
 import Mathlib.Data.List.BigOperators.Basic
@@ -17,6 +12,8 @@ import Mathlib.Data.SetLike.Basic
 import Mathlib.Data.Sigma.Basic
 import Lean.Elab.Tactic
 
+#align_import algebra.graded_monoid from "leanprover-community/mathlib"@"008205aa645b3f194c1da47025c5f110c8406eab"
+
 /-!
 # Additively-graded multiplicative structures
 

All of these are doc fixes

@@ -337,7 +337,7 @@ def mkZeroMonoidHom : A 0 →* GradedMonoid A
   map_mul' := mk_zero_smul
 #align graded_monoid.mk_zero_monoid_hom GradedMonoid.mkZeroMonoidHom
 
-/-- Each grade `A i` derives a `A 0`-action structure from `GMonoid A`. -/
+/-- Each grade `A i` derives an `A 0`-action structure from `GMonoid A`. -/
 instance GradeZero.mulAction {i} : MulAction (A 0) (A i) :=
   letI := MulAction.compHom (GradedMonoid A) (mkZeroMonoidHom A)
   Function.Injective.mulAction (mk i) sigma_mk_injective mk_zero_smul

These are all doc fixes

@@ -170,9 +170,9 @@ theorem gnpowRec_succ (n : ℕ) (a : GradedMonoid A) :
 
 end GMonoid
 
-/-- A tactic to for use as an optional value for `Gmonoid.gnpow_zero'' -/
+/-- A tactic to for use as an optional value for `GMonoid.gnpow_zero'`. -/
 macro "apply_gmonoid_gnpowRec_zero_tac" : tactic => `(tactic| apply GMonoid.gnpowRec_zero)
-/-- A tactic to for use as an optional value for `Gmonoid.gnpow_succ'' -/
+/-- A tactic to for use as an optional value for `GMonoid.gnpow_succ'`. -/
 macro "apply_gmonoid_gnpowRec_succ_tac" : tactic => `(tactic| apply GMonoid.gnpowRec_succ)
 
 /-- A graded version of `Monoid`
@@ -180,9 +180,9 @@ macro "apply_gmonoid_gnpowRec_succ_tac" : tactic => `(tactic| apply GMonoid.gnpo
 Like `Monoid.npow`, this has an optional `GMonoid.gnpow` field to allow definitional control of
 natural powers of a graded monoid. -/
 class GMonoid [AddMonoid ι] extends GMul A, GOne A where
-  /-- Muliplication by `one` on the left is the identity -/
+  /-- Multiplication by `one` on the left is the identity -/
   one_mul (a : GradedMonoid A) : 1 * a = a
-  /-- Muliplication by `one` on the right is the identity -/
+  /-- Multiplication by `one` on the right is the identity -/
   mul_one (a : GradedMonoid A) : a * 1 = a
   /-- Multiplication is associative -/
   mul_assoc (a b c : GradedMonoid A) : a * b * c = a * (b * c)

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -468,7 +468,7 @@ instance CommMonoid.gCommMonoid [AddCommMonoid ι] [CommMonoid R] :
 /-- When all the indexed types are the same, the dependent product is just the regular product. -/
 @[simp]
 theorem List.dProd_monoid {α} [AddMonoid ι] [Monoid R] (l : List α) (fι : α → ι) (fA : α → R) :
-    @List.dProd _ _ (fun _:ι => R) _ _ l fι fA = (l.map fA).prod := by
+    @List.dProd _ _ (fun _ : ι => R) _ _ l fι fA = (l.map fA).prod := by
   match l with
   | [] =>
     rw [List.dProd_nil, List.map_nil, List.prod_nil]

These are all doc fixes

@@ -86,7 +86,7 @@ in `Algebra.DirectSum.Internal`.
 This file also defines:
 
 * `SetLike.isHomogeneous A` (which says that `a` is homogeneous iff `a ∈ A i` for some `i : ι`)
-* `SetLike.HomogeneouSubmonoid A`, which is, as the name suggests, the submonoid consisting of
+* `SetLike.homogeneousSubmonoid A`, which is, as the name suggests, the submonoid consisting of
   all the homogeneous elements.
 
 ## tags

This fixes a bunch of spacing bugs in tactics. Mathlib counterpart of:

• Lean: leanprover/lean4#2240
• Std: leanprover/std4#149
• Aesop: JLimperg/aesop#56

@@ -171,9 +171,9 @@ theorem gnpowRec_succ (n : ℕ) (a : GradedMonoid A) :
 end GMonoid
 
 /-- A tactic to for use as an optional value for `Gmonoid.gnpow_zero'' -/
-macro "apply_gmonoid_gnpowRec_zero_tac" : tactic => `(tactic | apply GMonoid.gnpowRec_zero)
+macro "apply_gmonoid_gnpowRec_zero_tac" : tactic => `(tactic| apply GMonoid.gnpowRec_zero)
 /-- A tactic to for use as an optional value for `Gmonoid.gnpow_succ'' -/
-macro "apply_gmonoid_gnpowRec_succ_tac" : tactic => `(tactic | apply GMonoid.gnpowRec_succ)
+macro "apply_gmonoid_gnpowRec_succ_tac" : tactic => `(tactic| apply GMonoid.gnpowRec_succ)
 
 /-- A graded version of `Monoid`
 

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

@@ -77,7 +77,7 @@ which respectively provide the API lemmas
 * `SetLike.mul_mem_graded`
 * `SetLike.pow_mem_graded`, `SetLike.list_prod_map_mem_graded`
 
-Strictly this last class is unecessary as it has no fields not present in its parents, but it is
+Strictly this last class is unnecessary as it has no fields not present in its parents, but it is
 included for convenience. Note that there is no need for `SetLike.GradedRing` or similar, as all
 the information it would contain is already supplied by `GradedMonoid` when `A` is a collection
 of objects satisfying `AddSubmonoidClass` such as `Submodule`s. These constructions are explored

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

@@ -175,7 +175,7 @@ macro "apply_gmonoid_gnpowRec_zero_tac" : tactic => `(tactic | apply GMonoid.gnp
 /-- A tactic to for use as an optional value for `Gmonoid.gnpow_succ'' -/
 macro "apply_gmonoid_gnpowRec_succ_tac" : tactic => `(tactic | apply GMonoid.gnpowRec_succ)
 
-/-- A graded version of `monoid`
+/-- A graded version of `Monoid`
 
 Like `Monoid.npow`, this has an optional `GMonoid.gnpow` field to allow definitional control of
 natural powers of a graded monoid. -/
@@ -383,7 +383,7 @@ theorem List.dProdIndex_eq_map_sum (l : List α) (fι : α → ι) :
 /-- A dependent product for graded monoids represented by the indexed family of types `A i`.
 This is a dependent version of `(l.map fA).prod`.
 
-For a list `l : list α`, this computes the product of `fA a` over `a`, where each `fA` is of type
+For a list `l : List α`, this computes the product of `fA a` over `a`, where each `fA` is of type
 `A (fι a)`. -/
 def List.dProd (l : List α) (fι : α → ι) (fA : ∀ a, A (fι a)) : A (l.dProdIndex fι) :=
   l.foldrRecOn _ _ GradedMonoid.GOne.one fun _ x a _ => GradedMonoid.GMul.mul (fA a) x

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".

@@ -212,8 +212,7 @@ instance GMonoid.toMonoid [AddMonoid ι] [GMonoid A] : Monoid (GradedMonoid A)
 #align graded_monoid.gmonoid.to_monoid GradedMonoid.GMonoid.toMonoid
 
 theorem mk_pow [AddMonoid ι] [GMonoid A] {i} (a : A i) (n : ℕ) :
-    mk i a ^ n = mk (n • i) (GMonoid.gnpow _ a) :=
-  by
+    mk i a ^ n = mk (n • i) (GMonoid.gnpow _ a) := by
   match n with
   | 0 =>
     rw [pow_zero]
@@ -374,8 +373,8 @@ theorem List.dProdIndex_cons (a : α) (l : List α) (fι : α → ι) :
   rfl
 #align list.dprod_index_cons List.dProdIndex_cons
 
-theorem List.dProdIndex_eq_map_sum (l : List α) (fι : α → ι) : l.dProdIndex fι = (l.map fι).sum :=
-  by
+theorem List.dProdIndex_eq_map_sum (l : List α) (fι : α → ι) :
+    l.dProdIndex fι = (l.map fι).sum := by
   match l with
   | [] => simp
   | head::tail => simp [List.dProdIndex_eq_map_sum tail fι]
@@ -405,8 +404,7 @@ theorem List.dProd_cons (fι : α → ι) (fA : ∀ a, A (fι a)) (a : α) (l :
 #align list.dprod_cons List.dProd_cons
 
 theorem GradedMonoid.mk_list_dProd (l : List α) (fι : α → ι) (fA : ∀ a, A (fι a)) :
-    GradedMonoid.mk _ (l.dProd fι fA) = (l.map fun a => GradedMonoid.mk (fι a) (fA a)).prod :=
-  by
+    GradedMonoid.mk _ (l.dProd fι fA) = (l.map fun a => GradedMonoid.mk (fι a) (fA a)).prod := by
   match l with
   | [] => simp; rfl
   | head::tail =>
@@ -415,8 +413,7 @@ theorem GradedMonoid.mk_list_dProd (l : List α) (fι : α → ι) (fA : ∀ a,
 
 /-- A variant of `GradedMonoid.mk_list_dProd` for rewriting in the other direction. -/
 theorem GradedMonoid.list_prod_map_eq_dProd (l : List α) (f : α → GradedMonoid A) :
-    (l.map f).prod = GradedMonoid.mk _ (l.dProd (fun i => (f i).1) fun i => (f i).2) :=
-  by
+    (l.map f).prod = GradedMonoid.mk _ (l.dProd (fun i => (f i).1) fun i => (f i).2) := by
   rw [GradedMonoid.mk_list_dProd, GradedMonoid.mk]
   simp_rw [Sigma.eta]
 #align graded_monoid.list_prod_map_eq_dprod GradedMonoid.list_prod_map_eq_dProd
@@ -471,8 +468,7 @@ instance CommMonoid.gCommMonoid [AddCommMonoid ι] [CommMonoid R] :
 /-- When all the indexed types are the same, the dependent product is just the regular product. -/
 @[simp]
 theorem List.dProd_monoid {α} [AddMonoid ι] [Monoid R] (l : List α) (fι : α → ι) (fA : α → R) :
-    @List.dProd _ _ (fun _:ι => R) _ _ l fι fA = (l.map fA).prod  :=
-  by
+    @List.dProd _ _ (fun _:ι => R) _ _ l fι fA = (l.map fA).prod := by
   match l with
   | [] =>
     rw [List.dProd_nil, List.map_nil, List.prod_nil]
@@ -560,8 +556,7 @@ variable {S : Type _} [SetLike S R] [Monoid R] [AddMonoid ι]
 
 variable {A : ι → S} [SetLike.GradedMonoid A]
 
-theorem pow_mem_graded (n : ℕ) {r : R} {i : ι} (h : r ∈ A i) : r ^ n ∈ A (n • i) :=
-  by
+theorem pow_mem_graded (n : ℕ) {r : R} {i : ι} (h : r ∈ A i) : r ^ n ∈ A (n • i) := by
   match n with
   | 0 =>
     rw [pow_zero, zero_nsmul]
@@ -572,8 +567,7 @@ theorem pow_mem_graded (n : ℕ) {r : R} {i : ι} (h : r ∈ A i) : r ^ n ∈ A
 #align set_like.pow_mem_graded SetLike.pow_mem_graded
 
 theorem list_prod_map_mem_graded {ι'} (l : List ι') (i : ι' → ι) (r : ι' → R)
-    (h : ∀ j ∈ l, r j ∈ A (i j)) : (l.map r).prod ∈ A (l.map i).sum :=
-  by
+    (h : ∀ j ∈ l, r j ∈ A (i j)) : (l.map r).prod ∈ A (l.map i).sum := by
   match l with
   | [] =>
     rw [List.map_nil, List.map_nil, List.prod_nil, List.sum_nil]
@@ -586,8 +580,7 @@ theorem list_prod_map_mem_graded {ι'} (l : List ι') (i : ι' → ι) (r : ι'
 #align set_like.list_prod_map_mem_graded SetLike.list_prod_map_mem_graded
 
 theorem list_prod_ofFn_mem_graded {n} (i : Fin n → ι) (r : Fin n → R) (h : ∀ j, r j ∈ A (i j)) :
-    (List.ofFn r).prod ∈ A (List.ofFn i).sum :=
-  by
+    (List.ofFn r).prod ∈ A (List.ofFn i).sum := by
   rw [List.ofFn_eq_map, List.ofFn_eq_map]
   exact list_prod_map_mem_graded _ _ _ fun _ _ => h _
 #align set_like.list_prod_of_fn_mem_graded SetLike.list_prod_ofFn_mem_graded

@@ -104,7 +104,7 @@ def GradedMonoid (A : ι → Type _) :=
 
 namespace GradedMonoid
 
-instance {A : ι → Type _} [Inhabited ι] [Inhabited (A default)] : Inhabited (GradedMonoid A) where 
+instance {A : ι → Type _} [Inhabited ι] [Inhabited (A default)] : Inhabited (GradedMonoid A) where
   default := Sigma.instInhabitedSigma.default
 
 /-- Construct an element of a graded monoid. -/
@@ -194,7 +194,7 @@ class GMonoid [AddMonoid ι] extends GMul A, GOne A where
   /-- Successor powers behave as expected -/
   gnpow_succ' :
     ∀ (n : ℕ) (a : GradedMonoid A),
-      (GradedMonoid.mk _ <| gnpow n.succ a.snd) = a * ⟨_, gnpow n a.snd⟩ := by 
+      (GradedMonoid.mk _ <| gnpow n.succ a.snd) = a * ⟨_, gnpow n a.snd⟩ := by
     apply_gmonoid_gnpowRec_succ_tac
 #align graded_monoid.gmonoid GradedMonoid.GMonoid
 
@@ -214,11 +214,11 @@ instance GMonoid.toMonoid [AddMonoid ι] [GMonoid A] : Monoid (GradedMonoid A)
 theorem mk_pow [AddMonoid ι] [GMonoid A] {i} (a : A i) (n : ℕ) :
     mk i a ^ n = mk (n • i) (GMonoid.gnpow _ a) :=
   by
-  match n with 
-  | 0 => 
+  match n with
+  | 0 =>
     rw [pow_zero]
     exact (GMonoid.gnpow_zero' ⟨_, a⟩).symm
-  | n+1 => 
+  | n+1 =>
     rw [pow_succ, mk_pow a n, mk_mul_mk]
     exact (GMonoid.gnpow_succ' n ⟨_, a⟩).symm
 #align graded_monoid.mk_pow GradedMonoid.mk_pow
@@ -268,7 +268,7 @@ variable [AddZeroClass ι] [GMul A]
 an `Eq.rec` to turn `A (0 + i)` into `A i`.
 -/
 instance GradeZero.smul (i : ι) : SMul (A 0) (A i)
-    where smul x y := @Eq.rec ι (0+i) (fun a _ => A a) (GMul.mul x y) i (zero_add i)   
+    where smul x y := @Eq.rec ι (0+i) (fun a _ => A a) (GMul.mul x y) i (zero_add i)
 #align graded_monoid.grade_zero.has_smul GradedMonoid.GradeZero.smul
 
 /-- `(*) : A 0 → A 0 → A 0` is the value provided in `GradedMonoid.GMul.mul`, composed with
@@ -281,7 +281,7 @@ variable {A}
 
 @[simp]
 theorem mk_zero_smul {i} (a : A 0) (b : A i) : mk _ (a • b) = mk _ a * mk _ b :=
-  Sigma.ext (zero_add _).symm <| eq_rec_heq _ _ 
+  Sigma.ext (zero_add _).symm <| eq_rec_heq _ _
 #align graded_monoid.mk_zero_smul GradedMonoid.mk_zero_smul
 
 @[simp]
@@ -295,7 +295,7 @@ section Monoid
 
 variable [AddMonoid ι] [GMonoid A]
 
-instance : Pow (A 0) ℕ where 
+instance : Pow (A 0) ℕ where
   pow x n := @Eq.rec ι (n • (0:ι)) (fun a _ => A a) (GMonoid.gnpow n x) 0 (nsmul_zero n)
 
 variable {A}
@@ -376,9 +376,9 @@ theorem List.dProdIndex_cons (a : α) (l : List α) (fι : α → ι) :
 
 theorem List.dProdIndex_eq_map_sum (l : List α) (fι : α → ι) : l.dProdIndex fι = (l.map fι).sum :=
   by
-  match l with 
-  | [] => simp 
-  | head::tail => simp [List.dProdIndex_eq_map_sum tail fι] 
+  match l with
+  | [] => simp
+  | head::tail => simp [List.dProdIndex_eq_map_sum tail fι]
 #align list.dprod_index_eq_map_sum List.dProdIndex_eq_map_sum
 
 /-- A dependent product for graded monoids represented by the indexed family of types `A i`.
@@ -407,9 +407,9 @@ theorem List.dProd_cons (fι : α → ι) (fA : ∀ a, A (fι a)) (a : α) (l :
 theorem GradedMonoid.mk_list_dProd (l : List α) (fι : α → ι) (fA : ∀ a, A (fι a)) :
     GradedMonoid.mk _ (l.dProd fι fA) = (l.map fun a => GradedMonoid.mk (fι a) (fA a)).prod :=
   by
-  match l with 
-  | [] => simp; rfl 
-  | head::tail => 
+  match l with
+  | [] => simp; rfl
+  | head::tail =>
     simp[← GradedMonoid.mk_list_dProd tail _ _, GradedMonoid.mk_mul_mk, List.prod_cons]
 #align graded_monoid.mk_list_dprod GradedMonoid.mk_list_dProd
 
@@ -450,7 +450,7 @@ structure. -/
 instance Monoid.gMonoid [AddMonoid ι] [Monoid R] : GradedMonoid.GMonoid fun _ : ι => R :=
   -- { Mul.gMul ι, One.gOne ι with
   { One.gOne ι with
-    mul := fun x y => x * y 
+    mul := fun x y => x * y
     one_mul := fun _ => Sigma.ext (zero_add _) (heq_of_eq (one_mul _))
     mul_one := fun _ => Sigma.ext (add_zero _) (heq_of_eq (mul_one _))
     mul_assoc := fun _ _ _ => Sigma.ext (add_assoc _ _ _) (heq_of_eq (mul_assoc _ _ _))
@@ -473,11 +473,11 @@ instance CommMonoid.gCommMonoid [AddCommMonoid ι] [CommMonoid R] :
 theorem List.dProd_monoid {α} [AddMonoid ι] [Monoid R] (l : List α) (fι : α → ι) (fA : α → R) :
     @List.dProd _ _ (fun _:ι => R) _ _ l fι fA = (l.map fA).prod  :=
   by
-  match l with 
-  | [] => 
+  match l with
+  | [] =>
     rw [List.dProd_nil, List.map_nil, List.prod_nil]
     rfl
-  | head::tail => 
+  | head::tail =>
     rw [List.dProd_cons, List.map_cons, List.prod_cons, List.dProd_monoid tail _ _]
     rfl
 #align list.dprod_monoid List.dProd_monoid
@@ -530,7 +530,7 @@ instance SetLike.gMul {S : Type _} [SetLike S R] [Mul R] [Add ι] (A : ι → S)
 #align set_like.ghas_mul SetLike.gMul
 
 /-
-Porting note: simpNF linter returns 
+Porting note: simpNF linter returns
 
 "Left-hand side does not simplify, when using the simp lemma on itself."
 
@@ -538,10 +538,10 @@ However, simp does indeed solve the following. Possibly related std#71,std#78
 
 example {S : Type _} [SetLike S R] [Mul R] [Add ι] (A : ι → S)
     [SetLike.GradedMul A] {i j : ι} (x : A i) (y : A j) :
-    ↑(@GradedMonoid.GMul.mul _ (fun i => A i) _ _ _ _ x y) = (x * y : R) := by simp 
+    ↑(@GradedMonoid.GMul.mul _ (fun i => A i) _ _ _ _ x y) = (x * y : R) := by simp
 
 -/
-@[simp,nolint simpNF] 
+@[simp,nolint simpNF]
 theorem SetLike.coe_gMul {S : Type _} [SetLike S R] [Mul R] [Add ι] (A : ι → S)
     [SetLike.GradedMul A] {i j : ι} (x : A i) (y : A j) :
     ↑(@GradedMonoid.GMul.mul _ (fun i => A i) _ _ _ _ x y) = (x * y : R) :=
@@ -562,11 +562,11 @@ variable {A : ι → S} [SetLike.GradedMonoid A]
 
 theorem pow_mem_graded (n : ℕ) {r : R} {i : ι} (h : r ∈ A i) : r ^ n ∈ A (n • i) :=
   by
-  match n with 
-  | 0 => 
+  match n with
+  | 0 =>
     rw [pow_zero, zero_nsmul]
     exact one_mem_graded _
-  | n+1 => 
+  | n+1 =>
     rw [pow_succ', succ_nsmul']
     exact mul_mem_graded (pow_mem_graded n h) h
 #align set_like.pow_mem_graded SetLike.pow_mem_graded
@@ -574,11 +574,11 @@ theorem pow_mem_graded (n : ℕ) {r : R} {i : ι} (h : r ∈ A i) : r ^ n ∈ A
 theorem list_prod_map_mem_graded {ι'} (l : List ι') (i : ι' → ι) (r : ι' → R)
     (h : ∀ j ∈ l, r j ∈ A (i j)) : (l.map r).prod ∈ A (l.map i).sum :=
   by
-  match l with 
-  | [] => 
+  match l with
+  | [] =>
     rw [List.map_nil, List.map_nil, List.prod_nil, List.sum_nil]
     exact one_mem_graded _
-  | head::tail => 
+  | head::tail =>
     rw [List.map_cons, List.map_cons, List.prod_cons, List.sum_cons]
     exact
       mul_mem_graded (h _ <| List.mem_cons_self _ _)
@@ -598,8 +598,7 @@ end SetLike
 instance SetLike.gMonoid {S : Type _} [SetLike S R] [Monoid R] [AddMonoid ι] (A : ι → S)
     [SetLike.GradedMonoid A] : GradedMonoid.GMonoid fun i => A i :=
   { SetLike.gOne A,
-    SetLike.gMul
-      A with
+    SetLike.gMul A with
     one_mul := fun ⟨_, _, _⟩ => Sigma.subtype_ext (zero_add _) (one_mul _)
     mul_one := fun ⟨_, _, _⟩ => Sigma.subtype_ext (add_zero _) (mul_one _)
     mul_assoc := fun ⟨_, _, _⟩ ⟨_, _, _⟩ ⟨_, _, _⟩ =>
@@ -610,7 +609,7 @@ instance SetLike.gMonoid {S : Type _} [SetLike S R] [Monoid R] [AddMonoid ι] (A
 #align set_like.gmonoid SetLike.gMonoid
 
 /-
-Porting note: simpNF linter returns 
+Porting note: simpNF linter returns
 
 "Left-hand side does not simplify, when using the simp lemma on itself."
 
@@ -621,7 +620,7 @@ example {S : Type _} [SetLike S R] [Monoid R] [AddMonoid ι] (A : ι → S)
     ↑(@GradedMonoid.GMonoid.gnpow _ (fun i => A i) _ _ n _ x) = (x:R)^n := by simp
 
 -/
-@[simp,nolint simpNF] 
+@[simp,nolint simpNF]
 theorem SetLike.coe_gnpow {S : Type _} [SetLike S R] [Monoid R] [AddMonoid ι] (A : ι → S)
     [SetLike.GradedMonoid A] {i : ι} (x : A i) (n : ℕ) :
     ↑(@GradedMonoid.GMonoid.gnpow _ (fun i => A i) _ _ n _ x) = (x:R)^n :=
@@ -642,30 +641,30 @@ open SetLike SetLike.GradedMonoid
 variable {α S : Type _} [SetLike S R] [Monoid R] [AddMonoid ι]
 
 /-
-Porting note: simpNF linter returns 
+Porting note: simpNF linter returns
 
 "Left-hand side does not simplify, when using the simp lemma on itself."
 
 However, simp does indeed solve the following. Possibly related std#71,std#78
 
 example (A : ι → S) [SetLike.GradedMonoid A] (fι : α → ι)
-    (fA : ∀ a, A (fι a)) (l : List α) : ↑(@List.dProd _ _ (fun i => ↥(A i)) _ _ l fι fA) 
+    (fA : ∀ a, A (fι a)) (l : List α) : ↑(@List.dProd _ _ (fun i => ↥(A i)) _ _ l fι fA)
     = (List.prod (l.map fun a => fA a) : R) := by simp
 -/
 /-- Coercing a dependent product of subtypes is the same as taking the regular product of the
 coercions. -/
-@[simp,nolint simpNF] 
+@[simp,nolint simpNF]
 theorem SetLike.coe_list_dProd (A : ι → S) [SetLike.GradedMonoid A] (fι : α → ι)
-    (fA : ∀ a, A (fι a)) (l : List α) : ↑(@List.dProd _ _ (fun i => ↥(A i)) _ _ l fι fA) 
+    (fA : ∀ a, A (fι a)) (l : List α) : ↑(@List.dProd _ _ (fun i => ↥(A i)) _ _ l fι fA)
     = (List.prod (l.map fun a => fA a) : R) := by
-  match l with 
-  | [] => 
+  match l with
+  | [] =>
     rw [List.dProd_nil, coe_gOne, List.map_nil, List.prod_nil]
-  | head::tail => 
-    rw [List.dProd_cons, coe_gMul, List.map_cons, List.prod_cons, 
+  | head::tail =>
+    rw [List.dProd_cons, coe_gMul, List.map_cons, List.prod_cons,
       SetLike.coe_list_dProd _ _ _ tail]
 #align set_like.coe_list_dprod SetLike.coe_list_dProd
- 
+
 /-- A version of `List.coe_dProd_set_like` with `Subtype.mk`. -/
 theorem SetLike.list_dProd_eq (A : ι → S) [SetLike.GradedMonoid A] (fι : α → ι) (fA : ∀ a, A (fι a))
     (l : List α) :
@@ -709,8 +708,7 @@ def SetLike.homogeneousSubmonoid [AddMonoid ι] [Monoid R] (A : ι → S) [SetLi
     Submonoid R where
   carrier := { a | SetLike.Homogeneous A a }
   one_mem' := SetLike.homogeneous_one A
-  mul_mem' a b := SetLike.homogeneous_mul a b 
+  mul_mem' a b := SetLike.homogeneous_mul a b
 #align set_like.homogeneous_submonoid SetLike.homogeneousSubmonoid
 
 end HomogeneousElements
-

Co-authored-by: Johan Commelin <johan@commelin.net>

@@ -132,7 +132,7 @@ instance GOne.toOne [Zero ι] [GOne A] : One (GradedMonoid A) :=
 /-- A graded version of `Mul`. Multiplication combines grades additively, like
 `AddMonoidAlgebra`. -/
 class GMul [Add ι] where
-  /-- The homogeneous multiplaction map `mul` -/
+  /-- The homogeneous multiplication map `mul` -/
   mul {i j} : A i → A j → A (i + j)
 #align graded_monoid.ghas_mul GradedMonoid.GMul
 
@@ -515,7 +515,7 @@ theorem SetLike.coe_gOne {S : Type _} [SetLike S R] [One R] [Zero ι] (A : ι 
 
 /-- A version of `GradedMonoid.ghas_one` for internally graded objects. -/
 class SetLike.GradedMul {S : Type _} [SetLike S R] [Mul R] [Add ι] (A : ι → S) : Prop where
-  /-- Multiplication is homoegenous -/
+  /-- Multiplication is homogeneous -/
   mul_mem : ∀ ⦃i j⦄ {gi gj}, gi ∈ A i → gj ∈ A j → gi * gj ∈ A (i + j)
 #align set_like.has_graded_mul SetLike.GradedMul
 

This PR is the result of a slight variant on the following "algorithm"

• take all mathlib 3 names, remove _ and make all uppercase letters into lowercase
• take all mathlib 4 names, remove _ and make all uppercase letters into lowercase
• look for matches, and create pairs (original_lean3_name, OriginalLean4Name)
• for pairs that do not have an align statement:
  • use Lean 4 to lookup the file + position of the Lean 4 name
  • add an #align statement just before the next empty line
• manually fix some tiny mistakes (e.g., empty lines in proofs might cause the #align statement to have been inserted too early)

@@ -458,6 +458,7 @@ instance Monoid.gMonoid [AddMonoid ι] [Monoid R] : GradedMonoid.GMonoid fun _ :
     gnpow_zero' := fun _ => Sigma.ext (zero_nsmul _) (heq_of_eq (Monoid.npow_zero _))
     gnpow_succ' := fun _ ⟨_, _⟩ => Sigma.ext (succ_nsmul _ _) (heq_of_eq (Monoid.npow_succ _ _)) }
 #align monoid.gmonoid Monoid.gMonoid
+#align monoid.gmonoid_gnpow Monoid.gMonoid_gnpow
 
 /-- If all grades are the same type and themselves form a commutative monoid, then there is a
 trivial grading structure. -/