def __classcall__(cls, W, k=1, coxeter_element=None, algorithm="inductive"):
r"""
Standardize input to ensure a unique representation.
TESTS::
sage: S1 = ClusterComplex(['B',2])
sage: W = CoxeterGroup(['B',2])
sage: S2 = ClusterComplex(W)
sage: S3 = ClusterComplex(CoxeterMatrix('B2'), coxeter_element=(1,2))
sage: w = W.from_reduced_word([1,2])
sage: S4 = ClusterComplex('B2', coxeter_element=w, algorithm="inductive")
sage: S1 is S2 and S2 is S3 and S3 is S4
True
"""
if k not in NN:
raise ValueError("the additional parameter must be a "
"nonnegative integer")
if W not in CoxeterGroups:
W = CoxeterGroup(W)
if not W.is_finite():
raise ValueError("the Coxeter group must be finite")
if coxeter_element is None:
coxeter_element = W.index_set()
elif hasattr(coxeter_element, "reduced_word"):
coxeter_element = coxeter_element.reduced_word()
coxeter_element = tuple(coxeter_element)
return super(SubwordComplex, cls).__classcall__(cls, W=W, k=k,
coxeter_element=coxeter_element,
algorithm=algorithm)
def __classcall__(cls, W, k=1, coxeter_element=None, algorithm="inductive"):
r"""
Standardize input to ensure a unique representation.
TESTS::
sage: S1 = ClusterComplex(['B',2])
sage: W = CoxeterGroup(['B',2])
sage: S2 = ClusterComplex(W)
sage: S3 = ClusterComplex(CoxeterMatrix('B2'), coxeter_element=(1,2))
sage: w = W.from_reduced_word([1,2])
sage: S4 = ClusterComplex('B2', coxeter_element=w, algorithm="inductive")
sage: S1 is S2 and S2 is S3 and S3 is S4
True
"""
if k not in NN:
raise ValueError("the additional parameter must be a "
"nonnegative integer")
if W not in CoxeterGroups:
W = CoxeterGroup(W)
if not W.is_finite():
raise ValueError("the Coxeter group must be finite")
if coxeter_element is None:
coxeter_element = W.index_set()
elif hasattr(coxeter_element, "reduced_word"):
coxeter_element = coxeter_element.reduced_word()
coxeter_element = tuple(coxeter_element)
return super(SubwordComplex, cls).__classcall__(cls, W=W, k=k,
coxeter_element=coxeter_element,
algorithm=algorithm)
def __init__(self, coxeter_matrix, names):
"""
Initialize ``self``.
TESTS::
sage: A = ArtinGroup(['D',4])
sage: TestSuite(A).run()
sage: A = ArtinGroup(['B',3], ['x','y','z'])
sage: TestSuite(A).run()
"""
self._coxeter_group = CoxeterGroup(coxeter_matrix)
free_group = FreeGroup(names)
rels = []
# Generate the relations based on the Coxeter graph
I = coxeter_matrix.index_set()
for ii, i in enumerate(I):
for j in I[ii + 1:]:
m = coxeter_matrix[i, j]
if m == Infinity: # no relation
continue
elt = [i, j] * m
for ind in range(m, 2 * m):
elt[ind] = -elt[ind]
rels.append(free_group(elt))
FinitelyPresentedGroup.__init__(self, free_group, tuple(rels))
def __init__(self, coxeter_matrix, names):
"""
Initialize ``self``.
TESTS::
sage: A = ArtinGroup(['D',4])
sage: TestSuite(A).run()
sage: A = ArtinGroup(['B',3], ['x','y','z'])
sage: TestSuite(A).run()
"""
self._coxeter_group = CoxeterGroup(coxeter_matrix)
free_group = FreeGroup(names)
rels = []
# Generate the relations based on the Coxeter graph
I = coxeter_matrix.index_set()
for ii,i in enumerate(I):
for j in I[ii+1:]:
m = coxeter_matrix[i,j]
if m == Infinity: # no relation
continue
elt = [i,j]*m
for ind in range(m, 2*m):
elt[ind] = -elt[ind]
rels.append(free_group(elt))
FinitelyPresentedGroup.__init__(self, free_group, tuple(rels))
def __init__(self, G, names):
"""
Initialize ``self``.
TESTS::
sage: G = RightAngledArtinGroup(graphs.CycleGraph(5))
sage: TestSuite(G).run()
"""
self._graph = G
F = FreeGroup(names=names)
CG = Graph(G).complement() # Make sure it's mutable
CG.relabel() # Standardize the labels
cm = [[-1] * CG.num_verts() for _ in range(CG.num_verts())]
for i in range(CG.num_verts()):
cm[i][i] = 1
for u, v in CG.edge_iterator(labels=False):
cm[u][v] = 2
cm[v][u] = 2
self._coxeter_group = CoxeterGroup(
CoxeterMatrix(cm, index_set=G.vertices()))
rels = tuple(
F([i + 1, j + 1, -i - 1, -j - 1])
for i, j in CG.edge_iterator(labels=False)) # +/- 1 for indexing
FinitelyPresentedGroup.__init__(self, F, rels)
def __classcall_private__(cls, data):
r"""
EXAMPLES::
sage: from sage.combinat.fully_commutative_elements import FullyCommutativeElements
sage: x1 = FullyCommutativeElements(CoxeterGroup(['B', 3])); x1
Fully commutative elements of Finite Coxeter group over Number Field in a with defining polynomial x^2 - 2 with a = 1.414213562373095? with Coxeter matrix:
[1 3 2]
[3 1 4]
[2 4 1]
sage: x2 = FullyCommutativeElements(['B', 3]); x2
Fully commutative elements of Finite Coxeter group over Number Field in a with defining polynomial x^2 - 2 with a = 1.414213562373095? with Coxeter matrix:
[1 3 2]
[3 1 4]
[2 4 1]
sage: x3 = FullyCommutativeElements(CoxeterMatrix([[1, 3, 2], [3, 1, 4], [2, 4, 1]])); x3
Fully commutative elements of Finite Coxeter group over Number Field in a with defining polynomial x^2 - 2 with a = 1.414213562373095? with Coxeter matrix:
[1 3 2]
[3 1 4]
[2 4 1]
sage: x1 is x2 is x3
True
sage: FullyCommutativeElements(CartanType(['B', 3]).relabel({1: 3, 2: 2, 3: 1}))
Fully commutative elements of Finite Coxeter group over Number Field in a with defining polynomial x^2 - 2 with a = 1.414213562373095? with Coxeter matrix:
[1 4 2]
[4 1 3]
[2 3 1]
sage: m = CoxeterMatrix([(1, 5, 2, 2, 2), (5, 1, 3, 2, 2), (2, 3, 1, 3, 2), (2, 2, 3, 1, 3), (2, 2, 2, 3, 1)]); FullyCommutativeElements(m)
Fully commutative elements of Coxeter group over Universal Cyclotomic Field with Coxeter matrix:
[1 5 2 2 2]
[5 1 3 2 2]
[2 3 1 3 2]
[2 2 3 1 3]
[2 2 2 3 1]
"""
if data in CoxeterGroups():
group = data
else:
group = CoxeterGroup(data)
return super(cls, FullyCommutativeElements).__classcall__(cls, group)
class ArtinGroup(FinitelyPresentedGroup):
r"""
An Artin group.
Fix an index set `I`. Let `M = (m_{ij})_{i,j \in I}` be a
:class:`Coxeter matrix
<sage.combinat.root_system.coxeter_matrix.CoxeterMatrix>`.
An *Artin group* is a group `A_M` that has a presentation
given by generators `\{ s_i \mid i \in I \}` and relations
.. MATH::
\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
Artin group of type ['B', 3]
sage: ArtinGroup(['B',3])
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()
(s1, s2)
sage: ArtinGroup(['B',2], 'g').generators()
(g1, g2)
sage: ArtinGroup(['B',2], 'x,y').generators()
(x, y)
REFERENCES:
- :wikipedia:`Artin_group`
.. SEEALSO::
:class:`~sage.groups.raag.RightAngledArtinGroup`
"""
@staticmethod
def __classcall_private__(cls, coxeter_data, names=None):
"""
Normalize input to ensure a unique representation.
TESTS::
sage: A1 = ArtinGroup(['B',3])
sage: A2 = ArtinGroup(['B',3], 's')
sage: A3 = ArtinGroup(['B',3], ['s1','s2','s3'])
sage: A1 is A2 and A2 is A3
True
sage: A1 = ArtinGroup(['B',2], 'a,b')
sage: A2 = ArtinGroup([[1,4],[4,1]], 'a,b')
sage: A3.<a,b> = ArtinGroup('B2')
sage: A1 is A2 and A2 is A3
True
sage: ArtinGroup(['A',3]) is BraidGroup(4, 's1,s2,s3')
True
sage: G = graphs.PathGraph(3)
sage: CM = CoxeterMatrix([[1,-1,2],[-1,1,-1],[2,-1,1]], index_set=G.vertices())
sage: A = groups.misc.Artin(CM)
sage: Ap = groups.misc.RightAngledArtin(G, 's')
sage: A is Ap
True
"""
coxeter_data = CoxeterMatrix(coxeter_data)
if names is None:
names = 's'
if isinstance(names, six.string_types):
if ',' in names:
names = [x.strip() for x in names.split(',')]
else:
names = [names + str(i) for i in coxeter_data.index_set()]
names = tuple(names)
if len(names) != coxeter_data.rank():
raise ValueError("the number of generators must match"
" the rank of the Coxeter type")
if all(m == Infinity
for m in coxeter_data.coxeter_graph().edge_labels()):
from sage.groups.raag import RightAngledArtinGroup
return RightAngledArtinGroup(coxeter_data.coxeter_graph(), names)
if not coxeter_data.is_finite():
raise NotImplementedError
if coxeter_data.coxeter_type().cartan_type().type() == 'A':
from sage.groups.braid import BraidGroup
return BraidGroup(coxeter_data.rank() + 1, names)
return FiniteTypeArtinGroup(coxeter_data, names)
def __init__(self, coxeter_matrix, names):
"""
Initialize ``self``.
TESTS::
sage: A = ArtinGroup(['D',4])
sage: TestSuite(A).run()
sage: A = ArtinGroup(['B',3], ['x','y','z'])
sage: TestSuite(A).run()
"""
self._coxeter_group = CoxeterGroup(coxeter_matrix)
free_group = FreeGroup(names)
rels = []
# Generate the relations based on the Coxeter graph
I = coxeter_matrix.index_set()
for ii, i in enumerate(I):
for j in I[ii + 1:]:
m = coxeter_matrix[i, j]
if m == Infinity: # no relation
continue
elt = [i, j] * m
for ind in range(m, 2 * m):
elt[ind] = -elt[ind]
rels.append(free_group(elt))
FinitelyPresentedGroup.__init__(self, free_group, tuple(rels))
def _repr_(self):
"""
Return a string representation of ``self``.
TESTS::
sage: ArtinGroup(['B',3])
Artin group of type ['B', 3]
sage: ArtinGroup(['D',4], 'g')
Artin group of type ['D', 4]
"""
try:
data = self.coxeter_type().cartan_type()
return "Artin group of type {}".format(data)
except AttributeError:
pass
return "Artin group with Coxeter matrix:\n{}".format(
self.coxeter_matrix())
def cardinality(self):
"""
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])
sage: A.cardinality()
+Infinity
"""
from sage.rings.infinity import Infinity
return Infinity
order = cardinality
def as_permutation_group(self):
"""
Return an isomorphic permutation group.
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')
sage: A.as_permutation_group()
Traceback (most recent call last):
...
ValueError: the group is infinite
"""
raise ValueError("the group is infinite")
def coxeter_type(self):
"""
Return the Coxeter type of ``self``.
EXAMPLES::
sage: A = ArtinGroup(['D',4])
sage: A.coxeter_type()
Coxeter type of ['D', 4]
"""
return self._coxeter_group.coxeter_type()
def coxeter_matrix(self):
"""
Return the Coxeter matrix of ``self``.
EXAMPLES::
sage: A = ArtinGroup(['B',3])
sage: A.coxeter_matrix()
[1 3 2]
[3 1 4]
[2 4 1]
"""
return self._coxeter_group.coxeter_matrix()
def coxeter_group(self):
"""
Return the Coxeter group of ``self``.
EXAMPLES::
sage: A = ArtinGroup(['D',4])
sage: A.coxeter_group()
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]
"""
return self._coxeter_group
def index_set(self):
"""
Return the index set of ``self``.
OUTPUT:
A tuple.
EXAMPLES::
sage: A = ArtinGroup(['E',7])
sage: A.index_set()
(1, 2, 3, 4, 5, 6, 7)
"""
return self._coxeter_group.index_set()
def _element_constructor_(self, x):
"""
TESTS::
sage: A = ArtinGroup(['B',3])
sage: A([2,1,-2,3,3,3,1])
s2*s1*s2^-1*s3^3*s1
"""
if x in self._coxeter_group:
return self._standard_lift(x)
return self.element_class(self, x)
@cached_method
def an_element(self):
"""
Return an element of ``self``.
EXAMPLES::
sage: A = ArtinGroup(['B',2])
sage: A.an_element()
s1
"""
return self.gen(0)
def some_elements(self):
"""
Return a list of some elements of ``self``.
EXAMPLES::
sage: A = ArtinGroup(['B',3])
sage: A.some_elements()
[s1, s1*s2*s3, (s1*s2*s3)^3]
"""
rank = self.coxeter_matrix().rank()
elements_list = [self.gen(0)]
elements_list.append(self.prod(self.gens()))
elements_list.append(elements_list[-1]**min(rank, 3))
return elements_list
def _standard_lift_Tietze(self, w):
"""
Return a Tietze word representing the Coxeter element ``w``
under the natural section.
INPUT:
- ``w`` -- an element of the Coxeter group of ``self``.
EXAMPLES::
sage: A = ArtinGroup(['B',3])
sage: A._standard_lift_Tietze(A.coxeter_group().long_element())
[3, 2, 3, 1, 2, 3, 1, 2, 1]
"""
return w.reduced_word()
@cached_method
def _standard_lift(self, w):
"""
Return the element of ``self`` that corresponds to the given
Coxeter element ``w`` under the natural section.
INPUT:
- ``w`` -- an element of the Coxeter group of ``self``.
EXAMPLES::
sage: A = ArtinGroup(['B',3])
sage: A._standard_lift(A.coxeter_group().long_element())
s3*(s2*s3*s1)^2*s2*s1
sage: B = BraidGroup(5)
sage: P = Permutation([5, 3, 1, 2, 4])
sage: B._standard_lift(P)
s0*s1*s0*s2*s1*s3
"""
return self(self._standard_lift_Tietze(w))
Element = ArtinGroupElement
class ArtinGroup(FinitelyPresentedGroup):
r"""
An Artin group.
Fix an index set `I`. Let `M = (m_{ij})_{i,j \in I}` be a
:class:`Coxeter matrix
<sage.combinat.root_system.coxeter_matrix.CoxeterMatrix>`.
An *Artin group* is a group `A_M` that has a presentation
given by generators `\{ s_i \mid i \in I \}` and relations
.. MATH::
\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
Artin group of type ['B', 3]
sage: ArtinGroup(['B',3])
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()
(s1, s2)
sage: ArtinGroup(['B',2], 'g').generators()
(g1, g2)
sage: ArtinGroup(['B',2], 'x,y').generators()
(x, y)
REFERENCES:
- :wikipedia:`Artin_group`
.. SEEALSO::
:class:`~sage.groups.raag.RightAngledArtinGroup`
"""
@staticmethod
def __classcall_private__(cls, coxeter_data, names=None):
"""
Normalize input to ensure a unique representation.
TESTS::
sage: A1 = ArtinGroup(['B',3])
sage: A2 = ArtinGroup(['B',3], 's')
sage: A3 = ArtinGroup(['B',3], ['s1','s2','s3'])
sage: A1 is A2 and A2 is A3
True
sage: A1 = ArtinGroup(['B',2], 'a,b')
sage: A2 = ArtinGroup([[1,4],[4,1]], 'a,b')
sage: A3.<a,b> = ArtinGroup('B2')
sage: A1 is A2 and A2 is A3
True
sage: ArtinGroup(['A',3]) is BraidGroup(4, 's1,s2,s3')
True
sage: G = graphs.PathGraph(3)
sage: CM = CoxeterMatrix([[1,-1,2],[-1,1,-1],[2,-1,1]], index_set=G.vertices())
sage: A = groups.misc.Artin(CM)
sage: Ap = groups.misc.RightAngledArtin(G, 's')
sage: A is Ap
True
"""
coxeter_data = CoxeterMatrix(coxeter_data)
if names is None:
names = 's'
if isinstance(names, six.string_types):
if ',' in names:
names = [x.strip() for x in names.split(',')]
else:
names = [names + str(i) for i in coxeter_data.index_set()]
names = tuple(names)
if len(names) != coxeter_data.rank():
raise ValueError("the number of generators must match"
" the rank of the Coxeter type")
if all(m == Infinity for m in coxeter_data.coxeter_graph().edge_labels()):
from sage.groups.raag import RightAngledArtinGroup
return RightAngledArtinGroup(coxeter_data.coxeter_graph(), names)
if not coxeter_data.is_finite():
raise NotImplementedError
if coxeter_data.coxeter_type().cartan_type().type() == 'A':
from sage.groups.braid import BraidGroup
return BraidGroup(coxeter_data.rank()+1, names)
return FiniteTypeArtinGroup(coxeter_data, names)
def __init__(self, coxeter_matrix, names):
"""
Initialize ``self``.
TESTS::
sage: A = ArtinGroup(['D',4])
sage: TestSuite(A).run()
sage: A = ArtinGroup(['B',3], ['x','y','z'])
sage: TestSuite(A).run()
"""
self._coxeter_group = CoxeterGroup(coxeter_matrix)
free_group = FreeGroup(names)
rels = []
# Generate the relations based on the Coxeter graph
I = coxeter_matrix.index_set()
for ii,i in enumerate(I):
for j in I[ii+1:]:
m = coxeter_matrix[i,j]
if m == Infinity: # no relation
continue
elt = [i,j]*m
for ind in range(m, 2*m):
elt[ind] = -elt[ind]
rels.append(free_group(elt))
FinitelyPresentedGroup.__init__(self, free_group, tuple(rels))
def _repr_(self):
"""
Return a string representation of ``self``.
TESTS::
sage: ArtinGroup(['B',3])
Artin group of type ['B', 3]
sage: ArtinGroup(['D',4], 'g')
Artin group of type ['D', 4]
"""
try:
data = self.coxeter_type().cartan_type()
return "Artin group of type {}".format(data)
except AttributeError:
pass
return "Artin group with Coxeter matrix:\n{}".format(self.coxeter_matrix())
def cardinality(self):
"""
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])
sage: A.cardinality()
+Infinity
"""
from sage.rings.infinity import Infinity
return Infinity
order = cardinality
def as_permutation_group(self):
"""
Return an isomorphic permutation group.
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')
sage: A.as_permutation_group()
Traceback (most recent call last):
...
ValueError: the group is infinite
"""
raise ValueError("the group is infinite")
def coxeter_type(self):
"""
Return the Coxeter type of ``self``.
EXAMPLES::
sage: A = ArtinGroup(['D',4])
sage: A.coxeter_type()
Coxeter type of ['D', 4]
"""
return self._coxeter_group.coxeter_type()
def coxeter_matrix(self):
"""
Return the Coxeter matrix of ``self``.
EXAMPLES::
sage: A = ArtinGroup(['B',3])
sage: A.coxeter_matrix()
[1 3 2]
[3 1 4]
[2 4 1]
"""
return self._coxeter_group.coxeter_matrix()
def coxeter_group(self):
"""
Return the Coxeter group of ``self``.
EXAMPLES::
sage: A = ArtinGroup(['D',4])
sage: A.coxeter_group()
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]
"""
return self._coxeter_group
def index_set(self):
"""
Return the index set of ``self``.
OUTPUT:
A tuple.
EXAMPLES::
sage: A = ArtinGroup(['E',7])
sage: A.index_set()
(1, 2, 3, 4, 5, 6, 7)
"""
return self._coxeter_group.index_set()
def _element_constructor_(self, x):
"""
TESTS::
sage: A = ArtinGroup(['B',3])
sage: A([2,1,-2,3,3,3,1])
s2*s1*s2^-1*s3^3*s1
"""
if x in self._coxeter_group:
return self._standard_lift(x)
return self.element_class(self, x)
@cached_method
def an_element(self):
"""
Return an element of ``self``.
EXAMPLES::
sage: A = ArtinGroup(['B',2])
sage: A.an_element()
s1
"""
return self.gen(0)
def some_elements(self):
"""
Return a list of some elements of ``self``.
EXAMPLES::
sage: A = ArtinGroup(['B',3])
sage: A.some_elements()
[s1, s1*s2*s3, (s1*s2*s3)^3]
"""
rank = self.coxeter_matrix().rank()
elements_list = [self.gen(0)]
elements_list.append(self.prod(self.gens()))
elements_list.append(elements_list[-1] ** min(rank,3))
return elements_list
def _standard_lift_Tietze(self, w):
"""
Return a Tietze word representing the Coxeter element ``w``
under the natural section.
INPUT:
- ``w`` -- an element of the Coxeter group of ``self``.
EXAMPLES::
sage: A = ArtinGroup(['B',3])
sage: A._standard_lift_Tietze(A.coxeter_group().long_element())
[3, 2, 3, 1, 2, 3, 1, 2, 1]
"""
return w.reduced_word()
@cached_method
def _standard_lift(self, w):
"""
Return the element of ``self`` that corresponds to the given
Coxeter element ``w`` under the natural section.
INPUT:
- ``w`` -- an element of the Coxeter group of ``self``.
EXAMPLES::
sage: A = ArtinGroup(['B',3])
sage: A._standard_lift(A.coxeter_group().long_element())
s3*(s2*s3*s1)^2*s2*s1
sage: B = BraidGroup(5)
sage: P = Permutation([5, 3, 1, 2, 4])
sage: B._standard_lift(P)
s0*s1*s0*s2*s1*s3
"""
return self(self._standard_lift_Tietze(w))
Element = ArtinGroupElement