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, base_ring=None, index_set=None):
"""
Normalize arguments to ensure a unique representation.
EXAMPLES::
sage: W1 = CoxeterGroup(['A',2], implementation="reflection", base_ring=UniversalCyclotomicField())
sage: W2 = CoxeterGroup([[1,3],[3,1]], index_set=(1,2))
sage: W1 is W2
True
sage: G1 = Graph([(1,2)])
sage: W3 = CoxeterGroup(G1)
sage: W1 is W3
True
sage: G2 = Graph([(1,2,3)])
sage: W4 = CoxeterGroup(G2)
sage: W1 is W4
True
"""
data = CoxeterMatrix(data, index_set=index_set)
if base_ring is None:
base_ring = UniversalCyclotomicField()
return super(CoxeterMatrixGroup, cls).__classcall__(cls,
data, base_ring, data.index_set())
def coxeter_matrix(self):
"""
Return the Coxeter matrix of ``self``.
EXAMPLES::
sage: FiniteCoxeterGroups().example(6).coxeter_matrix()
[1 6]
[6 1]
"""
return CoxeterMatrix([[1, self.n], [self.n, 1]])
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 coxeter_matrix(self):
"""
Return the Coxeter matrix for this Coxeter group.
The columns and rows are ordered according to the result of
:meth:`index_set`.
EXAMPLES::
sage: W = CoxeterGroup(['A', 3], implementation='coxeter3') # optional - coxeter3
sage: m = W.coxeter_matrix(); m # optional - coxeter3
[1 3 2]
[3 1 3]
[2 3 1]
sage: m.index_set() == W.index_set() # optional - coxeter3
True
"""
return CoxeterMatrix(self._coxgroup.coxeter_matrix(), self.index_set())
def __classcall_private__(cls, data, base_ring=None, index_set=None):
"""
Normalize arguments to ensure a unique representation.
EXAMPLES::
sage: W1 = CoxeterGroup(['A',2], implementation="reflection", base_ring=ZZ)
sage: W2 = CoxeterGroup([[1,3],[3,1]], index_set=(1,2))
sage: W1 is W2
True
sage: G1 = Graph([(1,2)])
sage: W3 = CoxeterGroup(G1)
sage: W1 is W3
True
sage: G2 = Graph([(1,2,3)])
sage: W4 = CoxeterGroup(G2)
sage: W1 is W4
True
"""
data = CoxeterMatrix(data, index_set=index_set)
if base_ring is None:
if data.is_simply_laced():
base_ring = ZZ
elif data.is_finite():
letter = data.coxeter_type().cartan_type().type()
if letter in ['B', 'C', 'F']:
base_ring = QuadraticField(2)
elif letter == 'G':
base_ring = QuadraticField(3)
elif letter == 'H':
base_ring = QuadraticField(5)
else:
base_ring = UniversalCyclotomicField()
else:
base_ring = UniversalCyclotomicField()
return super(CoxeterMatrixGroup,
cls).__classcall__(cls, data, base_ring, data.index_set())