Artin Groups

Artin groups are implemented as a particular case of finitely presented groups. For finite-type Artin groups, there is a specific left normal form using the Garside structure associated to the lift the long element of the corresponding Coxeter group.

AUTHORS:

  • Travis Scrimshaw (2018-02-05): Initial version

class sage.groups.artin.ArtinGroup(coxeter_matrix, names)[source]

Bases: UniqueRepresentation, FinitelyPresentedGroup

An Artin group.

Fix an index set \(I\). Let \(M = (m_{ij})_{i,j \in I}\) be a Coxeter matrix. An Artin group is a group \(A_M\) that has a presentation given by generators \(\{ s_i \mid i \in I \}\) and relations

\[\underbrace{s_i s_j s_i \cdots}_{m_{ij}} = \underbrace{s_j s_i s_j \cdots}_{\text{$m_{ji}$ factors}}\]

for all \(i,j \in I\) with the usual convention that \(m_{ij} = \infty\) implies no relation between \(s_i\) and \(s_j\). There is a natural corresponding Coxeter group \(W_M\) by imposing the additional relations \(s_i^2 = 1\) for all \(i \in I\). Furthermore, there is a natural section of \(W_M\) by sending a reduced word \(s_{i_1} \cdots s_{i_{\ell}} \mapsto s_{i_1} \cdots s_{i_{\ell}}\).

Artin groups \(A_M\) are classified based on the Coxeter data:

  • \(A_M\) is of finite type or spherical if \(W_M\) is finite;

  • \(A_M\) is of affine type if \(W_M\) is of affine type;

  • \(A_M\) is of large type if \(m_{ij} \geq 4\) for all \(i,j \in I\);

  • \(A_M\) is of extra-large type if \(m_{ij} \geq 5\) for all \(i,j \in I\);

  • \(A_M\) is right-angled if \(m_{ij} \in \{2,\infty\}\) for all \(i,j \in I\).

Artin groups are conjectured to have many nice properties:

  • Artin groups are torsion free.

  • Finite type Artin groups have \(Z(A_M) = \ZZ\) and infinite type Artin groups have trivial center.

  • Artin groups have solvable word problems.

  • \(H_{W_M} / W_M\) is a \(K(A_M, 1)\)-space, where \(H_W\) is the hyperplane complement of the Coxeter group \(W\) acting on \(\CC^n\).

These conjectures are known when the Artin group is finite type and a number of other cases. See, e.g., [GP2012] and references therein.

INPUT:

  • coxeter_data – data defining a Coxeter matrix

  • names – string or list/tuple/iterable of strings (default: 's'); the generator names or name prefix

EXAMPLES:

sage: A.<a,b,c> = ArtinGroup(['B',3]);  A                                       # needs sage.rings.number_field
Artin group of type ['B', 3]
sage: ArtinGroup(['B',3])                                                       # needs sage.rings.number_field
Artin group of type ['B', 3]

>>> from sage.all import *
>>> A = ArtinGroup(['B',Integer(3)], names=('a', 'b', 'c',)); (a, b, c,) = A._first_ngens(3);  A                                       # needs sage.rings.number_field
Artin group of type ['B', 3]
>>> ArtinGroup(['B',Integer(3)])                                                       # needs sage.rings.number_field
Artin group of type ['B', 3]

The input must always include the Coxeter data, but the names can either be a string representing the prefix of the names or the explicit names of the generators. Otherwise the default prefix of 's' is used:

sage: ArtinGroup(['B',2]).generators()                                          # needs sage.rings.number_field
(s1, s2)
sage: ArtinGroup(['B',2], 'g').generators()                                     # needs sage.rings.number_field
(g1, g2)
sage: ArtinGroup(['B',2], 'x,y').generators()                                   # needs sage.rings.number_field
(x, y)

>>> from sage.all import *
>>> ArtinGroup(['B',Integer(2)]).generators()                                          # needs sage.rings.number_field
(s1, s2)
>>> ArtinGroup(['B',Integer(2)], 'g').generators()                                     # needs sage.rings.number_field
(g1, g2)
>>> ArtinGroup(['B',Integer(2)], 'x,y').generators()                                   # needs sage.rings.number_field
(x, y)

REFERENCES:

See also

RightAngledArtinGroup

Element[source]

alias of ArtinGroupElement

an_element()[source]

Return an element of self.

EXAMPLES:

sage: A = ArtinGroup(['B',2])                                               # needs sage.rings.number_field
sage: A.an_element()                                                        # needs sage.rings.number_field
s1

