Algebras - Category Framework

Skip to content
Back to top
View this page
Edit this page

# Algebras

AUTHORS:

- David Kohel & William Stein (2005): initial revision

- Nicolas M. Thiery (2008-2011): rewrote for the category framework

class sage.categories.algebras.Algebras(base_category)

  Bases: `CategoryWithAxiom_over_base_ring`

  The category of associative and unital algebras over a given base ring.

  An associative and unital algebra over a ring \(R\) is a module over \(R\) which is itself a ring.

  Warning

  `Algebras` will be eventually be replaced by `magmatic_algebras.MagmaticAlgebras` for consistency with e.g. Wikipedia article Algebras which assumes neither associativity nor the existence of a unit (see Issue #15043).

  Todo

  Should \(R\) be a commutative ring?

  EXAMPLES:

  Sage

      sage: Algebras(ZZ)
      Category of algebras over Integer Ring
      sage: sorted(Algebras(ZZ).super_categories(), key=str)
      [Category of associative algebras over Integer Ring,
       Category of rings,
       Category of unital algebras over Integer Ring]

  Python

      >>> from sage.all import *
      >>> Algebras(ZZ)
      Category of algebras over Integer Ring
      >>> sorted(Algebras(ZZ).super_categories(), key=str)
      [Category of associative algebras over Integer Ring,
       Category of rings,
       Category of unital algebras over Integer Ring]

  class CartesianProducts(category, *args)

    Bases: `CartesianProductsCategory`

    The category of algebras constructed as Cartesian products of algebras.

    This construction gives the direct product of algebras. See discussion on:

    > - http://groups.google.fr/group/sage-devel/browse_thread/thread/35a72b1d0a2fc77a/348f42ae77a66d16#348f42ae77a66d16

    > - Wikipedia article Direct_product

    extra_super_categories()

      A Cartesian product of algebras is endowed with a natural algebra structure.

      EXAMPLES:

      Sage

          sage: C = Algebras(QQ).CartesianProducts()
          sage: C.extra_super_categories()
          [Category of algebras over Rational Field]
          sage: sorted(C.super_categories(), key=str)
          [Category of Cartesian products of monoids,
           Category of Cartesian products of unital algebras over Rational Field,
           Category of algebras over Rational Field]

      Python

          >>> from sage.all import *
          >>> C = Algebras(QQ).CartesianProducts()
          >>> C.extra_super_categories()
          [Category of algebras over Rational Field]
          >>> sorted(C.super_categories(), key=str)
          [Category of Cartesian products of monoids,
           Category of Cartesian products of unital algebras over Rational Field,
           Category of algebras over Rational Field]

  Commutative

    alias of `CommutativeAlgebras`

  class DualObjects(category, *args)

    Bases: `DualObjectsCategory`

    extra_super_categories()

      Return the dual category.

      EXAMPLES:

      The category of algebras over the Rational Field is dual to the category of coalgebras over the same field:

      Sage

          sage: C = Algebras(QQ)
          sage: C.dual()
          Category of duals of algebras over Rational Field
          sage: C.dual().extra_super_categories()
          [Category of coalgebras over Rational Field]

      Python

          >>> from sage.all import *
          >>> C = Algebras(QQ)
          >>> C.dual()
          Category of duals of algebras over Rational Field
          >>> C.dual().extra_super_categories()
          [Category of coalgebras over Rational Field]

      Warning

      This is only correct in certain cases (finite dimension, …). See Issue #15647.

  class ElementMethods

    Bases: `object`

  Filtered

    alias of `FilteredAlgebras`

  Graded

    alias of `GradedAlgebras`

  class ParentMethods

    Bases: `object`

    characteristic()

      Return the characteristic of this algebra, which is the same as the characteristic of its base ring.

      EXAMPLES:

      Sage

          sage: # needs sage.modules
          sage: ZZ.characteristic()
          0
          sage: A = GF(7^3, 'a')                                                      # needs sage.rings.finite_rings
          sage: A.characteristic()                                                    # needs sage.rings.finite_rings
          7

      Python

          >>> from sage.all import *
          >>> # needs sage.modules
          >>> ZZ.characteristic()
          0
          >>> A = GF(Integer(7)**Integer(3), 'a')                                                      # needs sage.rings.finite_rings
          >>> A.characteristic()                                                    # needs sage.rings.finite_rings
          7

    has_standard_involution()

      Return `True` if the algebra has a standard involution and `False` otherwise.

      This algorithm follows Algorithm 2.10 from John Voight’s Identifying the Matrix Ring. Currently the only type of algebra this will work for is a quaternion algebra. Though this function seems redundant, once algebras have more functionality, in particular have a method to construct a basis, this algorithm will have more general purpose.

      EXAMPLES:

      Sage

          sage: # needs sage.combinat sage.modules
          sage: B = QuaternionAlgebra(2)
          sage: B.has_standard_involution()
          True
          sage: R.<x> = PolynomialRing(QQ)
          sage: K.<u> = NumberField(x**2 - 2)                                         # needs sage.rings.number_field
          sage: A = QuaternionAlgebra(K, -2, 5)                                       # needs sage.rings.number_field
          sage: A.has_standard_involution()                                           # needs sage.rings.number_field
          True
          sage: L.<a,b> = FreeAlgebra(QQ, 2)
          sage: L.has_standard_involution()
          Traceback (most recent call last):
          ...
          NotImplementedError: has_standard_involution is not implemented for this algebra

      Python

          >>> from sage.all import *
          >>> # needs sage.combinat sage.modules
          >>> B = QuaternionAlgebra(Integer(2))
          >>> B.has_standard_involution()
          True
          >>> R = PolynomialRing(QQ, names=('x',)); (x,) = R._first_ngens(1)
          >>> K = NumberField(x**Integer(2) - Integer(2), names=('u',)); (u,) = K._first_ngens(1)# needs sage.rings.number_field
          >>> A = QuaternionAlgebra(K, -Integer(2), Integer(5))                                       # needs sage.rings.number_field
          >>> A.has_standard_involution()                                           # needs sage.rings.number_field
          True
          >>> L = FreeAlgebra(QQ, Integer(2), names=('a', 'b',)); (a, b,) = L._first_ngens(2)
          >>> L.has_standard_involution()
          Traceback (most recent call last):
          ...
          NotImplementedError: has_standard_involution is not implemented for this algebra

  class Quotients(category, *args)

    Bases: `QuotientsCategory`

    class ParentMethods

      Bases: `object`

      algebra_generators()

        Return algebra generators for `self`.

        This implementation retracts the algebra generators from the ambient algebra.

        EXAMPLES:

        Sage

            sage: # needs sage.graphs sage.modules
            sage: A = FiniteDimensionalAlgebrasWithBasis(QQ).example(); A
            An example of a finite dimensional algebra with basis:
            the path algebra of the Kronecker quiver
            (containing the arrows a:x->y and b:x->y) over Rational Field
            sage: S = A.semisimple_quotient()
            sage: S.algebra_generators()
            Finite family {'x': B['x'], 'y': B['y'], 'a': 0, 'b': 0}

        Python

            >>> from sage.all import *
            >>> # needs sage.graphs sage.modules
            >>> A = FiniteDimensionalAlgebrasWithBasis(QQ).example(); A
            An example of a finite dimensional algebra with basis:
            the path algebra of the Kronecker quiver
            (containing the arrows a:x->y and b:x->y) over Rational Field
            >>> S = A.semisimple_quotient()
            >>> S.algebra_generators()
            Finite family {'x': B['x'], 'y': B['y'], 'a': 0, 'b': 0}

        Todo

        this could possibly remove the elements that retract to zero.

  Semisimple

    alias of `SemisimpleAlgebras`

  class SubcategoryMethods

    Bases: `object`

    Semisimple()

      Return the subcategory of semisimple objects of `self`.

      Note

      This mimics the syntax of axioms for a smooth transition if `Semisimple` becomes one.

      EXAMPLES:

      Sage

          sage: Algebras(QQ).Semisimple()
          Category of semisimple algebras over Rational Field
          sage: Algebras(QQ).WithBasis().FiniteDimensional().Semisimple()
          Category of finite dimensional semisimple algebras with basis over Rational Field

      Python

          >>> from sage.all import *
          >>> Algebras(QQ).Semisimple()
          Category of semisimple algebras over Rational Field
          >>> Algebras(QQ).WithBasis().FiniteDimensional().Semisimple()
          Category of finite dimensional semisimple algebras with basis over Rational Field

    Supercommutative()

      Return the full subcategory of the supercommutative objects of `self`.

      This is shorthand for creating the corresponding super category.

      EXAMPLES:

      Sage

          sage: Algebras(ZZ).Supercommutative()
          Category of supercommutative algebras over Integer Ring
          sage: Algebras(ZZ).WithBasis().Supercommutative()
          Category of supercommutative super algebras with basis over Integer Ring

          sage: Cat = Algebras(ZZ).Supercommutative()
          sage: Cat is Algebras(ZZ).Super().Supercommutative()
          True

      Python

          >>> from sage.all import *
          >>> Algebras(ZZ).Supercommutative()
          Category of supercommutative algebras over Integer Ring
          >>> Algebras(ZZ).WithBasis().Supercommutative()
          Category of supercommutative super algebras with basis over Integer Ring

          >>> Cat = Algebras(ZZ).Supercommutative()
          >>> Cat is Algebras(ZZ).Super().Supercommutative()
          True

  Super

    alias of `SuperAlgebras`

  class TensorProducts(category, *args)

    Bases: `TensorProductsCategory`

    class ElementMethods

      Bases: `object`

    class ParentMethods

      Bases: `object`

    extra_super_categories()

      EXAMPLES:

      Sage

          sage: Algebras(QQ).TensorProducts().extra_super_categories()
          [Category of algebras over Rational Field]
          sage: Algebras(QQ).TensorProducts().super_categories()
          [Category of algebras over Rational Field,
           Category of tensor products of vector spaces over Rational Field]

      Python

          >>> from sage.all import *
          >>> Algebras(QQ).TensorProducts().extra_super_categories()
          [Category of algebras over Rational Field]
          >>> Algebras(QQ).TensorProducts().super_categories()
          [Category of algebras over Rational Field,
           Category of tensor products of vector spaces over Rational Field]

      Meaning: a tensor product of algebras is an algebra

  WithBasis

    alias of `AlgebrasWithBasis`