def super_categories(self):
"""
EXAMPLES::
sage: CommutativeAdditiveSemigroups().super_categories()
[Category of additive magmas]
"""
return [AdditiveMagmas()]
def super_categories(self):
"""
EXAMPLES::
sage: from sage.categories.magmas_and_additive_magmas import MagmasAndAdditiveMagmas
sage: MagmasAndAdditiveMagmas().super_categories()
[Category of magmas, Category of additive magmas]
"""
return [Magmas(), AdditiveMagmas()]
def Distributive(self):
"""
Return the full subcategory of the objects of ``self``
where `*` is distributive on `+`.
INPUT:
- ``self`` -- a subcategory of :class:`Magmas`
and :class:`AdditiveMagmas`
Given that Sage does not yet know that the category
:class:`MagmasAndAdditiveMagmas` is the intersection of
the categories :class:`Magmas` and
:class:`AdditiveMagmas`, the method
:meth:`MagmasAndAdditiveMagmas.SubcategoryMethods.Distributive`
is not available, as would be desirable, for this intersection.
This method is a workaround. It checks that ``self`` is a
subcategory of both :class:`Magmas` and
:class:`AdditiveMagmas` and upgrades it to a subcategory
of :class:`MagmasAndAdditiveMagmas` before applying the
axiom. It complains otherwise, since the ``Distributive``
axiom does not make sense for a plain magma.
EXAMPLES::
sage: (Magmas() & AdditiveMagmas()).Distributive()
Category of distributive magmas and additive magmas
sage: (Monoids() & CommutativeAdditiveGroups()).Distributive()
Category of rings
sage: Magmas().Distributive()
Traceback (most recent call last):
...
ValueError: The distributive axiom only makes sense on a magma which is simultaneously an additive magma
sage: Semigroups().Distributive()
Traceback (most recent call last):
...
ValueError: The distributive axiom only makes sense on a magma which is simultaneously an additive magma
TESTS::
sage: Semigroups().Distributive.__module__
'sage.categories.magmas'
sage: Rings().Distributive.__module__
'sage.categories.magmas_and_additive_magmas'
"""
from .additive_magmas import AdditiveMagmas
if not self.is_subcategory(AdditiveMagmas()):
raise ValueError(
"The distributive axiom only makes sense on a magma which is simultaneously an additive magma"
)
from .magmas_and_additive_magmas import MagmasAndAdditiveMagmas
return (self & MagmasAndAdditiveMagmas()).Distributive()
def FinitelyGenerated(self):
r"""
Return the subcategory of the objects of ``self`` that are
endowed with a distinguished finite set of
(multiplicative) magma generators.
EXAMPLES:
This is a shorthand for :meth:`FinitelyGeneratedAsMagma`,
which see::
sage: Magmas().FinitelyGenerated()
Category of finitely generated magmas
sage: Semigroups().FinitelyGenerated()
Category of finitely generated semigroups
sage: Groups().FinitelyGenerated()
Category of finitely generated enumerated groups
An error is raised if this is ambiguous::
sage: (Magmas() & AdditiveMagmas()).FinitelyGenerated()
Traceback (most recent call last):
...
ValueError: FinitelyGenerated is ambiguous for
Join of Category of magmas and Category of additive magmas.
Please use explicitly one of the FinitelyGeneratedAsXXX methods
.. NOTE::
Checking that there is no ambiguity currently assumes
that all the other "finitely generated" axioms involve
an additive structure. As of Sage 6.4, this is
correct.
The use of this shorthand should be reserved for casual
interactive use or when there is no risk of ambiguity.
"""
from sage.categories.additive_magmas import AdditiveMagmas
if self.is_subcategory(AdditiveMagmas()):
raise ValueError(
"FinitelyGenerated is ambiguous for {}.\nPlease use explicitly one of the FinitelyGeneratedAsXXX methods"
.format(self))
return self.FinitelyGeneratedAsMagma()
def super_categories(self):
"""
EXAMPLES::
sage: from sage.categories.magmatic_algebras import MagmaticAlgebras
sage: MagmaticAlgebras(ZZ).super_categories()
[Category of additive commutative additive associative additive unital distributive magmas and additive magmas, Category of modules over Integer Ring]
sage: from sage.categories.additive_semigroups import AdditiveSemigroups
sage: MagmaticAlgebras(ZZ).is_subcategory((AdditiveSemigroups() & Magmas()).Distributive())
True
"""
R = self.base_ring()
# Note: The specifications impose `self` to be a subcategory
# of the join of its super categories. Here the join is non
# trivial, since some of the axioms of Modules (like the
# commutativity of '+') are added to the left hand side. We
# might want the infrastructure to take this join for us.
return Category.join([(Magmas() & AdditiveMagmas()).Distributive(), Modules(R)], as_list=True)
def GroupAlgebra(G, R=IntegerRing()):
"""
Return the group algebra of `G` over `R`.
INPUT:
- `G` -- a group
- `R` -- (default: `\ZZ`) a ring
EXAMPLES:
The *group algebra* `A=RG` is the space of formal linear
combinations of elements of `G` with coefficients in `R`::
sage: G = DihedralGroup(3)
sage: R = QQ
sage: A = GroupAlgebra(G, R); A
Algebra of Dihedral group of order 6 as a permutation group over Rational Field
sage: a = A.an_element(); a
() + 4*(1,2,3) + 2*(1,3)
This space is endowed with an algebra structure, obtained by extending
by bilinearity the multiplication of `G` to a multiplication on `RG`::
sage: A in Algebras
True
sage: a * a
5*() + 8*(2,3) + 8*(1,2) + 8*(1,2,3) + 16*(1,3,2) + 4*(1,3)
:func:`GroupAlgebra` is just a short hand for a more general
construction that covers, e.g., monoid algebras, additive group
algebras and so on::
sage: G.algebra(QQ)
Algebra of Dihedral group of order 6 as a permutation group over Rational Field
sage: GroupAlgebra(G,QQ) is G.algebra(QQ)
True
sage: M = Monoids().example(); M
An example of a monoid:
the free monoid generated by ('a', 'b', 'c', 'd')
sage: M.algebra(QQ)
Algebra of An example of a monoid: the free monoid generated by ('a', 'b', 'c', 'd')
over Rational Field
See the documentation of :mod:`sage.categories.algebra_functor`
for details.
TESTS::
sage: GroupAlgebra(1)
Traceback (most recent call last):
...
ValueError: 1 is not a magma or additive magma
sage: GroupAlgebra(GL(3, GF(7)))
Algebra of General Linear Group of degree 3 over Finite Field of size 7
over Integer Ring
sage: GroupAlgebra(GL(3, GF(7)), QQ)
Algebra of General Linear Group of degree 3 over Finite Field of size 7
over Rational Field
"""
if not (G in Magmas() or G in AdditiveMagmas()):
raise ValueError("%s is not a magma or additive magma" % G)
if not R in Rings():
raise ValueError("%s is not a ring" % R)
return G.algebra(R)