>>> from sage.all import *
>>> A = ArtinGroup(['B',Integer(2)])                                               # needs sage.rings.number_field
>>> A.an_element()                                                        # needs sage.rings.number_field
s1
as_permutation_group()[source]

Return an isomorphic permutation group.

This raises a ValueError error since Artin groups are infinite and have no corresponding permutation group.

EXAMPLES:

sage: Gamma = graphs.CycleGraph(5)
sage: G = RightAngledArtinGroup(Gamma)
sage: G.as_permutation_group()
Traceback (most recent call last):
...
ValueError: the group is infinite

sage: A = ArtinGroup(['D',4], 'g')                                          # needs sage.rings.number_field
sage: A.as_permutation_group()                                              # needs sage.rings.number_field
Traceback (most recent call last):
...
ValueError: the group is infinite

>>> from sage.all import *
>>> Gamma = graphs.CycleGraph(Integer(5))
>>> G = RightAngledArtinGroup(Gamma)
>>> G.as_permutation_group()
Traceback (most recent call last):
...
ValueError: the group is infinite

>>> A = ArtinGroup(['D',Integer(4)], 'g')                                          # needs sage.rings.number_field
>>> A.as_permutation_group()                                              # needs sage.rings.number_field
Traceback (most recent call last):
...
ValueError: the group is infinite
cardinality()[source]

Return the number of elements of self.

OUTPUT: infinity

EXAMPLES:

sage: Gamma = graphs.CycleGraph(5)
sage: G = RightAngledArtinGroup(Gamma)
sage: G.cardinality()
+Infinity

sage: A = ArtinGroup(['A',1])                                               # needs sage.rings.number_field
sage: A.cardinality()                                                       # needs sage.rings.number_field
+Infinity

>>> from sage.all import *
>>> Gamma = graphs.CycleGraph(Integer(5))
>>> G = RightAngledArtinGroup(Gamma)
>>> G.cardinality()
+Infinity

>>> A = ArtinGroup(['A',Integer(1)])                                               # needs sage.rings.number_field
>>> A.cardinality()                                                       # needs sage.rings.number_field
+Infinity
coxeter_group()[source]

Return the Coxeter group of self.

EXAMPLES:

sage: A = ArtinGroup(['D',4])                                               # needs sage.rings.number_field
sage: A.coxeter_group()                                                     # needs sage.rings.number_field
Finite Coxeter group over Integer Ring with Coxeter matrix:
[1 3 2 2]
[3 1 3 3]
[2 3 1 2]
[2 3 2 1]

>>> from sage.all import *
>>> A = ArtinGroup(['D',Integer(4)])                                               # needs sage.rings.number_field
>>> A.coxeter_group()                                                     # needs sage.rings.number_field
Finite Coxeter group over Integer Ring with Coxeter matrix:
[1 3 2 2]
[3 1 3 3]
[2 3 1 2]
[2 3 2 1]
coxeter_matrix()[source]

Return the Coxeter matrix of self.

EXAMPLES:

sage: A = ArtinGroup(['B',3])                                               # needs sage.rings.number_field
sage: A.coxeter_matrix()                                                    # needs sage.rings.number_field
[1 3 2]
[3 1 4]
[2 4 1]

>>> from sage.all import *
>>> A = ArtinGroup(['B',Integer(3)])                                               # needs sage.rings.number_field
>>> A.coxeter_matrix()                                                    # needs sage.rings.number_field
[1 3 2]
[3 1 4]
[2 4 1]
coxeter_type()[source]

Return the Coxeter type of self.

EXAMPLES:

sage: A = ArtinGroup(['D',4])                                               # needs sage.rings.number_field
sage: A.coxeter_type()                                                      # needs sage.rings.number_field
Coxeter type of ['D', 4]

>>> from sage.all import *
>>> A = ArtinGroup(['D',Integer(4)])                                               # needs sage.rings.number_field
>>> A.coxeter_type()                                                      # needs sage.rings.number_field
Coxeter type of ['D', 4]
index_set()[source]

Return the index set of self.

OUTPUT: tuple

EXAMPLES:

sage: A = ArtinGroup(['E',7])                                               # needs sage.rings.number_field
sage: A.index_set()                                                         # needs sage.rings.number_field
(1, 2, 3, 4, 5, 6, 7)

>>> from sage.all import *
>>> A = ArtinGroup(['E',Integer(7)])                                               # needs sage.rings.number_field
>>> A.index_set()                                                         # needs sage.rings.number_field
(1, 2, 3, 4, 5, 6, 7)
order()[source]

Return the number of elements of self.

OUTPUT: infinity

EXAMPLES:

