algebra.graded_mul_action | Mathlib porting status

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

861a2692

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

0ebfdb71

bump to nightly-2023-12-20-06

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

058cd493

Diff

@@ -63,31 +63,31 @@ variable (A : ι → Type _) (M : ι → Type _)
 
 /-- A graded version of `has_smul`. Scalar multiplication combines grades additively, i.e.
 if `a ∈ A i` and `m ∈ M j`, then `a • b` must be in `M (i + j)`-/
-class GSmul [Add ι] where
+class GSMul [Add ι] where
   smul {i j} : A i → M j → M (i + j)
-#align graded_monoid.ghas_smul GradedMonoid.GSmulₓ
+#align graded_monoid.ghas_smul GradedMonoid.GSMulₓ
 
-#print GradedMonoid.GMul.toGSmul /-
+#print GradedMonoid.GMul.toGSMul /-
 /-- A graded version of `has_mul.to_has_smul` -/
-instance GMul.toGSmul [Add ι] [GMul A] : GSmul A A where smul _ _ := GMul.mul
-#align graded_monoid.ghas_mul.to_ghas_smul GradedMonoid.GMul.toGSmul
+instance GMul.toGSMul [Add ι] [GMul A] : GSMul A A where smul _ _ := GMul.mul
+#align graded_monoid.ghas_mul.to_ghas_smul GradedMonoid.GMul.toGSMul
 -/
 
-#print GradedMonoid.GSmul.toSMul /-
-instance GSmul.toSMul [Add ι] [GSmul A M] : SMul (GradedMonoid A) (GradedMonoid M) :=
-  ⟨fun (x : GradedMonoid A) (y : GradedMonoid M) => ⟨_, GSmul.smul x.snd y.snd⟩⟩
-#align graded_monoid.ghas_smul.to_has_smul GradedMonoid.GSmul.toSMul
+#print GradedMonoid.GSMul.toSMul /-
+instance GSMul.toSMul [Add ι] [GSMul A M] : SMul (GradedMonoid A) (GradedMonoid M) :=
+  ⟨fun (x : GradedMonoid A) (y : GradedMonoid M) => ⟨_, GSMul.smul x.snd y.snd⟩⟩
+#align graded_monoid.ghas_smul.to_has_smul GradedMonoid.GSMul.toSMul
 -/
 
 #print GradedMonoid.mk_smul_mk /-
-theorem mk_smul_mk [Add ι] [GSmul A M] {i j} (a : A i) (b : M j) :
-    mk i a • mk j b = mk (i + j) (GSmul.smul a b) :=
+theorem mk_smul_mk [Add ι] [GSMul A M] {i j} (a : A i) (b : M j) :
+    mk i a • mk j b = mk (i + j) (GSMul.smul a b) :=
   rfl
 #align graded_monoid.mk_smul_mk GradedMonoid.mk_smul_mk
 -/
 
 /-- A graded version of `mul_action`. -/
-class GMulAction [AddMonoid ι] [GMonoid A] extends GSmul A M where
+class GMulAction [AddMonoid ι] [GMonoid A] extends GSMul A M where
   one_smul (b : GradedMonoid M) : (1 : GradedMonoid A) • b = b
   hMul_smul (a a' : GradedMonoid A) (b : GradedMonoid M) : (a * a') • b = a • a' • b
 #align graded_monoid.gmul_action GradedMonoid.GMulActionₓ
@@ -95,7 +95,7 @@ class GMulAction [AddMonoid ι] [GMonoid A] extends GSmul A M where
 #print GradedMonoid.GMonoid.toGMulAction /-
 /-- The graded version of `monoid.to_mul_action`. -/
 instance GMonoid.toGMulAction [AddMonoid ι] [GMonoid A] : GMulAction A A :=
-  { GMul.toGSmul _ with
+  { GMul.toGSMul _ with
     one_smul := GMonoid.one_hMul
     hMul_smul := GMonoid.hMul_assoc }
 #align graded_monoid.gmonoid.to_gmul_action GradedMonoid.GMonoid.toGMulAction
@@ -122,34 +122,34 @@ section Subobjects
 variable {R : Type _}
 
 /-- A version of `graded_monoid.ghas_smul` for internally graded objects. -/
-class SetLike.GradedSmul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
+class SetLike.GradedSMul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
     (A : ι → S) (B : ι → N) : Prop where
   smul_mem : ∀ ⦃i j : ι⦄ {ai bj}, ai ∈ A i → bj ∈ B j → ai • bj ∈ B (i + j)
-#align set_like.has_graded_smul SetLike.GradedSmulₓ
-
-#print SetLike.toGSmul /-
-instance SetLike.toGSmul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
-    (A : ι → S) (B : ι → N) [SetLike.GradedSmul A B] :
-    GradedMonoid.GSmul (fun i => A i) fun i => B i
-    where smul i j a b := ⟨(a : R) • b, SetLike.GradedSmul.smul_mem a.2 b.2⟩
-#align set_like.ghas_smul SetLike.toGSmul
+#align set_like.has_graded_smul SetLike.GradedSMulₓ
+
+#print SetLike.toGSMul /-
+instance SetLike.toGSMul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
+    (A : ι → S) (B : ι → N) [SetLike.GradedSMul A B] :
+    GradedMonoid.GSMul (fun i => A i) fun i => B i
+    where smul i j a b := ⟨(a : R) • b, SetLike.GradedSMul.smul_mem a.2 b.2⟩
+#align set_like.ghas_smul SetLike.toGSMul
 -/
 
-#print SetLike.coe_GSmul /-
+#print SetLike.coe_GSMul /-
 @[simp]
-theorem SetLike.coe_GSmul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
-    (A : ι → S) (B : ι → N) [SetLike.GradedSmul A B] {i j : ι} (x : A i) (y : B j) :
-    (@GradedMonoid.GSmul.smul ι (fun i => A i) (fun i => B i) _ _ i j x y : M) = (x : R) • y :=
+theorem SetLike.coe_GSMul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
+    (A : ι → S) (B : ι → N) [SetLike.GradedSMul A B] {i j : ι} (x : A i) (y : B j) :
+    (@GradedMonoid.GSMul.smul ι (fun i => A i) (fun i => B i) _ _ i j x y : M) = (x : R) • y :=
   rfl
-#align set_like.coe_ghas_smul SetLike.coe_GSmul
+#align set_like.coe_ghas_smul SetLike.coe_GSMul
 -/
 
-#print SetLike.GradedMul.toGradedSmul /-
+#print SetLike.GradedMul.toGradedSMul /-
 /-- Internally graded version of `has_mul.to_has_smul`. -/
-instance SetLike.GradedMul.toGradedSmul [AddMonoid ι] [Monoid R] {S : Type _} [SetLike S R]
-    (A : ι → S) [SetLike.GradedMonoid A] : SetLike.GradedSmul A A
+instance SetLike.GradedMul.toGradedSMul [AddMonoid ι] [Monoid R] {S : Type _} [SetLike S R]
+    (A : ι → S) [SetLike.GradedMonoid A] : SetLike.GradedSMul A A
     where smul_mem i j ai bj hi hj := SetLike.GradedMonoid.hMul_mem hi hj
-#align set_like.has_graded_mul.to_has_graded_smul SetLike.GradedMul.toGradedSmul
+#align set_like.has_graded_mul.to_has_graded_smul SetLike.GradedMul.toGradedSMul
 -/
 
 end Subobjects
@@ -160,9 +160,9 @@ variable {S R N M : Type _} [SetLike S R] [SetLike N M]
 
 #print SetLike.Homogeneous.graded_smul /-
 theorem SetLike.Homogeneous.graded_smul [Add ι] [SMul R M] {A : ι → S} {B : ι → N}
-    [SetLike.GradedSmul A B] {a : R} {b : M} :
+    [SetLike.GradedSMul A B] {a : R} {b : M} :
     SetLike.Homogeneous A a → SetLike.Homogeneous B b → SetLike.Homogeneous B (a • b)
-  | ⟨i, hi⟩, ⟨j, hj⟩ => ⟨i + j, SetLike.GradedSmul.smul_mem hi hj⟩
+  | ⟨i, hi⟩, ⟨j, hj⟩ => ⟨i + j, SetLike.GradedSMul.smul_mem hi hj⟩
 #align set_like.is_homogeneous.graded_smul SetLike.Homogeneous.graded_smul
 -/

0ebfdb71

bump to nightly-2023-10-21-06

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

a2dc86f8

Diff

@@ -61,13 +61,11 @@ section Defs
 
 variable (A : ι → Type _) (M : ι → Type _)
 
-#print GradedMonoid.GSmul /-
 /-- A graded version of `has_smul`. Scalar multiplication combines grades additively, i.e.
 if `a ∈ A i` and `m ∈ M j`, then `a • b` must be in `M (i + j)`-/
 class GSmul [Add ι] where
   smul {i j} : A i → M j → M (i + j)
-#align graded_monoid.ghas_smul GradedMonoid.GSmul
--/
+#align graded_monoid.ghas_smul GradedMonoid.GSmulₓ
 
 #print GradedMonoid.GMul.toGSmul /-
 /-- A graded version of `has_mul.to_has_smul` -/
@@ -88,13 +86,11 @@ theorem mk_smul_mk [Add ι] [GSmul A M] {i j} (a : A i) (b : M j) :
 #align graded_monoid.mk_smul_mk GradedMonoid.mk_smul_mk
 -/
 
-#print GradedMonoid.GMulAction /-
 /-- A graded version of `mul_action`. -/
 class GMulAction [AddMonoid ι] [GMonoid A] extends GSmul A M where
   one_smul (b : GradedMonoid M) : (1 : GradedMonoid A) • b = b
   hMul_smul (a a' : GradedMonoid A) (b : GradedMonoid M) : (a * a') • b = a • a' • b
-#align graded_monoid.gmul_action GradedMonoid.GMulAction
--/
+#align graded_monoid.gmul_action GradedMonoid.GMulActionₓ
 
 #print GradedMonoid.GMonoid.toGMulAction /-
 /-- The graded version of `monoid.to_mul_action`. -/
@@ -125,13 +121,11 @@ section Subobjects
 
 variable {R : Type _}
 
-#print SetLike.GradedSmul /-
 /-- A version of `graded_monoid.ghas_smul` for internally graded objects. -/
 class SetLike.GradedSmul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
     (A : ι → S) (B : ι → N) : Prop where
   smul_mem : ∀ ⦃i j : ι⦄ {ai bj}, ai ∈ A i → bj ∈ B j → ai • bj ∈ B (i + j)
-#align set_like.has_graded_smul SetLike.GradedSmul
--/
+#align set_like.has_graded_smul SetLike.GradedSmulₓ
 
 #print SetLike.toGSmul /-
 instance SetLike.toGSmul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]

