def multiplication_table(self, names='letters', elements=None):
r"""
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
:meth:`~sage.matrix.operation_table.OperationTable.list`
method. The association can also be retrieved with the
:meth:`~sage.matrix.operation_table.OperationTable.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
:meth:`~sage.matrix.operation_table.OperationTable.column_keys`,
padded to a common width with leading 'a's.
* ``digits`` - base 10 representation of the
elements' positions in the list given by
:meth:`~sage.matrix.operation_table.OperationTable.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 set. 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
:class:`~sage.matrix.operation_table.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
:class:`~sage.categories.examples.finite_semigroups.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
:class:`~sage.matrix.operation_table.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
"""
from sage.matrix.operation_table import OperationTable
import operator
return OperationTable(self, operation=operator.mul, names=names, elements=elements)
def addition_table(self, names='letters', elements=None):
r"""
Return a table describing the addition operation.
.. NOTE::
The order of the elements in the row and column
headings is equal to the order given by the table's
:meth:`~sage.matrix.operation_table.OperationTable.column_keys`
method. The association can also be retrieved with the
:meth:`~sage.matrix.operation_table.OperationTable.translation`
method.
INPUT:
- ``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
:meth:`~sage.matrix.operation_table.OperationTable.column_keys`,
padded to a common width with leading 'a's.
* ``'digits'`` - base 10 representation of the
elements' positions in the list given by
:meth:`~sage.matrix.operation_table.OperationTable.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 additive 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 addition table as an object of the class
:class:`~sage.matrix.operation_table.OperationTable`
which defines several methods for manipulating and
displaying the table. See the documentation there
for full details to supplement the documentation
here.
EXAMPLES:
All that is required is that an algebraic structure
has an addition defined.The default is to represent
elements as lowercase ASCII letters. ::
sage: R=IntegerModRing(5)
sage: R.addition_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
The ``names`` argument allows displaying the elements in
different ways. Requesting ``elements`` will use the
representation of the elements of the set. Requesting
``digits`` will include leading zeros as padding. ::
sage: R=IntegerModRing(11)
sage: P=R.addition_table(names='elements')
sage: P
+ 0 1 2 3 4 5 6 7 8 9 10
+---------------------------------
0| 0 1 2 3 4 5 6 7 8 9 10
1| 1 2 3 4 5 6 7 8 9 10 0
2| 2 3 4 5 6 7 8 9 10 0 1
3| 3 4 5 6 7 8 9 10 0 1 2
4| 4 5 6 7 8 9 10 0 1 2 3
5| 5 6 7 8 9 10 0 1 2 3 4
6| 6 7 8 9 10 0 1 2 3 4 5
7| 7 8 9 10 0 1 2 3 4 5 6
8| 8 9 10 0 1 2 3 4 5 6 7
9| 9 10 0 1 2 3 4 5 6 7 8
10| 10 0 1 2 3 4 5 6 7 8 9
sage: T=R.addition_table(names='digits')
sage: T
+ 00 01 02 03 04 05 06 07 08 09 10
+---------------------------------
00| 00 01 02 03 04 05 06 07 08 09 10
01| 01 02 03 04 05 06 07 08 09 10 00
02| 02 03 04 05 06 07 08 09 10 00 01
03| 03 04 05 06 07 08 09 10 00 01 02
04| 04 05 06 07 08 09 10 00 01 02 03
05| 05 06 07 08 09 10 00 01 02 03 04
06| 06 07 08 09 10 00 01 02 03 04 05
07| 07 08 09 10 00 01 02 03 04 05 06
08| 08 09 10 00 01 02 03 04 05 06 07
09| 09 10 00 01 02 03 04 05 06 07 08
10| 10 00 01 02 03 04 05 06 07 08 09
Specifying the elements in an alternative order can provide
more insight into how the operation behaves. ::
sage: S=IntegerModRing(7)
sage: elts = [0, 3, 6, 2, 5, 1, 4]
sage: S.addition_table(elements=elts)
+ a b c d e f g
+--------------
a| a b c d e f g
b| b c d e f g a
c| c d e f g a b
d| d e f g a b c
e| e f g a b c d
f| f g a b c d e
g| g a b c d e f
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: T=IntegerModRing(12)
sage: elts=[0, 3, 6, 9]
sage: T.addition_table(names='elements', elements=elts)
+ 0 3 6 9
+--------
0| 0 3 6 9
3| 3 6 9 0
6| 6 9 0 3
9| 9 0 3 6
The table returned can be manipulated in various ways. See
the documentation for
:class:`~sage.matrix.operation_table.OperationTable` for more
comprehensive documentation. ::
sage: R=IntegerModRing(3)
sage: T=R.addition_table()
sage: T.column_keys()
(0, 1, 2)
sage: sorted(T.translation().items())
[('a', 0), ('b', 1), ('c', 2)]
sage: T.change_names(['x', 'y', 'z'])
sage: sorted(T.translation().items())
[('x', 0), ('y', 1), ('z', 2)]
sage: T
+ x y z
+------
x| x y z
y| y z x
z| z x y
"""
from sage.matrix.operation_table import OperationTable
import operator
return OperationTable(self, operation=operator.add,
names=names, elements=elements)
def cayley_table(self, names='letters', elements=None):
r"""
Returns the "multiplication" table of this multiplicative group,
which is also known as the "Cayley table".
.. note:: The order of the elements in the row and column
headings is equal to the order given by the table's
:meth:`~sage.matrix.operation_table.OperationTable.column_keys`
method. The association between the actual elements and the
names/symbols used in the table can also be retrieved as
a dictionary with the
:meth:`~sage.matrix.operation_table.OperationTable.translation`
method.
For groups, this routine should behave identically to the
:meth:`~sage.categories.magmas.Magmas.ParentMethods.multiplication_table`
method for magmas, which applies in greater generality.
INPUT:
- ``names`` - the type of names used, values are:
* ``'letters'`` - lowercase ASCII letters are used
for a base 26 representation of the elements'
positions in the list given by :meth:`list`,
padded to a common width with leading 'a's.
* ``'digits'`` - base 10 representation of the
elements' positions in the list given by
:meth:`~sage.matrix.operation_table.OperationTable.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 group, 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 is provided by the
the group, which is reported by the
:meth:`~sage.matrix.operation_table.OperationTable.column_keys`
method. 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:
An object representing the multiplication table. This is
an :class:`~sage.matrix.operation_table.OperationTable` object
and even more documentation can be found there.
EXAMPLES:
Permutation groups, matrix groups and abelian groups
can all compute their multiplication tables. ::
sage: G = DiCyclicGroup(3)
sage: T = G.cayley_table()
sage: T.column_keys()
((), (5,6,7), (5,7,6)...(1,4,2,3)(5,7))
sage: T
* a b c d e f g h i j k l
+------------------------
a| a b c d e f g h i j k l
b| b c a e f d i g h l j k
c| c a b f d e h i g k l j
d| d e f a b c j k l g h i
e| e f d b c a l j k i g h
f| f d e c a b k l j h i g
g| g h i j k l d e f a b c
h| h i g k l j f d e c a b
i| i g h l j k e f d b c a
j| j k l g h i a b c d e f
k| k l j h i g c a b f d e
l| l j k i g h b c a e f d
::
sage: M=SL(2,2)
sage: M.cayley_table()
* a b c d e f
+------------
a| a b c d e f
b| b a d c f e
c| c f e b a d
d| d e f a b c
e| e d a f c b
f| f c b e d a
<BLANKLINE>
::
sage: A=AbelianGroup([2,3])
sage: A.cayley_table()
* a b c d e f
+------------
a| a b c d e f
b| b c a e f d
c| c a b f d e
d| d e f a b c
e| e f d b c a
f| f d e c a b
Lowercase ASCII letters are the default symbols used
for the table, but you can also specify the use of
decimal digit strings, or provide your own strings
(in the proper order if they have meaning).
Also, if the elements themselves are not too complex,
you can choose to just use the string representations
of the elements themselves. ::
sage: C=CyclicPermutationGroup(11)
sage: C.cayley_table(names='digits')
* 00 01 02 03 04 05 06 07 08 09 10
+---------------------------------
00| 00 01 02 03 04 05 06 07 08 09 10
01| 01 02 03 04 05 06 07 08 09 10 00
02| 02 03 04 05 06 07 08 09 10 00 01
03| 03 04 05 06 07 08 09 10 00 01 02
04| 04 05 06 07 08 09 10 00 01 02 03
05| 05 06 07 08 09 10 00 01 02 03 04
06| 06 07 08 09 10 00 01 02 03 04 05
07| 07 08 09 10 00 01 02 03 04 05 06
08| 08 09 10 00 01 02 03 04 05 06 07
09| 09 10 00 01 02 03 04 05 06 07 08
10| 10 00 01 02 03 04 05 06 07 08 09
::
sage: G=QuaternionGroup()
sage: names=['1', 'I', '-1', '-I', 'J', '-K', '-J', 'K']
sage: G.cayley_table(names=names)
* 1 I -1 -I J -K -J K
+------------------------
1| 1 I -1 -I J -K -J K
I| I -1 -I 1 K J -K -J
-1| -1 -I 1 I -J K J -K
-I| -I 1 I -1 -K -J K J
J| J -K -J K -1 -I 1 I
-K| -K -J K J I -1 -I 1
-J| -J K J -K 1 I -1 -I
K| K J -K -J -I 1 I -1
::
sage: A=AbelianGroup([2,2])
sage: A.cayley_table(names='elements')
* 1 f1 f0 f0*f1
+------------------------
1| 1 f1 f0 f0*f1
f1| f1 1 f0*f1 f0
f0| f0 f0*f1 1 f1
f0*f1| f0*f1 f0 f1 1
The :meth:`~sage.matrix.operation_table.OperationTable.change_names`
routine behaves similarly, but changes an existing table "in-place."
::
sage: G=AlternatingGroup(3)
sage: T=G.cayley_table()
sage: T.change_names('digits')
sage: T
* 0 1 2
+------
0| 0 1 2
1| 1 2 0
2| 2 0 1
For an infinite group, you can still work with finite sets of
elements, provided the set is closed under multiplication.
Elements will be coerced into the group as part of setting
up the table. ::
sage: G=SL(2,ZZ)
sage: G
Special Linear Group of degree 2 over Integer Ring
sage: identity = matrix(ZZ, [[1,0], [0,1]])
sage: G.cayley_table(elements=[identity, -identity])
* a b
+----
a| a b
b| b a
The
:class:`~sage.matrix.operation_table.OperationTable`
class provides even greater flexibility, including changing
the operation. Here is one such example, illustrating the
computation of commutators. ``commutator`` is defined as
a function of two variables, before being used to build
the table. From this, the commutator subgroup seems obvious,
and creating a Cayley table with just these three elements
confirms that they form a closed subset in the group.
::
sage: from sage.matrix.operation_table import OperationTable
sage: G=DiCyclicGroup(3)
sage: commutator = lambda x, y: x*y*x^-1*y^-1
sage: T=OperationTable(G, commutator)
sage: T
. a b c d e f g h i j k l
+------------------------
a| a a a a a a a a a a a a
b| a a a a a a c c c c c c
c| a a a a a a b b b b b b
d| a a a a a a a a a a a a
e| a a a a a a c c c c c c
f| a a a a a a b b b b b b
g| a b c a b c a c b a c b
h| a b c a b c b a c b a c
i| a b c a b c c b a c b a
j| a b c a b c a c b a c b
k| a b c a b c b a c b a c
l| a b c a b c c b a c b a
sage: trans = T.translation()
sage: comm = [trans['a'], trans['b'],trans['c']]
sage: comm
[(), (5,6,7), (5,7,6)]
sage: P=G.cayley_table(elements=comm)
sage: P
* a b c
+------
a| a b c
b| b c a
c| c a b
TODO:
Arrange an ordering of elements into cosets of a normal
subgroup close to size `\sqrt{n}`. Then the quotient
group structure is often apparent in the table. See
comments on Trac #7555.
AUTHOR:
- Rob Beezer (2010-03-15)
"""
from sage.matrix.operation_table import OperationTable
import operator
return OperationTable(self,
operation=operator.mul,
names=names,
elements=elements)