sage: Gamma = graphs.CycleGraph(5)
sage: G = RightAngledArtinGroup(Gamma)
sage: G.cardinality()
+Infinity

sage: A = ArtinGroup(['A',1])                                               # needs sage.rings.number_field
sage: A.cardinality()                                                       # needs sage.rings.number_field
+Infinity

>>> from sage.all import *
>>> Gamma = graphs.CycleGraph(Integer(5))
>>> G = RightAngledArtinGroup(Gamma)
>>> G.cardinality()
+Infinity

>>> A = ArtinGroup(['A',Integer(1)])                                               # needs sage.rings.number_field
>>> A.cardinality()                                                       # needs sage.rings.number_field
+Infinity
some_elements()[source]

Return a list of some elements of self.

EXAMPLES:

sage: A = ArtinGroup(['B',3])                                               # needs sage.rings.number_field
sage: A.some_elements()                                                     # needs sage.rings.number_field
[s1, s1*s2*s3, (s1*s2*s3)^3]

>>> from sage.all import *
>>> A = ArtinGroup(['B',Integer(3)])                                               # needs sage.rings.number_field
>>> A.some_elements()                                                     # needs sage.rings.number_field
[s1, s1*s2*s3, (s1*s2*s3)^3]
class sage.groups.artin.ArtinGroupElement(parent, x, check=True)[source]

Bases: FinitelyPresentedGroupElement

An element of an Artin group.

It is a particular case of element of a finitely presented group.

EXAMPLES:

sage: # needs sage.rings.number_field
sage: A.<s1,s2,s3> = ArtinGroup(['B',3])
sage: A
Artin group of type ['B', 3]
sage: s1 * s2 / s3 / s2
s1*s2*s3^-1*s2^-1
sage: A((1, 2, -3, -2))
s1*s2*s3^-1*s2^-1

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> A = ArtinGroup(['B',Integer(3)], names=('s1', 's2', 's3',)); (s1, s2, s3,) = A._first_ngens(3)
>>> A
Artin group of type ['B', 3]
>>> s1 * s2 / s3 / s2
s1*s2*s3^-1*s2^-1
>>> A((Integer(1), Integer(2), -Integer(3), -Integer(2)))
s1*s2*s3^-1*s2^-1
coxeter_group_element(W=None)[source]

Return the corresponding Coxeter group element under the natural projection.

INPUT:

  • W – (default: self.parent().coxeter_group()) the image Coxeter group

OUTPUT: an element of the Coxeter group W

EXAMPLES:

sage: # needs sage.rings.number_field
sage: B.<s1,s2,s3> = ArtinGroup(['B',3])
sage: b = s1 * s2 / s3 / s2
sage: b1 = b.coxeter_group_element(); b1
[ 1 -1  0]
[ 2 -1  0]
[ a -a  1]
sage: b.coxeter_group_element().reduced_word()
[1, 2, 3, 2]
sage: A.<s1,s2,s3> = ArtinGroup(['A',3])
sage: c = s1 * s2 *s3
sage: c1 = c.coxeter_group_element(); c1
[4, 1, 2, 3]
sage: c1.reduced_word()
[3, 2, 1]
sage: c.coxeter_group_element(W=SymmetricGroup(4))
(1,4,3,2)
sage: A.<s1,s2,s3> = BraidGroup(4)
sage: c = s1 * s2 * s3^-1
sage: c0 = c.coxeter_group_element(); c0
[4, 1, 2, 3]
sage: c1 = c.coxeter_group_element(W=SymmetricGroup(4)); c1
(1,4,3,2)

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> B = ArtinGroup(['B',Integer(3)], names=('s1', 's2', 's3',)); (s1, s2, s3,) = B._first_ngens(3)
>>> b = s1 * s2 / s3 / s2
>>> b1 = b.coxeter_group_element(); b1
[ 1 -1  0]
[ 2 -1  0]
[ a -a  1]
>>> b.coxeter_group_element().reduced_word()
[1, 2, 3, 2]
>>> A = ArtinGroup(['A',Integer(3)], names=('s1', 's2', 's3',)); (s1, s2, s3,) = A._first_ngens(3)
>>> c = s1 * s2 *s3
>>> c1 = c.coxeter_group_element(); c1
[4, 1, 2, 3]
>>> c1.reduced_word()
[3, 2, 1]
>>> c.coxeter_group_element(W=SymmetricGroup(Integer(4)))
(1,4,3,2)
>>> A = BraidGroup(Integer(4), names=('s1', 's2', 's3',)); (s1, s2, s3,) = A._first_ngens(3)
>>> c = s1 * s2 * s3**-Integer(1)
>>> c0 = c.coxeter_group_element(); c0
[4, 1, 2, 3]
>>> c1 = c.coxeter_group_element(W=SymmetricGroup(Integer(4))); c1
(1,4,3,2)