0ebfdb71

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2022 Jujian Zhang. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jujian Zhang, Eric Wieser
 -/
-import Mathbin.Algebra.GradedMonoid
+import Algebra.GradedMonoid
 
 #align_import algebra.graded_mul_action from "leanprover-community/mathlib"@"0ebfdb71919ac6ca5d7fbc61a082fa2519556818"

0ebfdb71

bump to nightly-2023-08-17-09

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

60285dcc

Diff

@@ -92,7 +92,7 @@ theorem mk_smul_mk [Add ι] [GSmul A M] {i j} (a : A i) (b : M j) :
 /-- A graded version of `mul_action`. -/
 class GMulAction [AddMonoid ι] [GMonoid A] extends GSmul A M where
   one_smul (b : GradedMonoid M) : (1 : GradedMonoid A) • b = b
-  mul_smul (a a' : GradedMonoid A) (b : GradedMonoid M) : (a * a') • b = a • a' • b
+  hMul_smul (a a' : GradedMonoid A) (b : GradedMonoid M) : (a * a') • b = a • a' • b
 #align graded_monoid.gmul_action GradedMonoid.GMulAction
 -/
 
@@ -100,8 +100,8 @@ class GMulAction [AddMonoid ι] [GMonoid A] extends GSmul A M where
 /-- The graded version of `monoid.to_mul_action`. -/
 instance GMonoid.toGMulAction [AddMonoid ι] [GMonoid A] : GMulAction A A :=
   { GMul.toGSmul _ with
-    one_smul := GMonoid.one_mul
-    mul_smul := GMonoid.mul_assoc }
+    one_smul := GMonoid.one_hMul
+    hMul_smul := GMonoid.hMul_assoc }
 #align graded_monoid.gmonoid.to_gmul_action GradedMonoid.GMonoid.toGMulAction
 -/
 
@@ -110,7 +110,7 @@ instance GMulAction.toMulAction [AddMonoid ι] [GMonoid A] [GMulAction A M] :
     MulAction (GradedMonoid A) (GradedMonoid M)
     where
   one_smul := GMulAction.one_smul
-  mul_smul := GMulAction.mul_smul
+  hMul_smul := GMulAction.hMul_smul
 #align graded_monoid.gmul_action.to_mul_action GradedMonoid.GMulAction.toMulAction
 -/
 
@@ -154,7 +154,7 @@ theorem SetLike.coe_GSmul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R
 /-- Internally graded version of `has_mul.to_has_smul`. -/
 instance SetLike.GradedMul.toGradedSmul [AddMonoid ι] [Monoid R] {S : Type _} [SetLike S R]
     (A : ι → S) [SetLike.GradedMonoid A] : SetLike.GradedSmul A A
-    where smul_mem i j ai bj hi hj := SetLike.GradedMonoid.mul_mem hi hj
+    where smul_mem i j ai bj hi hj := SetLike.GradedMonoid.hMul_mem hi hj
 #align set_like.has_graded_mul.to_has_graded_smul SetLike.GradedMul.toGradedSmul
 -/

0ebfdb71

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2022 Jujian Zhang. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jujian Zhang, Eric Wieser
-
-! This file was ported from Lean 3 source module algebra.graded_mul_action
-! leanprover-community/mathlib commit 0ebfdb71919ac6ca5d7fbc61a082fa2519556818
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.GradedMonoid
 
+#align_import algebra.graded_mul_action from "leanprover-community/mathlib"@"0ebfdb71919ac6ca5d7fbc61a082fa2519556818"
+
 /-!
 # Additively-graded multiplicative action structures

