Magmas¶

class sage.categories.magmas.Magmas(s=None)

Bases: sage.categories.category_singleton.Category_singleton

The category of (multiplicative) magmas, i.e. sets with a binary operation *.

EXAMPLES:

sage: Magmas()
Category of magmas
sage: Magmas().super_categories()
[Category of sets]
sage: Magmas().all_super_categories()
[Category of magmas, Category of sets, Category of sets with partial maps, Category of objects]


TESTS:

sage: C = Magmas()
sage: TestSuite(C).run()

class CartesianProducts(category, *args)

TESTS:

sage: from sage.categories.covariant_functorial_construction import CovariantConstructionCategory
sage: class FooBars(CovariantConstructionCategory):
...       _functor_category = "FooBars"
sage: Category.FooBars = lambda self: FooBars.category_of(self)
sage: C = FooBars(ModulesWithBasis(ZZ))
sage: C
Category of foo bars of modules with basis over Integer Ring
sage: C.base_category()
Category of modules with basis over Integer Ring
sage: latex(C)
\mathbf{FooBars}(\mathbf{ModulesWithBasis}_{\Bold{Z}})
sage: import __main__; __main__.FooBars = FooBars # Fake FooBars being defined in a python module
sage: TestSuite(C).run()

ParentMethods

alias of CartesianProducts.ParentMethods

example()

Returns an example of cartesian product of magmas

EXAMPLES:

sage: C = Magmas().CartesianProducts().example(); C
The cartesian product of (Rational Field, Integer Ring, Integer Ring)
sage: C.category()
Category of Cartesian products of monoids
sage: TestSuite(C).run()

extra_super_categories()

EXAMPLES:

sage: Semigroups().CartesianProducts().extra_super_categories()
[Category of semigroups]
sage: Semigroups().CartesianProducts().super_categories()
[Category of semigroups, Category of Cartesian products of magmas]

class Magmas.ElementMethods
is_idempotent()

Test whether self is idempotent.

EXAMPLES:

sage: S = Semigroups().example("free"); S
An example of a semigroup: the free semigroup generated by ('a', 'b', 'c', 'd')
sage: a = S('a')
sage: a^2
'aa'
sage: a.is_idempotent()
False

sage: L = Semigroups().example("leftzero"); L
An example of a semigroup: the left zero semigroup
sage: x = L('x')
sage: x^2
'x'
sage: x.is_idempotent()
True

class Magmas.ParentMethods
multiplication_table(names='letters', elements=None)

Returns a table describing the multiplication operation.

Note

The order of the elements in the row and column headings is equal to the order given by the table’s list() method. The association can also be retrieved with the dict() method.

INPUTS:

• names - the type of names used
• 'letters' - lowercase ASCII letters are used for a base 26 representation of the elements’ positions in the list given by column_keys(), padded to a common width with leading ‘a’s.
• 'digits' - base 10 representation of the elements’ positions in the list given by column_keys(), padded to a common width with leading zeros.
• 'elements' - the string representations of the elements themselves.
• a list - a list of strings, where the length of the list equals the number of elements.
• elements - default = None. A list of elements of the magma, in forms that can be coerced into the structure, eg. their string representations. This may be used to impose an alternate ordering on the elements, perhaps when this is used in the context of a particular structure. The default is to use whatever ordering the S.list method returns. Or the elements can be a subset which is closed under the operation. In particular, this can be used when the base set is infinite.

OUTPUT: The multiplication table as an object of the class OperationTable which defines several methods for manipulating and displaying the table. See the documentation there for full details to supplement the documentation here.

EXAMPLES:

The default is to represent elements as lowercase ASCII letters.

sage: G=CyclicPermutationGroup(5)
sage: G.multiplication_table()
*  a b c d e
+----------
a| a b c d e
b| b c d e a
c| c d e a b
d| d e a b c
e| e a b c d


All that is required is that an algebraic structure has a multiplication defined. A LeftRegularBand is an example of a finite semigroup. The names argument allows displaying the elements in different ways.

sage: from sage.categories.examples.finite_semigroups import LeftRegularBand
sage: L=LeftRegularBand(('a','b'))
sage: T=L.multiplication_table(names='digits')
sage: T.column_keys()
('a', 'b', 'ab', 'ba')
sage: T
*  0 1 2 3
+--------
0| 0 2 2 2
1| 3 1 3 3
2| 2 2 2 2
3| 3 3 3 3


Specifying the elements in an alternative order can provide more insight into how the operation behaves.

sage: L=LeftRegularBand(('a','b','c'))
sage: elts = sorted(L.list())
sage: L.multiplication_table(elements=elts)
*  a b c d e f g h i j k l m n o
+------------------------------
a| a b c d e b b c c c d d e e e
b| b b c c c b b c c c c c c c c
c| c c c c c c c c c c c c c c c
d| d e e d e e e e e e d d e e e
e| e e e e e e e e e e e e e e e
f| g g h h h f g h i j i j j i j
g| g g h h h g g h h h h h h h h
h| h h h h h h h h h h h h h h h
i| j j j j j i j j i j i j j i j
j| j j j j j j j j j j j j j j j
k| l m m l m n o o n o k l m n o
l| l m m l m m m m m m l l m m m
m| m m m m m m m m m m m m m m m
n| o o o o o n o o n o n o o n o
o| o o o o o o o o o o o o o o o


