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)[source]

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: 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]

>>> 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)[source]

Bases: CartesianProductsCategory

The category of algebras constructed as Cartesian products of algebras.

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

extra_super_categories()[source]

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

EXAMPLES:

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]

>>> 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[source]

alias of CommutativeAlgebras

class DualObjects(category, *args)[source]

Bases: DualObjectsCategory

extra_super_categories()[source]

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: 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]

>>> 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[source]

Bases: object

Filtered[source]

alias of FilteredAlgebras

Graded[source]

alias of GradedAlgebras

class ParentMethods[source]

Bases: object

characteristic()[source]

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

EXAMPLES:

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

>>> 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()[source]

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: # 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

>>> 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)[source]

Bases: QuotientsCategory

class ParentMethods[source]

Bases: object

algebra_generators()[source]

Return algebra generators for self.

This implementation retracts the algebra generators from the ambient algebra.

EXAMPLES:

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}

>>> 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[source]

alias of SemisimpleAlgebras

class SubcategoryMethods[source]

Bases: object

Semisimple()[source]

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: 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

>>> 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()[source]

Return the full subcategory of the supercommutative objects of self.

This is shorthand for creating the corresponding super category.

EXAMPLES:

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

>>> 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[source]

alias of SuperAlgebras

class TensorProducts(category, *args)[source]

Bases: TensorProductsCategory

class ElementMethods[source]

Bases: object

class ParentMethods[source]

Bases: object

extra_super_categories()[source]

EXAMPLES:

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]

>>> 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[source]

alias of AlgebrasWithBasis