0ebfdb71

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -84,10 +84,12 @@ instance GSmul.toSMul [Add ι] [GSmul A M] : SMul (GradedMonoid A) (GradedMonoid
 #align graded_monoid.ghas_smul.to_has_smul GradedMonoid.GSmul.toSMul
 -/
 
+#print GradedMonoid.mk_smul_mk /-
 theorem mk_smul_mk [Add ι] [GSmul A M] {i j} (a : A i) (b : M j) :
     mk i a • mk j b = mk (i + j) (GSmul.smul a b) :=
   rfl
 #align graded_monoid.mk_smul_mk GradedMonoid.mk_smul_mk
+-/
 
 #print GradedMonoid.GMulAction /-
 /-- A graded version of `mul_action`. -/
@@ -142,18 +144,22 @@ instance SetLike.toGSmul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R
 #align set_like.ghas_smul SetLike.toGSmul
 -/
 
+#print SetLike.coe_GSmul /-
 @[simp]
 theorem SetLike.coe_GSmul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
     (A : ι → S) (B : ι → N) [SetLike.GradedSmul A B] {i j : ι} (x : A i) (y : B j) :
     (@GradedMonoid.GSmul.smul ι (fun i => A i) (fun i => B i) _ _ i j x y : M) = (x : R) • y :=
   rfl
 #align set_like.coe_ghas_smul SetLike.coe_GSmul
+-/
 
+#print SetLike.GradedMul.toGradedSmul /-
 /-- Internally graded version of `has_mul.to_has_smul`. -/
 instance SetLike.GradedMul.toGradedSmul [AddMonoid ι] [Monoid R] {S : Type _} [SetLike S R]
     (A : ι → S) [SetLike.GradedMonoid A] : SetLike.GradedSmul A A
     where smul_mem i j ai bj hi hj := SetLike.GradedMonoid.mul_mem hi hj
 #align set_like.has_graded_mul.to_has_graded_smul SetLike.GradedMul.toGradedSmul
+-/
 
 end Subobjects
 
@@ -161,11 +167,13 @@ section HomogeneousElements
 
 variable {S R N M : Type _} [SetLike S R] [SetLike N M]
 
+#print SetLike.Homogeneous.graded_smul /-
 theorem SetLike.Homogeneous.graded_smul [Add ι] [SMul R M] {A : ι → S} {B : ι → N}
     [SetLike.GradedSmul A B] {a : R} {b : M} :
     SetLike.Homogeneous A a → SetLike.Homogeneous B b → SetLike.Homogeneous B (a • b)
   | ⟨i, hi⟩, ⟨j, hj⟩ => ⟨i + j, SetLike.GradedSmul.smul_mem hi hj⟩
 #align set_like.is_homogeneous.graded_smul SetLike.Homogeneous.graded_smul
+-/
 
 end HomogeneousElements

0ebfdb71

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -129,7 +129,7 @@ variable {R : Type _}
 #print SetLike.GradedSmul /-
 /-- A version of `graded_monoid.ghas_smul` for internally graded objects. -/
 class SetLike.GradedSmul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
-  (A : ι → S) (B : ι → N) : Prop where
+    (A : ι → S) (B : ι → N) : Prop where
   smul_mem : ∀ ⦃i j : ι⦄ {ai bj}, ai ∈ A i → bj ∈ B j → ai • bj ∈ B (i + j)
 #align set_like.has_graded_smul SetLike.GradedSmul
 -/

0ebfdb71

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -84,12 +84,6 @@ instance GSmul.toSMul [Add ι] [GSmul A M] : SMul (GradedMonoid A) (GradedMonoid
 #align graded_monoid.ghas_smul.to_has_smul GradedMonoid.GSmul.toSMul
 -/
 
-/- warning: graded_monoid.mk_smul_mk -> GradedMonoid.mk_smul_mk is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} (A : ι -> Type.{u2}) (M : ι -> Type.{u3}) [_inst_1 : Add.{u1} ι] [_inst_2 : GradedMonoid.GSmul.{u1, u2, u3} ι A M _inst_1] {i : ι} {j : ι} (a : A i) (b : M j), Eq.{succ (max u1 u3)} (GradedMonoid.{u1, u3} ι (fun {j : ι} => M j)) (SMul.smul.{max u1 u2, max u1 u3} (GradedMonoid.{u1, u2} ι (fun {i : ι} => A i)) (GradedMonoid.{u1, u3} ι (fun {j : ι} => M j)) (GradedMonoid.GSmul.toSMul.{u1, u2, u3} ι (fun {i : ι} => A i) (fun {j : ι} => M j) _inst_1 _inst_2) (GradedMonoid.mk.{u1, u2} ι (fun {i : ι} => A i) i a) (GradedMonoid.mk.{u1, u3} ι (fun {j : ι} => M j) j b)) (GradedMonoid.mk.{u1, u3} ι (fun {j : ι} => M j) (HAdd.hAdd.{u1, u1, u1} ι ι ι (instHAdd.{u1} ι _inst_1) i j) (GradedMonoid.GSmul.smul.{u1, u2, u3} ι (fun {i : ι} => A i) M _inst_1 _inst_2 i j a b))
-but is expected to have type
-  forall {ι : Type.{u3}} (A : ι -> Type.{u2}) (M : ι -> Type.{u1}) [_inst_1 : Add.{u3} ι] [_inst_2 : GradedMonoid.GSmul.{u3, u2, u1} ι A M _inst_1] {i : ι} {j : ι} (a : A i) (b : M j), Eq.{max (succ u3) (succ u1)} (GradedMonoid.{u3, u1} ι M) (HSMul.hSMul.{max u2 u3, max u1 u3, max u3 u1} (GradedMonoid.{u3, u2} ι A) (GradedMonoid.{u3, u1} ι M) (GradedMonoid.{u3, u1} ι M) (instHSMul.{max u3 u2, max u3 u1} (GradedMonoid.{u3, u2} ι A) (GradedMonoid.{u3, u1} ι M) (GradedMonoid.GSmul.toSMul.{u3, u2, u1} ι A M _inst_1 _inst_2)) (GradedMonoid.mk.{u3, u2} ι A i a) (GradedMonoid.mk.{u3, u1} ι M j b)) (GradedMonoid.mk.{u3, u1} ι M (HAdd.hAdd.{u3, u3, u3} ι ι ι (instHAdd.{u3} ι _inst_1) i j) (GradedMonoid.GSmul.smul.{u3, u2, u1} ι A M _inst_1 _inst_2 i j a b))
-Case conversion may be inaccurate. Consider using '#align graded_monoid.mk_smul_mk GradedMonoid.mk_smul_mkₓ'. -/
 theorem mk_smul_mk [Add ι] [GSmul A M] {i j} (a : A i) (b : M j) :
     mk i a • mk j b = mk (i + j) (GSmul.smul a b) :=
   rfl
@@ -148,9 +142,6 @@ instance SetLike.toGSmul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R
 #align set_like.ghas_smul SetLike.toGSmul
 -/
 
-/- warning: set_like.coe_ghas_smul -> SetLike.coe_GSmul is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align set_like.coe_ghas_smul SetLike.coe_GSmulₓ'. -/
 @[simp]
 theorem SetLike.coe_GSmul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
     (A : ι → S) (B : ι → N) [SetLike.GradedSmul A B] {i j : ι} (x : A i) (y : B j) :
@@ -158,12 +149,6 @@ theorem SetLike.coe_GSmul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R
   rfl
 #align set_like.coe_ghas_smul SetLike.coe_GSmul
 
-/- warning: set_like.has_graded_mul.to_has_graded_smul -> SetLike.GradedMul.toGradedSmul is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : Monoid.{u2} R] {S : Type.{u3}} [_inst_3 : SetLike.{u3, u2} S R] (A : ι -> S) [_inst_4 : SetLike.GradedMonoid.{u1, u2, u3} ι R S _inst_3 _inst_2 _inst_1 A], SetLike.GradedSmul.{u1, u3, u2, u3, u2} ι S R S R _inst_3 _inst_3 (Mul.toSMul.{u2} R (MulOneClass.toHasMul.{u2} R (Monoid.toMulOneClass.{u2} R _inst_2))) (AddZeroClass.toHasAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)) A A
-but is expected to have type
-  forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : AddMonoid.{u1} ι] [_inst_2 : Monoid.{u2} R] {S : Type.{u3}} [_inst_3 : SetLike.{u3, u2} S R] (A : ι -> S) [_inst_4 : SetLike.GradedMonoid.{u1, u2, u3} ι R S _inst_3 _inst_2 _inst_1 A], SetLike.GradedSmul.{u1, u3, u2, u3, u2} ι S R S R _inst_3 _inst_3 (MulAction.toSMul.{u2, u2} R R _inst_2 (Monoid.toMulAction.{u2} R _inst_2)) (AddZeroClass.toAdd.{u1} ι (AddMonoid.toAddZeroClass.{u1} ι _inst_1)) A A
-Case conversion may be inaccurate. Consider using '#align set_like.has_graded_mul.to_has_graded_smul SetLike.GradedMul.toGradedSmulₓ'. -/
 /-- Internally graded version of `has_mul.to_has_smul`. -/
 instance SetLike.GradedMul.toGradedSmul [AddMonoid ι] [Monoid R] {S : Type _} [SetLike S R]
     (A : ι → S) [SetLike.GradedMonoid A] : SetLike.GradedSmul A A
