File: Mathlib/Algebra/Module/GradedModule.lean

full_name: DirectSum.GdistribMulAction
code: /-- A graded version of `DistribMulAction`. -/
class GdistribMulAction [AddMonoid ιA] [VAdd ιA ιB] [GMonoid A] [∀ i, AddMonoid (M i)]
    extends GMulAction A M where
  smul_add {i j} (a : A i) (b c : M j) : smul a (b + c) = smul a b + smul a c
  smul_zero {i j} (a : A i) : smul a (0 : M j) = 0
goal: Type (max (max (max u_1 u_2) u_3) u_4)

full_name: DirectSum.GdistribMulAction.smul_add
code: /-- A graded version of `DistribMulAction`. -/
class GdistribMulAction [AddMonoid ιA] [VAdd ιA ιB] [GMonoid A] [∀ i, AddMonoid (M i)]
    extends GMulAction A M where
  smul_add {i j} (a : A i) (b c : M j) : smul a (b + c) = smul a b + smul a c
  smul_zero {i j} (a : A i) : smul a (0 : M j) = 0
goal: GradedMonoid.GSMul.smul a (b + c) = GradedMonoid.GSMul.smul a b + GradedMonoid.GSMul.smul a c

full_name: DirectSum.GdistribMulAction.smul_zero
code: /-- A graded version of `DistribMulAction`. -/
class GdistribMulAction [AddMonoid ιA] [VAdd ιA ιB] [GMonoid A] [∀ i, AddMonoid (M i)]
    extends GMulAction A M where
  smul_add {i j} (a : A i) (b c : M j) : smul a (b + c) = smul a b + smul a c
  smul_zero {i j} (a : A i) : smul a (0 : M j) = 0
goal: GradedMonoid.GSMul.smul a 0 = 0

full_name: DirectSum.Gmodule
code: /-- A graded version of `Module`. -/
class Gmodule [AddMonoid ιA] [VAdd ιA ιB] [∀ i, AddMonoid (A i)] [∀ i, AddMonoid (M i)] [GMonoid A]
    extends GdistribMulAction A M where
  add_smul {i j} (a a' : A i) (b : M j) : smul (a + a') b = smul a b + smul a' b
  zero_smul {i j} (b : M j) : smul (0 : A i) b = 0
goal: Type (max (max (max u_1 u_2) u_3) u_4)

full_name: DirectSum.Gmodule.add_smul
code: /-- A graded version of `Module`. -/
class Gmodule [AddMonoid ιA] [VAdd ιA ιB] [∀ i, AddMonoid (A i)] [∀ i, AddMonoid (M i)] [GMonoid A]
    extends GdistribMulAction A M where
  add_smul {i j} (a a' : A i) (b : M j) : smul (a + a') b = smul a b + smul a' b
  zero_smul {i j} (b : M j) : smul (0 : A i) b = 0
