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
Travis Scrimshaw (2025-01-30): Allowed general construction; implemented general Burau representation
Todo
Implement affine type Artin groups with their well-known embeddings into the classical braid group.
- class sage.groups.artin.ArtinGroup(coxeter_matrix, names)[source]¶
Bases:
UniqueRepresentation,FinitelyPresentedGroupAn 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 matrixnames– 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
namescan 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
- 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
ValueErrorerror 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:
FinitelyPresentedGroupElementAn 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
- burau_matrix(var='t')[source]¶
Return the Burau matrix of the Artin group element.
Following [BQ2024], the (generalized) Burau representation of an Artin group is defined by deforming the reflection representation of the corresponding Coxeter group. However, we substitute \(q \mapsto -t\) from [BQ2024] to match one of the unitary (reduced) Burau representations of the braid group (see
sage.groups.braid.Braid.burau_matrix()for details.)More precisely, let \((m_{ij})_{i,j \in I}\) be the
Coxeter matrix. Then the action is given on the basis \((\alpha_1, \ldots \alpha_n)\) (corresponding to the reflection representation of the correspondingCoxeter group) by\[\begin{split}\sigma_i(\alpha_j) = \alpha_j - \langle \alpha_i, \alpha_j \rangle_q \alpha_i, \qquad \text{ where } \langle \alpha_i, \alpha_j \rangle_q := \begin{cases} 1 + t^2 & \text{if } i = j, \\ -2 t \cos(\pi/m_{ij}) & \text{if } i \neq j. \end{cases}.\end{split}\]By convention \(\cos(\pi/\infty) = 1\). Note that the inverse of the generators act by \(\sigma_i^{-1}(\alpha_j) = \alpha_j - q^{-2} \langle \alpha_j, \alpha_i \rangle_q \alpha_i\).
INPUT:
var– string (default:'t'); the name of the variable in the entries of the matrix
OUTPUT:
The Burau matrix of the Artin group element over the Laurent polynomial ring in the variable
var.EXAMPLES:
sage: A.<s1,s2,s3> = ArtinGroup(['B',3]) sage: B1 = s1.burau_matrix() sage: B2 = s2.burau_matrix() sage: B3 = s3.burau_matrix() sage: [B1, B2, B3] [ [-t^2 t 0] [ 1 0 0] [ 1 0 0] [ 0 1 0] [ t -t^2 a*t] [ 0 1 0] [ 0 0 1], [ 0 0 1], [ 0 a*t -t^2] ] sage: B1 * B2 * B1 == B2 * B1 * B2 True sage: B2 * B3 * B2 * B3 == B3 * B2 * B3 * B2 True sage: B1 * B3 == B3 * B1 True sage: (~s1).burau_matrix() * B1 == 1 True
>>> from sage.all import * >>> A = ArtinGroup(['B',Integer(3)], names=('s1', 's2', 's3',)); (s1, s2, s3,) = A._first_ngens(3) >>> B1 = s1.burau_matrix() >>> B2 = s2.burau_matrix() >>> B3 = s3.burau_matrix() >>> [B1, B2, B3] [ [-t^2 t 0] [ 1 0 0] [ 1 0 0] [ 0 1 0] [ t -t^2 a*t] [ 0 1 0] [ 0 0 1], [ 0 0 1], [ 0 a*t -t^2] ] >>> B1 * B2 * B1 == B2 * B1 * B2 True >>> B2 * B3 * B2 * B3 == B3 * B2 * B3 * B2 True >>> B1 * B3 == B3 * B1 True >>> (~s1).burau_matrix() * B1 == Integer(1) True
We verify the example in Theorem 4.1 of [BQ2024]:
sage: A.<s1,s2,s3,s4> = ArtinGroup(['A', 3, 1]) sage: [g.burau_matrix() for g in A.gens()] [ [-t^2 t 0 t] [ 1 0 0 0] [ 1 0 0 0] [ 0 1 0 0] [ t -t^2 t 0] [ 0 1 0 0] [ 0 0 1 0] [ 0 0 1 0] [ 0 t -t^2 t] [ 0 0 0 1], [ 0 0 0 1], [ 0 0 0 1], [ 1 0 0 0] [ 0 1 0 0] [ 0 0 1 0] [ t 0 t -t^2] ] sage: a = s3^2 * s4 * s3 * s2 *s1 * ~s3 * s4 * s3 * s2 * s1^-2 * s4 sage: b = s1^2 * ~s2 * s4 * s1 * ~s3 * s2 * ~s4 * s3 * s1 * s4 * s1 * ~s2 * s4^-2 * s3 sage: alpha = a * s3 * ~a sage: beta = b * s2 * ~b sage: elm = alpha * beta * ~alpha * ~beta sage: print(elm.Tietze()) (3, 3, 4, 3, 2, 1, -3, 4, 3, 2, -1, -1, 4, 3, -4, 1, 1, -2, -3, -4, 3, -1, -2, -3, -4, -3, -3, 1, 1, -2, 4, 1, -3, 2, -4, 3, 1, 4, 1, -2, -4, -4, 3, 2, -3, 4, 4, 2, -1, -4, -1, -3, 4, -2, 3, -1, -4, 2, -1, -1, 3, 3, 4, 3, 2, 1, -3, 4, 3, 2, -1, -1, 4, -3, -4, 1, 1, -2, -3, -4, 3, -1, -2, -3, -4, -3, -3, 1, 1, -2, 4, 1, -3, 2, -4, 3, 1, 4, 1, -2, -4, -4, 3, -2, -3, 4, 4, 2, -1, -4, -1, -3, 4, -2, 3, -1, -4, 2, -1, -1) sage: elm.burau_matrix() [1 0 0 0] [0 1 0 0] [0 0 1 0] [0 0 0 1]
>>> from sage.all import * >>> A = ArtinGroup(['A', Integer(3), Integer(1)], names=('s1', 's2', 's3', 's4',)); (s1, s2, s3, s4,) = A._first_ngens(4) >>> [g.burau_matrix() for g in A.gens()] [ [-t^2 t 0 t] [ 1 0 0 0] [ 1 0 0 0] [ 0 1 0 0] [ t -t^2 t 0] [ 0 1 0 0] [ 0 0 1 0] [ 0 0 1 0] [ 0 t -t^2 t] [ 0 0 0 1], [ 0 0 0 1], [ 0 0 0 1], <BLANKLINE> [ 1 0 0 0] [ 0 1 0 0] [ 0 0 1 0] [ t 0 t -t^2] ] >>> a = s3**Integer(2) * s4 * s3 * s2 *s1 * ~s3 * s4 * s3 * s2 * s1**-Integer(2) * s4 >>> b = s1**Integer(2) * ~s2 * s4 * s1 * ~s3 * s2 * ~s4 * s3 * s1 * s4 * s1 * ~s2 * s4**-Integer(2) * s3 >>> alpha = a * s3 * ~a >>> beta = b * s2 * ~b >>> elm = alpha * beta * ~alpha * ~beta >>> print(elm.Tietze()) (3, 3, 4, 3, 2, 1, -3, 4, 3, 2, -1, -1, 4, 3, -4, 1, 1, -2, -3, -4, 3, -1, -2, -3, -4, -3, -3, 1, 1, -2, 4, 1, -3, 2, -4, 3, 1, 4, 1, -2, -4, -4, 3, 2, -3, 4, 4, 2, -1, -4, -1, -3, 4, -2, 3, -1, -4, 2, -1, -1, 3, 3, 4, 3, 2, 1, -3, 4, 3, 2, -1, -1, 4, -3, -4, 1, 1, -2, -3, -4, 3, -1, -2, -3, -4, -3, -3, 1, 1, -2, 4, 1, -3, 2, -4, 3, 1, 4, 1, -2, -4, -4, 3, -2, -3, 4, 4, 2, -1, -4, -1, -3, 4, -2, 3, -1, -4, 2, -1, -1) >>> elm.burau_matrix() [1 0 0 0] [0 1 0 0] [0 0 1 0] [0 0 0 1]
Next, we show
elmis not the identity by using the embedding of the affine braid group \(\widetilde{B}_n \to B_{n+1}\):sage: B.<t1,t2,t3,t4> = BraidGroup(5) sage: D = t1 * t2 * t3 * t4^2 sage: t0 = D * t3 * ~D sage: t0*t1*t0 == t1*t0*t1 True sage: t0*t2 == t2*t0 True sage: t0*t3*t0 == t3*t0*t3 True sage: T = [t0, t1, t2, t3] sage: emb = B.prod(T[i-1] if i > 0 else ~T[-i-1] for i in elm.Tietze()) sage: emb.is_one() False
>>> from sage.all import * >>> B = BraidGroup(Integer(5), names=('t1', 't2', 't3', 't4',)); (t1, t2, t3, t4,) = B._first_ngens(4) >>> D = t1 * t2 * t3 * t4**Integer(2) >>> t0 = D * t3 * ~D >>> t0*t1*t0 == t1*t0*t1 True >>> t0*t2 == t2*t0 True >>> t0*t3*t0 == t3*t0*t3 True >>> T = [t0, t1, t2, t3] >>> emb = B.prod(T[i-Integer(1)] if i > Integer(0) else ~T[-i-Integer(1)] for i in elm.Tietze()) >>> emb.is_one() False
Since the Burau representation does not respect the group embedding, the corresponding \(B_5\) element’s Burau matrix is not the identity (Bigelow gave an example of the representation not being faithful for \(B_5\), but it is still open for \(B_4\)):
sage: emb.burau_matrix() != 1 True
>>> from sage.all import * >>> emb.burau_matrix() != Integer(1) True
We also verify the result using the elements in [BQ2024] Remark 4.2:
sage: ap = s3 * s1 * s2 * s1 * ~s3 * s4 * s2 * s3 * s2 * ~s3 * s1^-2 * s4 sage: bp = s1 * ~s4 * s1^2 * s3^-2 * ~s2 * s4 * s1 * ~s3 * s2 * ~s4 * s3 * s1 * s4 * s1 * ~s2 * s4^-2 * s3 sage: alpha = ap * s3 * ~ap sage: beta = bp * s2 * ~bp sage: elm = alpha * beta * ~alpha * ~beta sage: elm.burau_matrix() [1 0 0 0] [0 1 0 0] [0 0 1 0] [0 0 0 1]
>>> from sage.all import * >>> ap = s3 * s1 * s2 * s1 * ~s3 * s4 * s2 * s3 * s2 * ~s3 * s1**-Integer(2) * s4 >>> bp = s1 * ~s4 * s1**Integer(2) * s3**-Integer(2) * ~s2 * s4 * s1 * ~s3 * s2 * ~s4 * s3 * s1 * s4 * s1 * ~s2 * s4**-Integer(2) * s3 >>> alpha = ap * s3 * ~ap >>> beta = bp * s2 * ~bp >>> elm = alpha * beta * ~alpha * ~beta >>> elm.burau_matrix() [1 0 0 0] [0 1 0 0] [0 0 1 0] [0 0 0 1]
REFERENCES:
- 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
WEXAMPLES:
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:
ArtinGroupA 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
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:
ArtinGroupElementAn 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)