The elements argument can be used to provide a subset of the elements of the structure. The subset must be closed under the operation. Elements need only be in a form that can be coerced into the set. The names argument can also be used to request that the elements be represented with their usual string representation.

sage: L=LeftRegularBand(('a','b','c'))
sage: elts=['a', 'c', 'ac', 'ca']
sage: L.multiplication_table(names='elements', elements=elts)
*   'a'  'c' 'ac' 'ca'
+--------------------
'a'|  'a' 'ac' 'ac' 'ac'
'c'| 'ca'  'c' 'ca' 'ca'
'ac'| 'ac' 'ac' 'ac' 'ac'
'ca'| 'ca' 'ca' 'ca' 'ca'


The table returned can be manipulated in various ways. See the documentation for OperationTable for more comprehensive documentation.

sage: G=AlternatingGroup(3)
sage: T=G.multiplication_table()
sage: T.column_keys()
((), (1,2,3), (1,3,2))
sage: sorted(T.translation().items())
[('a', ()), ('b', (1,2,3)), ('c', (1,3,2))]
sage: T.change_names(['x', 'y', 'z'])
sage: sorted(T.translation().items())
[('x', ()), ('y', (1,2,3)), ('z', (1,3,2))]
sage: T
*  x y z
+------
x| x y z
y| y z x
z| z x y

product(x, y)

The binary multiplication of the magma

INPUT:

• x, y: elements of this magma

OUTPUT:

• an element of the magma (the product of x and y)

EXAMPLES:

sage: S = Semigroups().example("free")
sage: x = S('a'); y = S('b')
sage: S.product(x, y)
'ab'


A parent in Magmas() must either implement product() in the parent class or _mul_ in the element class. By default, the addition method on elements x._mul_(y) calls S.product(x,y), and reciprocally.

As a bonus, S.product models the binary function from S to S:

sage: bin = S.product
sage: bin(x,y)
'ab'


Currently, S.product is just a bound method:

sage: bin
<bound method FreeSemigroup_with_category.product of An example of a semigroup: the free semigroup generated by ('a', 'b', 'c', 'd')>


When Sage will support multivariate morphisms, it will be possible, and in fact recommended, to enrich S.product with extra mathematical structure. This will typically be implemented using lazy attributes.:

sage: bin                 # todo: not implemented
Generic binary morphism:
From: (S x S)
To:   S

product_from_element_class_mul(x, y)

The binary multiplication of the magma

INPUT:

• x, y: elements of this magma

OUTPUT:

• an element of the magma (the product of x and y)

EXAMPLES:

sage: S = Semigroups().example("free")
sage: x = S('a'); y = S('b')
sage: S.product(x, y)
'ab'


A parent in Magmas() must either implement product() in the parent class or _mul_ in the element class. By default, the addition method on elements x._mul_(y) calls S.product(x,y), and reciprocally.

As a bonus, S.product models the binary function from S to S:

sage: bin = S.product
sage: bin(x,y)
'ab'


Currently, S.product is just a bound method:

sage: bin
<bound method FreeSemigroup_with_category.product of An example of a semigroup: the free semigroup generated by ('a', 'b', 'c', 'd')>


When Sage will support multivariate morphisms, it will be possible, and in fact recommended, to enrich S.product with extra mathematical structure. This will typically be implemented using lazy attributes.:

sage: bin                 # todo: not implemented
Generic binary morphism:
From: (S x S)
To:   S

class Magmas.Realizations(category, *args)

TESTS:

sage: from sage.categories.covariant_functorial_construction import CovariantConstructionCategory
sage: class FooBars(CovariantConstructionCategory):
...       _functor_category = "FooBars"
sage: Category.FooBars = lambda self: FooBars.category_of(self)
sage: C = FooBars(ModulesWithBasis(ZZ))
sage: C
Category of foo bars of modules with basis over Integer Ring
sage: C.base_category()
Category of modules with basis over Integer Ring
sage: latex(C)
\mathbf{FooBars}(\mathbf{ModulesWithBasis}_{\Bold{Z}})
sage: import __main__; __main__.FooBars = FooBars # Fake FooBars being defined in a python module
sage: TestSuite(C).run()

ParentMethods

alias of Realizations.ParentMethods

class Magmas.Subquotients(category, *args)

The category of sub/quotient magmas.

Let $$G$$ and $$S$$ be two magmas and $$l: S \mapsto G$$ and $$r: G \mapsto S$$ be two maps such that:

• $$r \circ l$$ is the identity of $$G$$.
• for any two $$a,b\in S$$ the identity $$a \times_S b = r(l(a) \times_G l(b))$$ holds.

The category Subquotient implements the product $$\times_S$$ from $$l$$ and $$r$$ and the product of $$G$$.

$$S$$ is supposed to belongs the category Magmas().Subquotients() and to specify $$G$$ under the name S.ambient() and to implement $$x\to l(x)$$ and $$y \to r(y)$$ under the names S.lift(x) and S.retract(y).

EXAMPLES:

sage: Semigroups().Subquotients().all_super_categories()
[Category of subquotients of semigroups, Category of semigroups,
Category of subquotients of magmas, Category of magmas,
Category of subquotients of sets, Category of sets,
Category of sets with partial maps,
Category of objects]

ParentMethods

alias of Subquotients.ParentMethods

Magmas.super_categories()

EXAMPLES:

sage: Magmas().super_categories()
[Category of sets]


Left modules

Matrix algebras