From an element of the Coxeter group it is possible to recover the image by the standard section to the Artin group:

sage: # needs sage.rings.number_field
sage: B(b1)
s1*s2*s3*s2
sage: A(c0)
s1*s2*s3
sage: A(c0) == A(c1)
True

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> B(b1)
s1*s2*s3*s2
>>> A(c0)
s1*s2*s3
>>> A(c0) == A(c1)
True
exponent_sum()[source]

Return the exponent sum of self.

OUTPUT: integer

EXAMPLES:

sage: # needs sage.rings.number_field
sage: A = ArtinGroup(['E',6])
sage: b = A([1, 4, -3, 2])
sage: b.exponent_sum()
2
sage: b = A([])
sage: b.exponent_sum()
0

sage: B = BraidGroup(5)
sage: b = B([1, 4, -3, 2])
sage: b.exponent_sum()
2
sage: b = B([])
sage: b.exponent_sum()
0

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> A = ArtinGroup(['E',Integer(6)])
>>> b = A([Integer(1), Integer(4), -Integer(3), Integer(2)])
>>> b.exponent_sum()
2
>>> b = A([])
>>> b.exponent_sum()
0

>>> B = BraidGroup(Integer(5))
>>> b = B([Integer(1), Integer(4), -Integer(3), Integer(2)])
>>> b.exponent_sum()
2
>>> b = B([])
>>> b.exponent_sum()
0
class sage.groups.artin.FiniteTypeArtinGroup(coxeter_matrix, names)[source]

Bases: ArtinGroup

A finite-type Artin group.

An Artin group is finite-type or spherical if the corresponding Coxeter group is finite. Finite type Artin groups are known to be torsion free, have a Garside structure given by \(\Delta\) (see delta()) and have a center generated by \(\Delta\).

See also

ArtinGroup

EXAMPLES:

sage: ArtinGroup(['E',7])                                                       # needs sage.rings.number_field
Artin group of type ['E', 7]

>>> from sage.all import *
>>> ArtinGroup(['E',Integer(7)])                                                       # needs sage.rings.number_field
Artin group of type ['E', 7]