@@ -176,12 +161,6 @@ section HomogeneousElements
 
 variable {S R N M : Type _} [SetLike S R] [SetLike N M]
 
-/- warning: set_like.is_homogeneous.graded_smul -> SetLike.Homogeneous.graded_smul is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {S : Type.{u2}} {R : Type.{u3}} {N : Type.{u4}} {M : Type.{u5}} [_inst_1 : SetLike.{u2, u3} S R] [_inst_2 : SetLike.{u4, u5} N M] [_inst_3 : Add.{u1} ι] [_inst_4 : SMul.{u3, u5} R M] {A : ι -> S} {B : ι -> N} [_inst_5 : SetLike.GradedSmul.{u1, u2, u3, u4, u5} ι S R N M _inst_1 _inst_2 _inst_4 _inst_3 A B] {a : R} {b : M}, (SetLike.Homogeneous.{u1, u3, u2} ι R S _inst_1 A a) -> (SetLike.Homogeneous.{u1, u5, u4} ι M N _inst_2 B b) -> (SetLike.Homogeneous.{u1, u5, u4} ι M N _inst_2 B (SMul.smul.{u3, u5} R M _inst_4 a b))
-but is expected to have type
-  forall {ι : Type.{u5}} {S : Type.{u2}} {R : Type.{u4}} {N : Type.{u1}} {M : Type.{u3}} [_inst_1 : SetLike.{u2, u4} S R] [_inst_2 : SetLike.{u1, u3} N M] [_inst_3 : Add.{u5} ι] [_inst_4 : SMul.{u4, u3} R M] {A : ι -> S} {B : ι -> N} [_inst_5 : SetLike.GradedSmul.{u5, u2, u4, u1, u3} ι S R N M _inst_1 _inst_2 _inst_4 _inst_3 A B] {a : R} {b : M}, (SetLike.Homogeneous.{u5, u4, u2} ι R S _inst_1 A a) -> (SetLike.Homogeneous.{u5, u3, u1} ι M N _inst_2 B b) -> (SetLike.Homogeneous.{u5, u3, u1} ι M N _inst_2 B (HSMul.hSMul.{u4, u3, u3} R M M (instHSMul.{u4, u3} R M _inst_4) a b))
-Case conversion may be inaccurate. Consider using '#align set_like.is_homogeneous.graded_smul SetLike.Homogeneous.graded_smulₓ'. -/
 theorem SetLike.Homogeneous.graded_smul [Add ι] [SMul R M] {A : ι → S} {B : ι → N}
     [SetLike.GradedSmul A B] {a : R} {b : M} :
     SetLike.Homogeneous A a → SetLike.Homogeneous B b → SetLike.Homogeneous B (a • b)

0ebfdb71

bump to nightly-2023-05-28-03

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

6c6011cf

Diff

@@ -149,10 +149,7 @@ instance SetLike.toGSmul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R
 -/
 
 /- warning: set_like.coe_ghas_smul -> SetLike.coe_GSmul is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {S : Type.{u2}} {R : Type.{u3}} {N : Type.{u4}} {M : Type.{u5}} [_inst_1 : SetLike.{u2, u3} S R] [_inst_2 : SetLike.{u4, u5} N M] [_inst_3 : SMul.{u3, u5} R M] [_inst_4 : Add.{u1} ι] (A : ι -> S) (B : ι -> N) [_inst_5 : SetLike.GradedSmul.{u1, u2, u3, u4, u5} ι S R N M _inst_1 _inst_2 _inst_3 _inst_4 A B] {i : ι} {j : ι} (x : coeSort.{succ u2, succ (succ u3)} S Type.{u3} (SetLike.hasCoeToSort.{u2, u3} S R _inst_1) (A i)) (y : coeSort.{succ u4, succ (succ u5)} N Type.{u5} (SetLike.hasCoeToSort.{u4, u5} N M _inst_2) (B j)), Eq.{succ u5} M ((fun (a : Type.{u5}) (b : Type.{u5}) [self : HasLiftT.{succ u5, succ u5} a b] => self.0) ((fun (i : ι) => coeSort.{succ u4, succ (succ u5)} N Type.{u5} (SetLike.hasCoeToSort.{u4, u5} N M _inst_2) (B i)) (HAdd.hAdd.{u1, u1, u1} ι ι ι (instHAdd.{u1} ι _inst_4) i j)) M (HasLiftT.mk.{succ u5, succ u5} ((fun (i : ι) => coeSort.{succ u4, succ (succ u5)} N Type.{u5} (SetLike.hasCoeToSort.{u4, u5} N M _inst_2) (B i)) (HAdd.hAdd.{u1, u1, u1} ι ι ι (instHAdd.{u1} ι _inst_4) i j)) M (CoeTCₓ.coe.{succ u5, succ u5} ((fun (i : ι) => coeSort.{succ u4, succ (succ u5)} N Type.{u5} (SetLike.hasCoeToSort.{u4, u5} N M _inst_2) (B i)) (HAdd.hAdd.{u1, u1, u1} ι ι ι (instHAdd.{u1} ι _inst_4) i j)) M (coeBase.{succ u5, succ u5} ((fun (i : ι) => coeSort.{succ u4, succ (succ u5)} N Type.{u5} (SetLike.hasCoeToSort.{u4, u5} N M _inst_2) (B i)) (HAdd.hAdd.{u1, u1, u1} ι ι ι (instHAdd.{u1} ι _inst_4) i j)) M (coeSubtype.{succ u5} M (fun (x : M) => Membership.Mem.{u5, u4} M N (SetLike.hasMem.{u4, u5} N M _inst_2) x (B (HAdd.hAdd.{u1, u1, u1} ι ι ι (instHAdd.{u1} ι _inst_4) i j))))))) (GradedMonoid.GSmul.smul.{u1, u3, u5} ι (fun (i : ι) => coeSort.{succ u2, succ (succ u3)} S Type.{u3} (SetLike.hasCoeToSort.{u2, u3} S R _inst_1) (A i)) (fun (i : ι) => coeSort.{succ u4, succ (succ u5)} N Type.{u5} (SetLike.hasCoeToSort.{u4, u5} N M _inst_2) (B i)) _inst_4 (SetLike.toGSmul.{u1, u2, u3, u4, u5} ι S R N M _inst_1 _inst_2 _inst_3 _inst_4 (fun (i : ι) => A i) (fun (i : ι) => B i) _inst_5) i j x y)) (SMul.smul.{u3, u5} R M _inst_3 ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (coeSort.{succ u2, succ (succ u3)} S Type.{u3} (SetLike.hasCoeToSort.{u2, u3} S R _inst_1) (A i)) R (HasLiftT.mk.{succ u3, succ u3} (coeSort.{succ u2, succ (succ u3)} S Type.{u3} (SetLike.hasCoeToSort.{u2, u3} S R _inst_1) (A i)) R (CoeTCₓ.coe.{succ u3, succ u3} (coeSort.{succ u2, succ (succ u3)} S Type.{u3} (SetLike.hasCoeToSort.{u2, u3} S R _inst_1) (A i)) R (coeBase.{succ u3, succ u3} (coeSort.{succ u2, succ (succ u3)} S Type.{u3} (SetLike.hasCoeToSort.{u2, u3} S R _inst_1) (A i)) R (coeSubtype.{succ u3} R (fun (x : R) => Membership.Mem.{u3, u2} R S (SetLike.hasMem.{u2, u3} S R _inst_1) x (A i)))))) x) ((fun (a : Type.{u5}) (b : Type.{u5}) [self : HasLiftT.{succ u5, succ u5} a b] => self.0) (coeSort.{succ u4, succ (succ u5)} N Type.{u5} (SetLike.hasCoeToSort.{u4, u5} N M _inst_2) (B j)) M (HasLiftT.mk.{succ u5, succ u5} (coeSort.{succ u4, succ (succ u5)} N Type.{u5} (SetLike.hasCoeToSort.{u4, u5} N M _inst_2) (B j)) M (CoeTCₓ.coe.{succ u5, succ u5} (coeSort.{succ u4, succ (succ u5)} N Type.{u5} (SetLike.hasCoeToSort.{u4, u5} N M _inst_2) (B j)) M (coeBase.{succ u5, succ u5} (coeSort.{succ u4, succ (succ u5)} N Type.{u5} (SetLike.hasCoeToSort.{u4, u5} N M _inst_2) (B j)) M (coeSubtype.{succ u5} M (fun (x : M) => Membership.Mem.{u5, u4} M N (SetLike.hasMem.{u4, u5} N M _inst_2) x (B j)))))) y))
