### Navigation

- index
- modules |
- next |
- previous |
- Category Theory »

# Modules

class `sage.categories.modules.``Modules`(base, name=None)

  Bases: `sage.categories.category_types.Category_module`

  The category of all modules over a base ring \(R\).

  An \(R\)-module \(M\) is a left and right \(R\)-module over a commutative ring \(R\) such that:

  \[r*(x*s) = (r*x)*s \qquad \forall r,s \in R \text{ and } x \in M\]

  INPUT:

  - `base_ring` – a ring \(R\) or subcategory of `Rings()`
  - `dispatch` – a boolean (for internal use; default: `True`)

  When the base ring is a field, the category of vector spaces is returned instead (unless `dispatch == False`).

  Warning

  Outside of the context of symmetric modules over a commutative ring, the specifications of this category are fuzzy and not yet set in stone (see below). The code in this category and its subcategories is therefore prone to bugs or arbitrary limitations in this case.

  EXAMPLES:

      sage: Modules(ZZ)
      Category of modules over Integer Ring
      sage: Modules(QQ)
      Category of vector spaces over Rational Field

      sage: Modules(Rings())
      Category of modules over rings
      sage: Modules(FiniteFields())
      Category of vector spaces over finite fields

      sage: Modules(Integers(9))
      Category of modules over Ring of integers modulo 9

      sage: Modules(Integers(9)).super_categories()
      [Category of bimodules over Ring of integers modulo 9 on the left and Ring of integers modulo 9 on the right]

      sage: Modules(ZZ).super_categories()
      [Category of bimodules over Integer Ring on the left and Integer Ring on the right]

      sage: Modules == RingModules
      True

      sage: Modules(ZZ[x]).is_abelian()   # see #6081
      True

  TESTS:

      sage: TestSuite(Modules(ZZ)).run()

  Todo

  - Clarify the distinction, if any, with `BiModules(R, R)`. In particular, if \(R\) is a commutative ring (e.g. a field), some pieces of the code possibly assume that \(M\) is a symmetric `R`-`R`-bimodule:

    \[r*x = x*r \qquad \forall r \in R \text{ and } x \in M\]

  - Make sure that non symmetric modules are properly supported by all the code, and advertise it.

  - Make sure that non commutative rings are properly supported by all the code, and advertise it.

  - Add support for base semirings.

  - Implement a `FreeModules(R)` category, when so prompted by a concrete use case: e.g. modeling a free module with several bases (using `Sets.SubcategoryMethods.Realizations()`) or with an atlas of local maps (see e.g. trac ticket #15916).

  class `ElementMethods`
  class `Modules.``FiniteDimensional`(base_category)

    Bases: `sage.categories.category_with_axiom.CategoryWithAxiom_over_base_ring`

    TESTS:

        sage: C = Modules(ZZ).FiniteDimensional(); C
        Category of finite dimensional modules over Integer Ring
        sage: type(C)
        <class 'sage.categories.modules.Modules.FiniteDimensional_with_category'>
        sage: type(C).__base__.__base__
        <class 'sage.categories.category_with_axiom.CategoryWithAxiom_over_base_ring'>

        sage: TestSuite(C).run()

    `extra_super_categories`()

      Implement the fact that a finite dimensional module over a finite ring is finite.

      EXAMPLES:

          sage: Modules(IntegerModRing(4)).FiniteDimensional().extra_super_categories()
          [Category of finite sets]
          sage: Modules(ZZ).FiniteDimensional().extra_super_categories()
          []
          sage: Modules(GF(5)).FiniteDimensional().is_subcategory(Sets().Finite())
          True
          sage: Modules(ZZ).FiniteDimensional().is_subcategory(Sets().Finite())
          False

  `Modules.``Graded`

    alias of `GradedModules`

  class `Modules.``Homsets`(category, *args)

    Bases: `sage.categories.homsets.HomsetsCategory`

    The category of homomorphism sets \(\hom(X,Y)\) for \(X\), \(Y\) modules.

    class `Endset`(base_category)

      Bases: `sage.categories.category_with_axiom.CategoryWithAxiom_over_base_ring`

      The category of endomorphism sets \(End(X)\) for \(X\) a module (this is not used yet)

      `extra_super_categories`()

        Implement the fact that the endomorphism set of a module is an algebra.

        See also

        `CategoryWithAxiom.extra_super_categories()`

        EXAMPLES:

            sage: Modules(ZZ).Endsets().extra_super_categories()
            [Category of magmatic algebras over Integer Ring]

            sage: End(ZZ^3) in Algebras(ZZ)
            True

    class `Modules.Homsets.``ParentMethods`
      `base_ring`()

        Return the base ring of `self`.

        EXAMPLES:

            sage: E = CombinatorialFreeModule(ZZ, [1,2,3])
            sage: F = CombinatorialFreeModule(ZZ, [2,3,4])
            sage: H = Hom(E, F)
            sage: H.base_ring()
            Integer Ring

        This `base_ring` method is actually overridden by `sage.structure.category_object.CategoryObject.base_ring()`:

            sage: H.base_ring.__module__

        Here we call it directly:

            sage: method = H.category().parent_class.base_ring
            sage: method.__get__(H)()
            Integer Ring

      `zero`()

        EXAMPLES:

            sage: E = CombinatorialFreeModule(ZZ, [1,2,3])
            sage: F = CombinatorialFreeModule(ZZ, [2,3,4])
            sage: H = Hom(E, F)
            sage: f = H.zero()
            sage: f
            Generic morphism:
              From: Free module generated by {1, 2, 3} over Integer Ring
              To:   Free module generated by {2, 3, 4} over Integer Ring
            sage: f(E.monomial(2))
            0
            sage: f(E.monomial(3)) == F.zero()
            True

        TESTS:

        We check that `H.zero()` is picklable:

            sage: loads(dumps(f.parent().zero()))
            Generic morphism:
              From: Free module generated by {1, 2, 3} over Integer Ring
              To:   Free module generated by {2, 3, 4} over Integer Ring

    `Modules.Homsets.``base_ring`()

      EXAMPLES:

          sage: Modules(ZZ).Homsets().base_ring()
          Integer Ring

      Todo

      Generalize this so that any homset category of a full subcategory of modules over a base ring is a category over this base ring.

    `Modules.Homsets.``extra_super_categories`()

      EXAMPLES:

          sage: Modules(ZZ).Homsets().extra_super_categories()
          [Category of modules over Integer Ring]

  class `Modules.``ParentMethods`
  class `Modules.``SubcategoryMethods`
    `DualObjects`()

      Return the category of spaces constructed as duals of spaces of `self`.

      The dual of a vector space \(V\) is the space consisting of all linear functionals on \(V\) (see Wikipedia article Dual_space). Additional structure on \(V\) can endow its dual with additional structure; for example, if \(V\) is a finite dimensional algebra, then its dual is a coalgebra.

      This returns the category of spaces constructed as dual of spaces in `self`, endowed with the appropriate additional structure.

      Warning

      - This semantic of `dual` and `DualObject` is imposed on all subcategories, in particular to make `dual` a covariant functorial construction.

        A subcategory that defines a different notion of dual needs to use a different name.

      - Typically, the category of graded modules should define a separate `graded_dual` construction (see trac ticket #15647). For now the two constructions are not distinguished which is an oversimplified model.

      See also

      - `dual.DualObjectsCategory`
      - `CovariantFunctorialConstruction`.

      EXAMPLES:

          sage: VectorSpaces(QQ).DualObjects()
          Category of duals of vector spaces over Rational Field

      The dual of a vector space is a vector space:

          sage: VectorSpaces(QQ).DualObjects().super_categories()
          [Category of vector spaces over Rational Field]

      The dual of an algebra is a coalgebra:

          sage: sorted(Algebras(QQ).DualObjects().super_categories(), key=str)
          [Category of coalgebras over Rational Field,
           Category of duals of vector spaces over Rational Field]

      The dual of a coalgebra is an algebra:

          sage: sorted(Coalgebras(QQ).DualObjects().super_categories(), key=str)
          [Category of algebras over Rational Field,
           Category of duals of vector spaces over Rational Field]

      As a shorthand, this category can be accessed with the `dual()` method:

          sage: VectorSpaces(QQ).dual()
          Category of duals of vector spaces over Rational Field

      TESTS:

          sage: C = VectorSpaces(QQ).DualObjects()
          sage: C.base_category()
          Category of vector spaces over Rational Field
          sage: C.super_categories()
          [Category of vector spaces over Rational Field]
          sage: latex(C)
          \mathbf{DualObjects}(\mathbf{VectorSpaces}_{\Bold{Q}})
          sage: TestSuite(C).run()

    `FiniteDimensional`()

      Return the full subcategory of the finite dimensional objects of `self`.

      EXAMPLES:

          sage: Modules(ZZ).FiniteDimensional()
          Category of finite dimensional modules over Integer Ring
          sage: Coalgebras(QQ).FiniteDimensional()
          Category of finite dimensional coalgebras over Rational Field
          sage: AlgebrasWithBasis(QQ).FiniteDimensional()
          Category of finite dimensional algebras with basis over Rational Field

      TESTS:

          sage: TestSuite(Modules(ZZ).FiniteDimensional()).run()
          sage: Coalgebras(QQ).FiniteDimensional.__module__
          'sage.categories.modules'

    `Graded`(base_ring=None)

      Return the subcategory of the graded objects of `self`.

      INPUT:

          - ``base_ring`` -- this is ignored

      EXAMPLES:

          sage: Modules(ZZ).Graded()
          Category of graded modules over Integer Ring

          sage: Coalgebras(QQ).Graded()
          Join of Category of graded modules over Rational Field and Category of coalgebras over Rational Field

          sage: AlgebrasWithBasis(QQ).Graded()
          Category of graded algebras with basis over Rational Field

      Todo

      - Explain why this does not commute with `WithBasis()`
      - Improve the support for covariant functorial constructions categories over a base ring so as to get rid of the `base_ring` argument.

      TESTS:

          sage: Coalgebras(QQ).Graded.__module__
          'sage.categories.modules'

    `TensorProducts`()

      Return the full subcategory of objects of `self` constructed as tensor products.

      See also

      - `tensor.TensorProductsCategory`
      - `RegressiveCovariantFunctorialConstruction`.

      EXAMPLES:

          sage: ModulesWithBasis(QQ).TensorProducts()
          Category of tensor products of vector spaces with basis over Rational Field

    `WithBasis`()

      Return the full subcategory of the objects of `self` with a distinguished basis.

      EXAMPLES:

          sage: Modules(ZZ).WithBasis()
          Category of modules with basis over Integer Ring
          sage: Coalgebras(QQ).WithBasis()
          Category of coalgebras with basis over Rational Field
          sage: AlgebrasWithBasis(QQ).WithBasis()
          Category of algebras with basis over Rational Field

      TESTS:

          sage: TestSuite(Modules(ZZ).WithBasis()).run()
          sage: Coalgebras(QQ).WithBasis.__module__
          'sage.categories.modules'

    `base_ring`()

      Return the base ring (category) for `self`.

      This implements a `base_ring` method for join categories which are subcategories of some `Modules(K)`.

      Todo

      handle base being a category

      Note

      - This uses the fact that join categories are flattened; thus some direct subcategory of `self` should be a category over a base ring.
      - Generalize this to any `Category_over_base_ring`.
      - Should this code be in `JoinCategory`?
      - This assumes that a subcategory of a :class`~.category_types.Category_over_base_ring` is a `JoinCategory` or a :class`~.category_types.Category_over_base_ring`.

      EXAMPLES:

          sage: C = Modules(QQ) & Semigroups(); C
          Join of Category of semigroups and Category of vector spaces over Rational Field
          sage: C.base_ring()
          Rational Field
          sage: C.base_ring.__module__
          'sage.categories.modules'

    `dual`()

      Return the category of spaces constructed as duals of spaces of `self`.

      The dual of a vector space \(V\) is the space consisting of all linear functionals on \(V\) (see Wikipedia article Dual_space). Additional structure on \(V\) can endow its dual with additional structure; for example, if \(V\) is a finite dimensional algebra, then its dual is a coalgebra.

      This returns the category of spaces constructed as dual of spaces in `self`, endowed with the appropriate additional structure.

      Warning

      - This semantic of `dual` and `DualObject` is imposed on all subcategories, in particular to make `dual` a covariant functorial construction.

        A subcategory that defines a different notion of dual needs to use a different name.

      - Typically, the category of graded modules should define a separate `graded_dual` construction (see trac ticket #15647). For now the two constructions are not distinguished which is an oversimplified model.

      See also

      - `dual.DualObjectsCategory`
      - `CovariantFunctorialConstruction`.

      EXAMPLES:

          sage: VectorSpaces(QQ).DualObjects()
          Category of duals of vector spaces over Rational Field

      The dual of a vector space is a vector space:

          sage: VectorSpaces(QQ).DualObjects().super_categories()
          [Category of vector spaces over Rational Field]

      The dual of an algebra is a coalgebra:

          sage: sorted(Algebras(QQ).DualObjects().super_categories(), key=str)
          [Category of coalgebras over Rational Field,
           Category of duals of vector spaces over Rational Field]

      The dual of a coalgebra is an algebra:

          sage: sorted(Coalgebras(QQ).DualObjects().super_categories(), key=str)
          [Category of algebras over Rational Field,
           Category of duals of vector spaces over Rational Field]

      As a shorthand, this category can be accessed with the `dual()` method:

          sage: VectorSpaces(QQ).dual()
          Category of duals of vector spaces over Rational Field

      TESTS:

          sage: C = VectorSpaces(QQ).DualObjects()
          sage: C.base_category()
          Category of vector spaces over Rational Field
          sage: C.super_categories()
          [Category of vector spaces over Rational Field]
          sage: latex(C)
          \mathbf{DualObjects}(\mathbf{VectorSpaces}_{\Bold{Q}})
          sage: TestSuite(C).run()

  `Modules.``WithBasis`

    alias of `ModulesWithBasis`

  `Modules.``additional_structure`()

    Return `None`.

    Indeed, the category of modules defines no additional structure: a bimodule morphism between two modules is a module morphism.

    See also

    `Category.additional_structure()`

    Todo

    Should this category be a `CategoryWithAxiom`?

    EXAMPLES:

        sage: Modules(ZZ).additional_structure()

  `Modules.``super_categories`()

    EXAMPLES:

        sage: Modules(ZZ).super_categories()
        [Category of bimodules over Integer Ring on the left and Integer Ring on the right]

    Nota bene:

        sage: Modules(QQ)
        Category of vector spaces over Rational Field
        sage: Modules(QQ).super_categories()
        [Category of modules over Rational Field]

### Navigation

- index
- modules |
- next |
- previous |
- Category Theory »