goal: GradedMonoid.GSMul.smul (a + a') b = GradedMonoid.GSMul.smul a b + GradedMonoid.GSMul.smul a' b

full_name: DirectSum.Gmodule.zero_smul
code: /-- A graded version of `Module`. -/
class Gmodule [AddMonoid ιA] [VAdd ιA ιB] [∀ i, AddMonoid (A i)] [∀ i, AddMonoid (M i)] [GMonoid A]
    extends GdistribMulAction A M where
  add_smul {i j} (a a' : A i) (b : M j) : smul (a + a') b = smul a b + smul a' b
  zero_smul {i j} (b : M j) : smul (0 : A i) b = 0
goal: GradedMonoid.GSMul.smul 0 b = 0

full_name: DirectSum.GSemiring.toGmodule
code: /-- A graded version of `Semiring.toModule`. -/
instance GSemiring.toGmodule [AddMonoid ιA] [∀ i : ιA, AddCommMonoid (A i)]
    [h : GSemiring A] : Gmodule A A 
goal: DirectSum.Gmodule A A

full_name: DirectSum.gsmulHom_apply_apply
code: /-- The piecewise multiplication from the `Mul` instance, as a bundled homomorphism. -/
@[simps]
def gsmulHom [GMonoid A] [Gmodule A M] {i j} : A i →+ M j →+ M (i +ᵥ j) 
goal: ((DirectSum.gsmulHom A M) a) b = GradedMonoid.GSMul.smul a b

full_name: DirectSum.gsmulHom
code: /-- The piecewise multiplication from the `Mul` instance, as a bundled homomorphism. -/
@[simps]
def gsmulHom [GMonoid A] [Gmodule A M] {i j} : A i →+ M j →+ M (i +ᵥ j) 
goal: A i →+ M j →+ M (i +ᵥ j)

full_name: DirectSum.Gmodule.smulAddMonoidHom
code: /-- For graded monoid `A` and a graded module `M` over `A`. `Gmodule.smulAddMonoidHom` is the
`⨁ᵢ Aᵢ`-scalar multiplication on `⨁ᵢ Mᵢ` induced by `gsmul_hom`. -/
def smulAddMonoidHom [DecidableEq ιA] [DecidableEq ιB] [GMonoid A] [Gmodule A M] :
    (⨁ i, A i) →+ (⨁ i, M i) →+ ⨁ i, M i 
goal: (⨁ (i : ιA), A i) →+ (⨁ (i : ιB), M i) →+ ⨁ (i : ιB), M i

full_name: DirectSum.Gmodule.instSMulOfDecidableEq
code: instance [DecidableEq ιA] [DecidableEq ιB] [GMonoid A] [Gmodule A M] :
    SMul (⨁ i, A i) (⨁ i, M i) 
goal: SMul (⨁ (i : ιA), A i) (⨁ (i : ιB), M i)

full_name: DirectSum.Gmodule.smul_def
code: @[simp]
theorem smul_def [DecidableEq ιA] [DecidableEq ιB] [GMonoid A] [Gmodule A M]
    (x : ⨁ i, A i) (y : ⨁ i, M i) :
    x • y = smulAddMonoidHom _ _ x y 
goal: x • y = ((DirectSum.Gmodule.smulAddMonoidHom A M) x) y

full_name: DirectSum.Gmodule.smulAddMonoidHom_apply_of_of
code: @[simp]
theorem smulAddMonoidHom_apply_of_of [DecidableEq ιA] [DecidableEq ιB] [GMonoid A] [Gmodule A M]
    {i j} (x : A i) (y : M j) :
    smulAddMonoidHom A M (DirectSum.of A i x) (of M j y) = of M (i +ᵥ j) (GSMul.smul x y) 
goal: ((DirectSum.Gmodule.smulAddMonoidHom A M) ((DirectSum.of A i) x)) ((DirectSum.of M j) y) =
  (DirectSum.of M (i +ᵥ j)) (GradedMonoid.GSMul.smul x y)

full_name: DirectSum.Gmodule.of_smul_of
code: theorem of_smul_of [DecidableEq ιA] [DecidableEq ιB] [GMonoid A] [Gmodule A M]
    {i j} (x : A i) (y : M j) :
    DirectSum.of A i x • of M j y = of M (i +ᵥ j) (GSMul.smul x y) 
goal: (DirectSum.of A i) x • (DirectSum.of M j) y = (DirectSum.of M (i +ᵥ j)) (GradedMonoid.GSMul.smul x y)

full_name: _private.Mathlib.Algebra.Module.GradedModule.0.DirectSum.Gmodule.one_smul'
code: private theorem one_smul' [DecidableEq ιA] [DecidableEq ιB] [GMonoid A] [Gmodule A M]
    (x : ⨁ i, M i) :
    (1 : ⨁ i, A i) • x = x 
goal: 1 • x = x

full_name: _private.Mathlib.Algebra.Module.GradedModule.0.DirectSum.Gmodule.mul_smul'
code: private theorem mul_smul' [DecidableEq ιA] [DecidableEq ιB] [GSemiring A] [Gmodule A M]
    (a b : ⨁ i, A i)
    (c : ⨁ i, M i) : (a * b) • c = a • b • c 
goal: (a * b) • c = a • b • c

full_name: DirectSum.Gmodule.module
code: /-- The `Module` derived from `gmodule A M`. -/
instance module [DecidableEq ιA] [DecidableEq ιB] [GSemiring A] [Gmodule A M] :
    Module (⨁ i, A i) (⨁ i, M i) 
goal: Module (⨁ (i : ιA), A i) (⨁ (i : ιB), M i)

full_name: SetLike.gmulAction
code: instance gmulAction [AddMonoid M] [DistribMulAction A M] [SetLike σ M] [SetLike.GradedMonoid 𝓐]
    [SetLike.GradedSMul 𝓐 𝓜] : GradedMonoid.GMulAction (fun i => 𝓐 i) fun i => 𝓜 i 
goal: GradedMonoid.GMulAction (fun i => ↥(𝓐 i)) fun i => ↥(𝓜 i)

full_name: SetLike.gdistribMulAction
code: instance gdistribMulAction [AddMonoid M] [DistribMulAction A M] [SetLike σ M]
    [AddSubmonoidClass σ M] [SetLike.GradedMonoid 𝓐] [SetLike.GradedSMul 𝓐 𝓜] :
    DirectSum.GdistribMulAction (fun i => 𝓐 i) fun i => 𝓜 i 
goal: DirectSum.GdistribMulAction (fun i => ↥(𝓐 i)) fun i => ↥(𝓜 i)

full_name: SetLike.gmodule
code: /-- `[SetLike.GradedMonoid 𝓐] [SetLike.GradedSMul 𝓐 𝓜]` is the internal version of graded
  module, the internal version can be translated into the external version `gmodule`. -/
instance gmodule : DirectSum.Gmodule (fun i => 𝓐 i) fun i => 𝓜 i 
goal: DirectSum.Gmodule (fun i => ↥(𝓐 i)) fun i => ↥(𝓜 i)

full_name: GradedModule.isModule
code: /-- The smul multiplication of `A` on `⨁ i, 𝓜 i` from `(⨁ i, 𝓐 i) →+ (⨁ i, 𝓜 i) →+ ⨁ i, 𝓜 i`
turns `⨁ i, 𝓜 i` into an `A`-module
-/
def isModule [DecidableEq ιA] [DecidableEq ιM] [GradedRing 𝓐] : Module A (⨁ i, 𝓜 i) 
goal: Module A (⨁ (i : ιM), ↥(𝓜 i))

full_name: GradedModule.linearEquiv
code: /-- `⨁ i, 𝓜 i` and `M` are isomorphic as `A`-modules.
"The internal version" and "the external version" are isomorphism as `A`-modules.
-/
def linearEquiv [DecidableEq ιA] [DecidableEq ιM] [GradedRing 𝓐] [DirectSum.Decomposition 𝓜] :
    @LinearEquiv A A _ _ (RingHom.id A) (RingHom.id A) _ _ M (⨁ i, 𝓜 i) _
    _ _ (by letI := isModule 𝓐 𝓜; infer_instance) 
goal: M ≃ₗ[A] ⨁ (i : ιM), ↥(𝓜 i)