-but is expected to have type
-  forall {ι : Type.{u1}} {S : Type.{u5}} {R : Type.{u4}} {N : Type.{u3}} {M : Type.{u2}} [_inst_1 : SetLike.{u5, u4} S R] [_inst_2 : SetLike.{u3, u2} N M] [_inst_3 : SMul.{u4, u2} R M] [_inst_4 : Add.{u1} ι] (A : ι -> S) (B : ι -> N) [_inst_5 : SetLike.GradedSmul.{u1, u5, u4, u3, u2} ι S R N M _inst_1 _inst_2 _inst_3 _inst_4 A B] {i : ι} {j : ι} (x : Subtype.{succ u4} R (fun (x : R) => Membership.mem.{u4, u5} R S (SetLike.instMembership.{u5, u4} S R _inst_1) x (A i))) (y : Subtype.{succ u2} M (fun (x : M) => Membership.mem.{u2, u3} M N (SetLike.instMembership.{u3, u2} N M _inst_2) x (B j))), Eq.{succ u2} M (Subtype.val.{succ u2} M (fun (x : M) => Membership.mem.{u2, u2} M (Set.{u2} M) (Set.instMembershipSet.{u2} M) x (SetLike.coe.{u3, u2} N M _inst_2 (B (HAdd.hAdd.{u1, u1, u1} ι ι ι (instHAdd.{u1} ι _inst_4) i j)))) (GradedMonoid.GSmul.smul.{u1, u4, u2} ι (fun (i : ι) => Subtype.{succ u4} R (fun (x : R) => Membership.mem.{u4, u5} R S (SetLike.instMembership.{u5, u4} S R _inst_1) x (A i))) (fun (i : ι) => Subtype.{succ u2} M (fun (x : M) => Membership.mem.{u2, u3} M N (SetLike.instMembership.{u3, u2} N M _inst_2) x (B i))) _inst_4 (SetLike.toGSmul.{u1, u5, u4, u3, u2} ι S R N M _inst_1 _inst_2 _inst_3 _inst_4 (fun (i : ι) => A i) (fun (i : ι) => B i) _inst_5) i j x y)) (HSMul.hSMul.{u4, u2, u2} R M M (instHSMul.{u4, u2} R M _inst_3) (Subtype.val.{succ u4} R (fun (x : R) => Membership.mem.{u4, u5} R S (SetLike.instMembership.{u5, u4} S R _inst_1) x (A i)) x) (Subtype.val.{succ u2} M (fun (x : M) => Membership.mem.{u2, u3} M N (SetLike.instMembership.{u3, u2} N M _inst_2) x (B j)) y))
+<too large>
 Case conversion may be inaccurate. Consider using '#align set_like.coe_ghas_smul SetLike.coe_GSmulₓ'. -/
 @[simp]
 theorem SetLike.coe_GSmul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]

0ebfdb71

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

861a2692