Since the word problem for finite-type Artin groups is solvable, their Cayley graph can be locally obtained as follows (see Issue #16059):

sage: def ball(group, radius):
....:     ret = set()
....:     ret.add(group.one())
....:     for length in range(1, radius):
....:         for w in Words(alphabet=group.gens(), length=length):
....:              ret.add(prod(w))
....:     return ret
sage: A = ArtinGroup(['B',3])                                                   # needs sage.rings.number_field
sage: GA = A.cayley_graph(elements=ball(A, 4), generators=A.gens()); GA         # needs sage.rings.number_field
Digraph on 32 vertices

>>> from sage.all import *
>>> def ball(group, radius):
...     ret = set()
...     ret.add(group.one())
...     for length in range(Integer(1), radius):
...         for w in Words(alphabet=group.gens(), length=length):
...              ret.add(prod(w))
...     return ret
>>> A = ArtinGroup(['B',Integer(3)])                                                   # needs sage.rings.number_field
>>> GA = A.cayley_graph(elements=ball(A, Integer(4)), generators=A.gens()); GA         # needs sage.rings.number_field
Digraph on 32 vertices

Since the Artin group has nontrivial relations, this graph contains less vertices than the one associated to the free group (which is a tree):

sage: F = FreeGroup(3)
sage: GF = F.cayley_graph(elements=ball(F, 4), generators=F.gens()); GF         # needs sage.combinat
Digraph on 40 vertices

>>> from sage.all import *
>>> F = FreeGroup(Integer(3))
>>> GF = F.cayley_graph(elements=ball(F, Integer(4)), generators=F.gens()); GF         # needs sage.combinat
Digraph on 40 vertices
Element[source]

alias of FiniteTypeArtinGroupElement

delta()[source]

Return the \(\Delta\) element of self.

EXAMPLES:

sage: A = ArtinGroup(['B',3])                                               # needs sage.rings.number_field
sage: A.delta()                                                             # needs sage.rings.number_field
s3*(s2*s3*s1)^2*s2*s1

sage: A = ArtinGroup(['G',2])                                               # needs sage.rings.number_field
sage: A.delta()                                                             # needs sage.rings.number_field
(s2*s1)^3

sage: B = BraidGroup(5)
sage: B.delta()
s0*s1*s2*s3*s0*s1*s2*s0*s1*s0

>>> from sage.all import *
>>> A = ArtinGroup(['B',Integer(3)])                                               # needs sage.rings.number_field
>>> A.delta()                                                             # needs sage.rings.number_field
s3*(s2*s3*s1)^2*s2*s1

>>> A = ArtinGroup(['G',Integer(2)])                                               # needs sage.rings.number_field
>>> A.delta()                                                             # needs sage.rings.number_field
(s2*s1)^3

>>> B = BraidGroup(Integer(5))
>>> B.delta()
s0*s1*s2*s3*s0*s1*s2*s0*s1*s0
class sage.groups.artin.FiniteTypeArtinGroupElement(parent, x, check=True)[source]

Bases: ArtinGroupElement

An element of a finite-type Artin group.

left_normal_form()[source]

Return the left normal form of self.

OUTPUT:

A tuple of simple generators in the left normal form. The first element is a power of \(\Delta\), and the rest are elements of the natural section lift from the corresponding Coxeter group.

EXAMPLES:

sage: # needs sage.rings.number_field
sage: A = ArtinGroup(['B',3])
sage: A([1]).left_normal_form()
(1, s1)
sage: A([-1]).left_normal_form()
(s1^-1*(s2^-1*s1^-1*s3^-1)^2*s2^-1*s3^-1, s3*(s2*s3*s1)^2*s2)
sage: A([1, 2, 2, 1, 2]).left_normal_form()
(1, s1*s2*s1, s2*s1)
sage: A([3, 3, -2]).left_normal_form()
(s1^-1*(s2^-1*s1^-1*s3^-1)^2*s2^-1*s3^-1,
 s3*s1*s2*s3*s2*s1, s3, s3*s2*s3)
sage: A([1, 2, 3, -1, 2, -3]).left_normal_form()
(s1^-1*(s2^-1*s1^-1*s3^-1)^2*s2^-1*s3^-1,
 (s3*s1*s2)^2*s1, s1*s2*s3*s2)
sage: A([1,2,1,3,2,1,3,2,3,3,2,3,1,2,3,1,2,3,1,2]).left_normal_form()
((s3*(s2*s3*s1)^2*s2*s1)^2, s3*s2)

sage: B = BraidGroup(4)
sage: b = B([1, 2, 3, -1, 2, -3])
sage: b.left_normal_form()
(s0^-1*s1^-1*s0^-1*s2^-1*s1^-1*s0^-1, s0*s1*s2*s1*s0, s0*s2*s1)
sage: c = B([1])
sage: c.left_normal_form()
(1, s0)

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> A = ArtinGroup(['B',Integer(3)])
>>> A([Integer(1)]).left_normal_form()
(1, s1)
>>> A([-Integer(1)]).left_normal_form()
(s1^-1*(s2^-1*s1^-1*s3^-1)^2*s2^-1*s3^-1, s3*(s2*s3*s1)^2*s2)
>>> A([Integer(1), Integer(2), Integer(2), Integer(1), Integer(2)]).left_normal_form()
(1, s1*s2*s1, s2*s1)
>>> A([Integer(3), Integer(3), -Integer(2)]).left_normal_form()
(s1^-1*(s2^-1*s1^-1*s3^-1)^2*s2^-1*s3^-1,
 s3*s1*s2*s3*s2*s1, s3, s3*s2*s3)
>>> A([Integer(1), Integer(2), Integer(3), -Integer(1), Integer(2), -Integer(3)]).left_normal_form()
(s1^-1*(s2^-1*s1^-1*s3^-1)^2*s2^-1*s3^-1,
 (s3*s1*s2)^2*s1, s1*s2*s3*s2)
>>> A([Integer(1),Integer(2),Integer(1),Integer(3),Integer(2),Integer(1),Integer(3),Integer(2),Integer(3),Integer(3),Integer(2),Integer(3),Integer(1),Integer(2),Integer(3),Integer(1),Integer(2),Integer(3),Integer(1),Integer(2)]).left_normal_form()
((s3*(s2*s3*s1)^2*s2*s1)^2, s3*s2)

>>> B = BraidGroup(Integer(4))
>>> b = B([Integer(1), Integer(2), Integer(3), -Integer(1), Integer(2), -Integer(3)])
>>> b.left_normal_form()
(s0^-1*s1^-1*s0^-1*s2^-1*s1^-1*s0^-1, s0*s1*s2*s1*s0, s0*s2*s1)
>>> c = B([Integer(1)])
>>> c.left_normal_form()
(1, s0)