doc: fix typos in tags header (#11088)

Fix 1 typo, 5 lowercase, 4 header depths

ab90a4e3

Diff

@@ -41,7 +41,7 @@ Note that there is no need for `SetLike.graded_mul_action` or similar, as all th
 would contain is already supplied by `GradedSMul` when the objects within `A` and `M` have
 a `MulAction` instance.
 
-## tags
+## Tags
 
 graded action
 -/

861a2692

chore: Nsmul -> NSMul, Zpow -> ZPow, etc (#9067)

Normalising to naming convention rule number 6.

9b2f0dca

Diff

@@ -14,7 +14,7 @@ This module provides a set of heterogeneous typeclasses for defining a multiplic
 over the sigma type `GradedMonoid A` such that `(•) : A i → M j → M (i +ᵥ j)`; that is to say, `A`
 has an additively-graded multiplicative action on `M`. The typeclasses are:
 
-* `GradedMonoid.GSmul A M`
+* `GradedMonoid.GSMul A M`
 * `GradedMonoid.GMulAction A M`
 
 With the `SigmaGraded` locale open, these respectively imbue:
@@ -31,14 +31,14 @@ In addition to the above typeclasses, in the most frequent case when `A` is an i
 `SetLike` subobjects (such as `AddSubmonoid`s, `AddSubgroup`s, or `Submodule`s), this file
 provides the `Prop` typeclasses:
 
-* `SetLike.GradedSmul A M` (which provides the obvious `GradedMonoid.GSmul A` instance)
+* `SetLike.GradedSMul A M` (which provides the obvious `GradedMonoid.GSMul A` instance)
 
 which provides the API lemma
 
 * `SetLike.graded_smul_mem_graded`
 
 Note that there is no need for `SetLike.graded_mul_action` or similar, as all the information it
-would contain is already supplied by `GradedSmul` when the objects within `A` and `M` have
+would contain is already supplied by `GradedSMul` when the objects within `A` and `M` have
 a `MulAction` instance.
 
 ## tags
@@ -60,26 +60,26 @@ variable (A : ιA → Type*) (M : ιM → Type*)
 
 /-- A graded version of `SMul`. Scalar multiplication combines grades additively, i.e.
 if `a ∈ A i` and `m ∈ M j`, then `a • b` must be in `M (i + j)`-/
-class GSmul [VAdd ιA ιM] where
+class GSMul [VAdd ιA ιM] where
   /-- The homogeneous multiplication map `smul` -/
   smul {i j} : A i → M j → M (i +ᵥ j)
-#align graded_monoid.ghas_smul GradedMonoid.GSmul
+#align graded_monoid.ghas_smul GradedMonoid.GSMul
 
 /-- A graded version of `Mul.toSMul` -/
-instance GMul.toGSmul [Add ιA] [GMul A] : GSmul A A where smul := GMul.mul
-#align graded_monoid.ghas_mul.to_ghas_smul GradedMonoid.GMul.toGSmul
+instance GMul.toGSMul [Add ιA] [GMul A] : GSMul A A where smul := GMul.mul
+#align graded_monoid.ghas_mul.to_ghas_smul GradedMonoid.GMul.toGSMul
 
-instance GSmul.toSMul [VAdd ιA ιM] [GSmul A M] : SMul (GradedMonoid A) (GradedMonoid M) :=
-  ⟨fun x y ↦ ⟨_, GSmul.smul x.snd y.snd⟩⟩
-#align graded_monoid.ghas_smul.to_has_smul GradedMonoid.GSmul.toSMul
+instance GSMul.toSMul [VAdd ιA ιM] [GSMul A M] : SMul (GradedMonoid A) (GradedMonoid M) :=
+  ⟨fun x y ↦ ⟨_, GSMul.smul x.snd y.snd⟩⟩
+#align graded_monoid.ghas_smul.to_has_smul GradedMonoid.GSMul.toSMul
 
-theorem mk_smul_mk [VAdd ιA ιM] [GSmul A M] {i j} (a : A i) (b : M j) :
-    mk i a • mk j b = mk (i +ᵥ j) (GSmul.smul a b) :=
+theorem mk_smul_mk [VAdd ιA ιM] [GSMul A M] {i j} (a : A i) (b : M j) :
+    mk i a • mk j b = mk (i +ᵥ j) (GSMul.smul a b) :=
   rfl
 #align graded_monoid.mk_smul_mk GradedMonoid.mk_smul_mk
 
 /-- A graded version of `MulAction`. -/
-class GMulAction [AddMonoid ιA] [VAdd ιA ιM] [GMonoid A] extends GSmul A M where
+class GMulAction [AddMonoid ιA] [VAdd ιA ιM] [GMonoid A] extends GSMul A M where
   /-- One is the neutral element for `•` -/
   one_smul (b : GradedMonoid M) : (1 : GradedMonoid A) • b = b
   /-- Associativity of `•` and `*` -/
@@ -88,7 +88,7 @@ class GMulAction [AddMonoid ιA] [VAdd ιA ιM] [GMonoid A] extends GSmul A M wh
 
 /-- The graded version of `Monoid.toMulAction`. -/
 instance GMonoid.toGMulAction [AddMonoid ιA] [GMonoid A] : GMulAction A A :=
-  { GMul.toGSmul _ with
+  { GMul.toGSMul _ with
     one_smul := GMonoid.one_mul
     mul_smul := GMonoid.mul_assoc }
 #align graded_monoid.gmonoid.to_gmul_action GradedMonoid.GMonoid.toGMulAction
@@ -111,39 +111,39 @@ section Subobjects
 
 variable {R : Type*}
 
-/-- A version of `GradedMonoid.GSmul` for internally graded objects. -/
-class SetLike.GradedSmul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [VAdd ιA ιB]
+/-- A version of `GradedMonoid.GSMul` for internally graded objects. -/
+class SetLike.GradedSMul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [VAdd ιA ιB]
   (A : ιA → S) (B : ιB → N) : Prop where
   /-- Multiplication is homogeneous -/
   smul_mem : ∀ ⦃i : ιA⦄ ⦃j : ιB⦄ {ai bj}, ai ∈ A i → bj ∈ B j → ai • bj ∈ B (i +ᵥ j)
-#align set_like.has_graded_smul SetLike.GradedSmul
+#align set_like.has_graded_smul SetLike.GradedSMul
 
-instance SetLike.toGSmul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [VAdd ιA ιB]
-    (A : ιA → S) (B : ιB → N) [SetLike.GradedSmul A B] :
-    GradedMonoid.GSmul (fun i ↦ A i) fun i ↦ B i where
-  smul a b := ⟨a.1 • b.1, SetLike.GradedSmul.smul_mem a.2 b.2⟩
-#align set_like.ghas_smul SetLike.toGSmul
+instance SetLike.toGSMul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [VAdd ιA ιB]
+    (A : ιA → S) (B : ιB → N) [SetLike.GradedSMul A B] :
+    GradedMonoid.GSMul (fun i ↦ A i) fun i ↦ B i where
+  smul a b := ⟨a.1 • b.1, SetLike.GradedSMul.smul_mem a.2 b.2⟩
+#align set_like.ghas_smul SetLike.toGSMul
 
 /-
 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 {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
-    (A : ι → S) (B : ι → N) [SetLike.GradedSmul A B] {i j : ι} (x : A i) (y : B j) :
-    (@GradedMonoid.GSmul.smul ι (fun i ↦ A i) (fun i ↦ B i) _ _ i j x y : M) = x.1 • y.1 := by simp
+    (A : ι → S) (B : ι → N) [SetLike.GradedSMul A B] {i j : ι} (x : A i) (y : B j) :
+    (@GradedMonoid.GSMul.smul ι (fun i ↦ A i) (fun i ↦ B i) _ _ i j x y : M) = x.1 • y.1 := by simp
 -/
 @[simp,nolint simpNF]
-theorem SetLike.coe_GSmul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [VAdd ιA ιB]
-    (A : ιA → S) (B : ιB → N) [SetLike.GradedSmul A B] {i : ιA} {j : ιB} (x : A i) (y : B j) :
-    (@GradedMonoid.GSmul.smul ιA ιB (fun i ↦ A i) (fun i ↦ B i) _ _ i j x y : M) = x.1 • y.1 :=
+theorem SetLike.coe_GSMul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [VAdd ιA ιB]
+    (A : ιA → S) (B : ιB → N) [SetLike.GradedSMul A B] {i : ιA} {j : ιB} (x : A i) (y : B j) :
+    (@GradedMonoid.GSMul.smul ιA ιB (fun i ↦ A i) (fun i ↦ B i) _ _ i j x y : M) = x.1 • y.1 :=
   rfl
-#align set_like.coe_ghas_smul SetLike.coe_GSmul
+#align set_like.coe_ghas_smul SetLike.coe_GSMul
 
 /-- Internally graded version of `Mul.toSMul`. -/
-instance SetLike.GradedMul.toGradedSmul [AddMonoid ιA] [Monoid R] {S : Type*} [SetLike S R]
-    (A : ιA → S) [SetLike.GradedMonoid A] : SetLike.GradedSmul A A where
+instance SetLike.GradedMul.toGradedSMul [AddMonoid ιA] [Monoid R] {S : Type*} [SetLike S R]
+    (A : ιA → S) [SetLike.GradedMonoid A] : SetLike.GradedSMul A A where
   smul_mem _ _ _ _ hi hj := SetLike.GradedMonoid.toGradedMul.mul_mem hi hj
-#align set_like.has_graded_mul.to_has_graded_smul SetLike.GradedMul.toGradedSmul
+#align set_like.has_graded_mul.to_has_graded_smul SetLike.GradedMul.toGradedSMul
 
 end Subobjects
 
@@ -152,9 +152,9 @@ section HomogeneousElements
 variable {S R N M : Type*} [SetLike S R] [SetLike N M]
 
 theorem SetLike.Homogeneous.graded_smul [VAdd ιA ιB] [SMul R M] {A : ιA → S} {B : ιB → N}
-    [SetLike.GradedSmul A B] {a : R} {b : M} :
+    [SetLike.GradedSMul A B] {a : R} {b : M} :
     SetLike.Homogeneous A a → SetLike.Homogeneous B b → SetLike.Homogeneous B (a • b)
-  | ⟨i, hi⟩, ⟨j, hj⟩ => ⟨i +ᵥ j, SetLike.GradedSmul.smul_mem hi hj⟩
+  | ⟨i, hi⟩, ⟨j, hj⟩ => ⟨i +ᵥ j, SetLike.GradedSMul.smul_mem hi hj⟩
 #align set_like.is_homogeneous.graded_smul SetLike.Homogeneous.graded_smul
 
 end HomogeneousElements

861a2692

chore: remove some double spaces (#7983)

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

24cd315a

Diff

@@ -47,7 +47,7 @@ graded action
 -/
 
 
-variable {ιA ιB ιM  : Type*}
+variable {ιA ιB ιM : Type*}
 
 namespace GradedMonoid

861a2692

feat(Algebra/Module/GradedModule): generalize + to +ᵥ in indicies (#7573)

The action is now of signature A i → M j → M (i +ᵥ j) instead of A i → M j → M (i + j). These are defeq when i and j are of the same type.

This allow the grading type of the ring and module to be different, as long as one acts additively on the other, as requested on Zulip:

@AntoineChambert-Loir said:

In our work with Maria Ines, we had the impression that some basic work on graded stuff is still missing. For example, [...] graduations which are not indexed by the same thing on the ring and on the module (some action of one on the other would be required, of course )

@kbuzzard said:

In alg geom it's pretty common to have the rings indexed by $ℕ$ and the modules by $ℤ$.

Mathlib is rather short on instances for additive actions, but with suitable instances this will allow the ring to be ℕ-graded and the module to be ℤ-graded.

d3c0421b

Diff

@@ -11,7 +11,7 @@ import Mathlib.Algebra.GradedMonoid
 # Additively-graded multiplicative action structures
 
 This module provides a set of heterogeneous typeclasses for defining a multiplicative structure
-over the sigma type `GradedMonoid A` such that `(•) : A i → M j → M (i + j)`; that is to say, `A`
+over the sigma type `GradedMonoid A` such that `(•) : A i → M j → M (i +ᵥ j)`; that is to say, `A`
 has an additively-graded multiplicative action on `M`. The typeclasses are:
 
 * `GradedMonoid.GSmul A M`
@@ -47,7 +47,7 @@ graded action
 -/
 
 
-variable {ι : Type*}
+variable {ιA ιB ιM  : Type*}
 
 namespace GradedMonoid
 
@@ -56,30 +56,30 @@ namespace GradedMonoid
 
 section Defs
 
-variable (A : ι → Type*) (M : ι → Type*)
+variable (A : ιA → Type*) (M : ιM → Type*)
 
 /-- A graded version of `SMul`. Scalar multiplication combines grades additively, i.e.
 if `a ∈ A i` and `m ∈ M j`, then `a • b` must be in `M (i + j)`-/
-class GSmul [Add ι] where
+class GSmul [VAdd ιA ιM] where
   /-- The homogeneous multiplication map `smul` -/
-  smul {i j} : A i → M j → M (i + j)
+  smul {i j} : A i → M j → M (i +ᵥ j)
 #align graded_monoid.ghas_smul GradedMonoid.GSmul
 
 /-- A graded version of `Mul.toSMul` -/
-instance GMul.toGSmul [Add ι] [GMul A] : GSmul A A where smul := GMul.mul
+instance GMul.toGSmul [Add ιA] [GMul A] : GSmul A A where smul := GMul.mul
 #align graded_monoid.ghas_mul.to_ghas_smul GradedMonoid.GMul.toGSmul
 
-instance GSmul.toSMul [Add ι] [GSmul A M] : SMul (GradedMonoid A) (GradedMonoid M) :=
+instance GSmul.toSMul [VAdd ιA ιM] [GSmul A M] : SMul (GradedMonoid A) (GradedMonoid M) :=
   ⟨fun x y ↦ ⟨_, GSmul.smul x.snd y.snd⟩⟩
 #align graded_monoid.ghas_smul.to_has_smul GradedMonoid.GSmul.toSMul
 
-theorem mk_smul_mk [Add ι] [GSmul A M] {i j} (a : A i) (b : M j) :
-    mk i a • mk j b = mk (i + j) (GSmul.smul a b) :=
+theorem mk_smul_mk [VAdd ιA ιM] [GSmul A M] {i j} (a : A i) (b : M j) :
+    mk i a • mk j b = mk (i +ᵥ j) (GSmul.smul a b) :=
   rfl
 #align graded_monoid.mk_smul_mk GradedMonoid.mk_smul_mk
 
 /-- A graded version of `MulAction`. -/
-class GMulAction [AddMonoid ι] [GMonoid A] extends GSmul A M where
+class GMulAction [AddMonoid ιA] [VAdd ιA ιM] [GMonoid A] extends GSmul A M where
   /-- One is the neutral element for `•` -/
   one_smul (b : GradedMonoid M) : (1 : GradedMonoid A) • b = b
   /-- Associativity of `•` and `*` -/
@@ -87,13 +87,13 @@ class GMulAction [AddMonoid ι] [GMonoid A] extends GSmul A M where
 #align graded_monoid.gmul_action GradedMonoid.GMulAction
 
 /-- The graded version of `Monoid.toMulAction`. -/
-instance GMonoid.toGMulAction [AddMonoid ι] [GMonoid A] : GMulAction A A :=
+instance GMonoid.toGMulAction [AddMonoid ιA] [GMonoid A] : GMulAction A A :=
   { GMul.toGSmul _ with
     one_smul := GMonoid.one_mul
     mul_smul := GMonoid.mul_assoc }
 #align graded_monoid.gmonoid.to_gmul_action GradedMonoid.GMonoid.toGMulAction
 
-instance GMulAction.toMulAction [AddMonoid ι] [GMonoid A] [GMulAction A M] :
+instance GMulAction.toMulAction [AddMonoid ιA] [GMonoid A] [VAdd ιA ιM] [GMulAction A M] :
     MulAction (GradedMonoid A) (GradedMonoid M)
     where
   one_smul := GMulAction.one_smul
@@ -112,14 +112,14 @@ section Subobjects
 variable {R : Type*}
 
 /-- A version of `GradedMonoid.GSmul` for internally graded objects. -/
-class SetLike.GradedSmul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
-  (A : ι → S) (B : ι → N) : Prop where
+class SetLike.GradedSmul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [VAdd ιA ιB]
+  (A : ιA → S) (B : ιB → N) : Prop where
   /-- Multiplication is homogeneous -/
-  smul_mem : ∀ ⦃i j : ι⦄ {ai bj}, ai ∈ A i → bj ∈ B j → ai • bj ∈ B (i + j)
+  smul_mem : ∀ ⦃i : ιA⦄ ⦃j : ιB⦄ {ai bj}, ai ∈ A i → bj ∈ B j → ai • bj ∈ B (i +ᵥ j)
 #align set_like.has_graded_smul SetLike.GradedSmul
 
-instance SetLike.toGSmul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
-    (A : ι → S) (B : ι → N) [SetLike.GradedSmul A B] :
+instance SetLike.toGSmul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [VAdd ιA ιB]
+    (A : ιA → S) (B : ιB → N) [SetLike.GradedSmul A B] :
     GradedMonoid.GSmul (fun i ↦ A i) fun i ↦ B i where
   smul a b := ⟨a.1 • b.1, SetLike.GradedSmul.smul_mem a.2 b.2⟩
 #align set_like.ghas_smul SetLike.toGSmul
@@ -133,15 +133,15 @@ example {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
     (@GradedMonoid.GSmul.smul ι (fun i ↦ A i) (fun i ↦ B i) _ _ i j x y : M) = x.1 • y.1 := by simp
 -/
 @[simp,nolint simpNF]
-theorem SetLike.coe_GSmul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
-    (A : ι → S) (B : ι → N) [SetLike.GradedSmul A B] {i j : ι} (x : A i) (y : B j) :
-    (@GradedMonoid.GSmul.smul ι (fun i ↦ A i) (fun i ↦ B i) _ _ i j x y : M) = x.1 • y.1 :=
+theorem SetLike.coe_GSmul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [VAdd ιA ιB]
+    (A : ιA → S) (B : ιB → N) [SetLike.GradedSmul A B] {i : ιA} {j : ιB} (x : A i) (y : B j) :
+    (@GradedMonoid.GSmul.smul ιA ιB (fun i ↦ A i) (fun i ↦ B i) _ _ i j x y : M) = x.1 • y.1 :=
   rfl
 #align set_like.coe_ghas_smul SetLike.coe_GSmul
 
 /-- Internally graded version of `Mul.toSMul`. -/
-instance SetLike.GradedMul.toGradedSmul [AddMonoid ι] [Monoid R] {S : Type*} [SetLike S R]
-    (A : ι → S) [SetLike.GradedMonoid A] : SetLike.GradedSmul A A where
+instance SetLike.GradedMul.toGradedSmul [AddMonoid ιA] [Monoid R] {S : Type*} [SetLike S R]
+    (A : ιA → S) [SetLike.GradedMonoid A] : SetLike.GradedSmul A A where
   smul_mem _ _ _ _ hi hj := SetLike.GradedMonoid.toGradedMul.mul_mem hi hj
 #align set_like.has_graded_mul.to_has_graded_smul SetLike.GradedMul.toGradedSmul
 
@@ -151,10 +151,10 @@ section HomogeneousElements
 
 variable {S R N M : Type*} [SetLike S R] [SetLike N M]
 
-theorem SetLike.Homogeneous.graded_smul [Add ι] [SMul R M] {A : ι → S} {B : ι → N}
+theorem SetLike.Homogeneous.graded_smul [VAdd ιA ιB] [SMul R M] {A : ιA → S} {B : ιB → N}
     [SetLike.GradedSmul A B] {a : R} {b : M} :
     SetLike.Homogeneous A a → SetLike.Homogeneous B b → SetLike.Homogeneous B (a • b)
-  | ⟨i, hi⟩, ⟨j, hj⟩ => ⟨i + j, SetLike.GradedSmul.smul_mem hi hj⟩
+  | ⟨i, hi⟩, ⟨j, hj⟩ => ⟨i +ᵥ j, SetLike.GradedSmul.smul_mem hi hj⟩
 #align set_like.is_homogeneous.graded_smul SetLike.Homogeneous.graded_smul
 
 end HomogeneousElements

861a2692

style: fix wrapping of where (#7149)

084cfb35

Diff

@@ -120,8 +120,8 @@ class SetLike.GradedSmul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M
 
 instance SetLike.toGSmul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
     (A : ι → S) (B : ι → N) [SetLike.GradedSmul A B] :
-    GradedMonoid.GSmul (fun i ↦ A i) fun i ↦ B i
-    where smul a b := ⟨a.1 • b.1, SetLike.GradedSmul.smul_mem a.2 b.2⟩
+    GradedMonoid.GSmul (fun i ↦ A i) fun i ↦ B i where
+  smul a b := ⟨a.1 • b.1, SetLike.GradedSmul.smul_mem a.2 b.2⟩
 #align set_like.ghas_smul SetLike.toGSmul
 
 /-
@@ -141,8 +141,8 @@ theorem SetLike.coe_GSmul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R
 
 /-- Internally graded version of `Mul.toSMul`. -/
 instance SetLike.GradedMul.toGradedSmul [AddMonoid ι] [Monoid R] {S : Type*} [SetLike S R]
-    (A : ι → S) [SetLike.GradedMonoid A] : SetLike.GradedSmul A A
-    where smul_mem _ _ _ _ hi hj := SetLike.GradedMonoid.toGradedMul.mul_mem hi hj
+    (A : ι → S) [SetLike.GradedMonoid A] : SetLike.GradedSmul A A where
+  smul_mem _ _ _ _ hi hj := SetLike.GradedMonoid.toGradedMul.mul_mem hi hj
 #align set_like.has_graded_mul.to_has_graded_smul SetLike.GradedMul.toGradedSmul
 
 end Subobjects

861a2692

chore: banish Type _ and Sort _ (#6499)

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

This has nice performance benefits.

32de3f67

Diff

@@ -47,7 +47,7 @@ graded action
 -/
 
 
-variable {ι : Type _}
+variable {ι : Type*}
 
 namespace GradedMonoid
 
@@ -56,7 +56,7 @@ namespace GradedMonoid
 
 section Defs
 
-variable (A : ι → Type _) (M : ι → Type _)
+variable (A : ι → Type*) (M : ι → Type*)
 
 /-- A graded version of `SMul`. Scalar multiplication combines grades additively, i.e.
 if `a ∈ A i` and `m ∈ M j`, then `a • b` must be in `M (i + j)`-/
@@ -109,16 +109,16 @@ end GradedMonoid
 
 section Subobjects
 
-variable {R : Type _}
+variable {R : Type*}
 
 /-- A version of `GradedMonoid.GSmul` for internally graded objects. -/
-class SetLike.GradedSmul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
+class SetLike.GradedSmul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
   (A : ι → S) (B : ι → N) : Prop where
   /-- Multiplication is homogeneous -/
   smul_mem : ∀ ⦃i j : ι⦄ {ai bj}, ai ∈ A i → bj ∈ B j → ai • bj ∈ B (i + j)
 #align set_like.has_graded_smul SetLike.GradedSmul
 
-instance SetLike.toGSmul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
+instance SetLike.toGSmul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
     (A : ι → S) (B : ι → N) [SetLike.GradedSmul A B] :
     GradedMonoid.GSmul (fun i ↦ A i) fun i ↦ B i
     where smul a b := ⟨a.1 • b.1, SetLike.GradedSmul.smul_mem a.2 b.2⟩
@@ -128,19 +128,19 @@ instance SetLike.toGSmul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R
 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 {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
+example {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
     (A : ι → S) (B : ι → N) [SetLike.GradedSmul A B] {i j : ι} (x : A i) (y : B j) :
     (@GradedMonoid.GSmul.smul ι (fun i ↦ A i) (fun i ↦ B i) _ _ i j x y : M) = x.1 • y.1 := by simp
 -/
 @[simp,nolint simpNF]
-theorem SetLike.coe_GSmul {S R N M : Type _} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
+theorem SetLike.coe_GSmul {S R N M : Type*} [SetLike S R] [SetLike N M] [SMul R M] [Add ι]
     (A : ι → S) (B : ι → N) [SetLike.GradedSmul A B] {i j : ι} (x : A i) (y : B j) :
     (@GradedMonoid.GSmul.smul ι (fun i ↦ A i) (fun i ↦ B i) _ _ i j x y : M) = x.1 • y.1 :=
   rfl
 #align set_like.coe_ghas_smul SetLike.coe_GSmul
 
 /-- Internally graded version of `Mul.toSMul`. -/
-instance SetLike.GradedMul.toGradedSmul [AddMonoid ι] [Monoid R] {S : Type _} [SetLike S R]
+instance SetLike.GradedMul.toGradedSmul [AddMonoid ι] [Monoid R] {S : Type*} [SetLike S R]
     (A : ι → S) [SetLike.GradedMonoid A] : SetLike.GradedSmul A A
     where smul_mem _ _ _ _ hi hj := SetLike.GradedMonoid.toGradedMul.mul_mem hi hj
 #align set_like.has_graded_mul.to_has_graded_smul SetLike.GradedMul.toGradedSmul
@@ -149,7 +149,7 @@ end Subobjects
 
 section HomogeneousElements
 
-variable {S R N M : Type _} [SetLike S R] [SetLike N M]
+variable {S R N M : Type*} [SetLike S R] [SetLike N M]
 
 theorem SetLike.Homogeneous.graded_smul [Add ι] [SMul R M] {A : ι → S} {B : ι → N}
     [SetLike.GradedSmul A B] {a : R} {b : M} :

861a2692

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2022 Jujian Zhang. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jujian Zhang, Eric Wieser
-
-! This file was ported from Lean 3 source module algebra.graded_mul_action
-! leanprover-community/mathlib commit 861a26926586cd46ff80264d121cdb6fa0e35cc1
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.GradedMonoid
 
+#align_import algebra.graded_mul_action from "leanprover-community/mathlib"@"861a26926586cd46ff80264d121cdb6fa0e35cc1"
+
 /-!
 # Additively-graded multiplicative action structures

861a2692

feat: port Algebra.GradedMulAction (#1959)

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

de1a0155

`algebra.graded_mul_action` ⟷ `Mathlib.Algebra.GradedMulAction`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 2 + 163

algebra.graded_mul_action ⟷ Mathlib.Algebra.GradedMulAction

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 2 + 163

`algebra.graded_mul_action` ⟷ `Mathlib.Algebra.GradedMulAction`