def __init__(self, W_types, index_set=None, hyperplane_index_set=None, reflection_index_set=None):
r"""
Initialize ``self``.
TESTS::
sage: W = ReflectionGroup(['A',3]) # optional - gap3
sage: TestSuite(W).run() # optional - gap3
"""
W_types = tuple([tuple(W_type) if isinstance(W_type, (list, tuple)) else W_type for W_type in W_types])
cartan_types = []
for W_type in W_types:
W_type = CartanType(W_type)
if not W_type.is_finite() or not W_type.is_irreducible():
raise ValueError("the given Cartan type of a component is not irreducible and finite")
cartan_types.append(W_type)
if len(W_types) == 1:
cls = IrreducibleComplexReflectionGroup
else:
cls = ComplexReflectionGroup
cls.__init__(
self,
W_types,
index_set=index_set,
hyperplane_index_set=hyperplane_index_set,
reflection_index_set=reflection_index_set,
)
def __init__(self,
W_types,
index_set=None,
hyperplane_index_set=None,
reflection_index_set=None):
r"""
Initialize ``self``.
TESTS::
sage: W = ReflectionGroup(['A',3]) # optional - gap3
sage: TestSuite(W).run() # optional - gap3
"""
W_types = tuple([
tuple(W_type) if isinstance(W_type, (list, tuple)) else W_type
for W_type in W_types
])
cartan_types = []
for W_type in W_types:
W_type = CartanType(W_type)
if not W_type.is_finite() or not W_type.is_irreducible():
raise ValueError(
"the given Cartan type of a component is not irreducible and finite"
)
cartan_types.append(W_type)
if len(W_types) == 1:
cls = IrreducibleComplexReflectionGroup
else:
cls = ComplexReflectionGroup
cls.__init__(self,
W_types,
index_set=index_set,
hyperplane_index_set=hyperplane_index_set,
reflection_index_set=reflection_index_set)
def CoxeterGroup(cartan_type, implementation = None):
"""
INPUT:
- ``cartan_type`` -- a cartan type (or coercible into; see :class:`CartanType`)
- ``implementation`` -- "permutation", "matrix", "coxeter3", or None (default: None)
Returns an implementation of the Coxeter group of type
``cartan_type``.
EXAMPLES:
If ``implementation`` is not specified, a permutation
representation is returned whenever possible (finite irreducible
Cartan type, with the GAP3 Chevie package available)::
sage: W = CoxeterGroup(["A",2])
sage: W # optional - chevie
Permutation Group with generators [(1,3)(2,5)(4,6), (1,4)(2,3)(5,6)]
Otherwise, a Weyl group is returned::
sage: W = CoxeterGroup(["A",3,1])
sage: W
Weyl Group of type ['A', 3, 1] (as a matrix group acting on the root space)
We now use the ``implementation`` option::
sage: W = CoxeterGroup(["A",2], implementation = "permutation") # optional - chevie
sage: W # optional - chevie
Permutation Group with generators [(1,3)(2,5)(4,6), (1,4)(2,3)(5,6)]
sage: W.category() # optional - chevie
Join of Category of finite permutation groups and Category of finite coxeter groups
sage: W = CoxeterGroup(["A",2], implementation = "matrix")
sage: W
Weyl Group of type ['A', 2] (as a matrix group acting on the ambient space)
sage: W = CoxeterGroup(["H",3], implementation = "matrix")
Traceback (most recent call last):
...
NotImplementedError: Coxeter group of type ['H', 3] as matrix group not implemented
sage: W = CoxeterGroup(["A",4,1], implementation = "permutation")
Traceback (most recent call last):
...
NotImplementedError: Coxeter group of type ['A', 4, 1] as permutation group not implemented
"""
assert implementation in ["permutation", "matrix", "coxeter3", None]
cartan_type = CartanType(cartan_type)
if implementation is None:
if cartan_type.is_finite() and cartan_type.is_irreducible() and is_chevie_available():
implementation = "permutation"
else:
implementation = "matrix"
if implementation == "coxeter3":
try:
from sage.libs.coxeter3.coxeter_group import CoxeterGroup
except ImportError:
raise RuntimeError, "coxeter3 must be installed"
else:
return CoxeterGroup(cartan_type)
if implementation == "permutation" and is_chevie_available() and \
cartan_type.is_finite() and cartan_type.is_irreducible():
return CoxeterGroupAsPermutationGroup(cartan_type)
elif implementation == "matrix" and cartan_type.is_crystallographic():
return WeylGroup(cartan_type)
else:
raise NotImplementedError, "Coxeter group of type %s as %s group not implemented "%(cartan_type, implementation)
def CoxeterGroup(data, implementation="reflection", base_ring=None, index_set=None):
"""
Return an implementation of the Coxeter group given by ``data``.
INPUT:
- ``data`` -- a Cartan type (or coercible into; see :class:`CartanType`)
or a Coxeter matrix or graph
- ``implementation`` -- (default: ``'reflection'``) can be one of
the following:
* ``'permutation'`` - as a permutation representation
* ``'matrix'`` - as a Weyl group (as a matrix group acting on the
root space); if this is not implemented, this uses the "reflection"
implementation
* ``'coxeter3'`` - using the coxeter3 package
* ``'reflection'`` - as elements in the reflection representation; see
:class:`~sage.groups.matrix_gps.coxeter_groups.CoxeterMatrixGroup`
- ``base_ring`` -- (optional) the base ring for the ``'reflection'``
implementation
- ``index_set`` -- (optional) the index set for the ``'reflection'``
implementation
EXAMPLES:
Now assume that ``data`` represents a Cartan type. If
``implementation`` is not specified, the reflection representation
is returned::
sage: W = CoxeterGroup(["A",2])
sage: W
Finite Coxeter group over Universal Cyclotomic Field with Coxeter matrix:
[1 3]
[3 1]
sage: W = CoxeterGroup(["A",3,1]); W
Coxeter group over Universal Cyclotomic Field with Coxeter matrix:
[1 3 2 3]
[3 1 3 2]
[2 3 1 3]
[3 2 3 1]
sage: W = CoxeterGroup(['H',3]); W
Finite Coxeter group over Universal Cyclotomic Field with Coxeter matrix:
[1 3 2]
[3 1 5]
[2 5 1]
We now use the ``implementation`` option::
sage: W = CoxeterGroup(["A",2], implementation = "permutation") # optional - chevie
sage: W # optional - chevie
Permutation Group with generators [(1,3)(2,5)(4,6), (1,4)(2,3)(5,6)]
sage: W.category() # optional - chevie
Join of Category of finite permutation groups and Category of finite coxeter groups
sage: W = CoxeterGroup(["A",2], implementation="matrix")
sage: W
Weyl Group of type ['A', 2] (as a matrix group acting on the ambient space)
sage: W = CoxeterGroup(["H",3], implementation="matrix")
sage: W
Finite Coxeter group over Universal Cyclotomic Field with Coxeter matrix:
[1 3 2]
[3 1 5]
[2 5 1]
sage: W = CoxeterGroup(["H",3], implementation="reflection")
sage: W
Finite Coxeter group over Universal Cyclotomic Field with Coxeter matrix:
[1 3 2]
[3 1 5]
[2 5 1]
sage: W = CoxeterGroup(["A",4,1], implementation="permutation")
Traceback (most recent call last):
...
NotImplementedError: Coxeter group of type ['A', 4, 1] as permutation group not implemented
We use the different options for the "reflection" implementation::
sage: W = CoxeterGroup(["H",3], implementation="reflection", base_ring=RR)
sage: W
Finite Coxeter group over Real Field with 53 bits of precision with Coxeter matrix:
[1 3 2]
[3 1 5]
[2 5 1]
sage: W = CoxeterGroup([[1,10],[10,1]], implementation="reflection", index_set=['a','b'], base_ring=SR)
sage: W
Finite Coxeter group over Symbolic Ring with Coxeter matrix:
[ 1 10]
[10 1]
TESTS::
sage: W = groups.misc.CoxeterGroup(["H",3])
"""
if implementation not in ["permutation", "matrix", "coxeter3", "reflection", None]:
raise ValueError("invalid type implementation")
try:
cartan_type = CartanType(data)
except (TypeError, ValueError): # If it is not a Cartan type, try to see if we can represent it as a matrix group
return CoxeterMatrixGroup(data, base_ring, index_set)
if implementation is None:
implementation = "matrix"
if implementation == "reflection":
return CoxeterMatrixGroup(cartan_type, base_ring, index_set)
if implementation == "coxeter3":
try:
from sage.libs.coxeter3.coxeter_group import CoxeterGroup
except ImportError:
raise RuntimeError("coxeter3 must be installed")
else:
return CoxeterGroup(cartan_type)
if implementation == "permutation" and is_chevie_available() and \
cartan_type.is_finite() and cartan_type.is_irreducible():
return CoxeterGroupAsPermutationGroup(cartan_type)
elif implementation == "matrix":
if cartan_type.is_crystallographic():
return WeylGroup(cartan_type)
return CoxeterMatrixGroup(cartan_type, base_ring, index_set)
raise NotImplementedError("Coxeter group of type {} as {} group not implemented".format(cartan_type, implementation))
def CoxeterGroup(data,
implementation="reflection",
base_ring=None,
index_set=None):
"""
Return an implementation of the Coxeter group given by ``data``.
INPUT:
- ``data`` -- a Cartan type (or coercible into; see :class:`CartanType`)
or a Coxeter matrix or graph
- ``implementation`` -- (default: ``'reflection'``) can be one of
the following:
* ``'permutation'`` - as a permutation representation
* ``'matrix'`` - as a Weyl group (as a matrix group acting on the
root space); if this is not implemented, this uses the "reflection"
implementation
* ``'coxeter3'`` - using the coxeter3 package
* ``'reflection'`` - as elements in the reflection representation; see
:class:`~sage.groups.matrix_gps.coxeter_groups.CoxeterMatrixGroup`
- ``base_ring`` -- (optional) the base ring for the ``'reflection'``
implementation
- ``index_set`` -- (optional) the index set for the ``'reflection'``
implementation
EXAMPLES:
Now assume that ``data`` represents a Cartan type. If
``implementation`` is not specified, the reflection representation
is returned::
sage: W = CoxeterGroup(["A",2])
sage: W
Finite Coxeter group over Universal Cyclotomic Field with Coxeter matrix:
[1 3]
[3 1]
sage: W = CoxeterGroup(["A",3,1]); W
Coxeter group over Universal Cyclotomic Field with Coxeter matrix:
[1 3 2 3]
[3 1 3 2]
[2 3 1 3]
[3 2 3 1]
sage: W = CoxeterGroup(['H',3]); W
Finite Coxeter group over Universal Cyclotomic Field with Coxeter matrix:
[1 3 2]
[3 1 5]
[2 5 1]
We now use the ``implementation`` option::
sage: W = CoxeterGroup(["A",2], implementation = "permutation") # optional - chevie
sage: W # optional - chevie
Permutation Group with generators [(1,3)(2,5)(4,6), (1,4)(2,3)(5,6)]
sage: W.category() # optional - chevie
Join of Category of finite permutation groups and Category of finite coxeter groups
sage: W = CoxeterGroup(["A",2], implementation="matrix")
sage: W
Weyl Group of type ['A', 2] (as a matrix group acting on the ambient space)
sage: W = CoxeterGroup(["H",3], implementation="matrix")
sage: W
Finite Coxeter group over Universal Cyclotomic Field with Coxeter matrix:
[1 3 2]
[3 1 5]
[2 5 1]
sage: W = CoxeterGroup(["H",3], implementation="reflection")
sage: W
Finite Coxeter group over Universal Cyclotomic Field with Coxeter matrix:
[1 3 2]
[3 1 5]
[2 5 1]
sage: W = CoxeterGroup(["A",4,1], implementation="permutation")
Traceback (most recent call last):
...
NotImplementedError: Coxeter group of type ['A', 4, 1] as permutation group not implemented
We use the different options for the "reflection" implementation::
sage: W = CoxeterGroup(["H",3], implementation="reflection", base_ring=RR)
sage: W
Finite Coxeter group over Real Field with 53 bits of precision with Coxeter matrix:
[1 3 2]
[3 1 5]
[2 5 1]
sage: W = CoxeterGroup([[1,10],[10,1]], implementation="reflection", index_set=['a','b'], base_ring=SR)
sage: W
Finite Coxeter group over Symbolic Ring with Coxeter matrix:
[ 1 10]
[10 1]
TESTS::
sage: W = groups.misc.CoxeterGroup(["H",3])
"""
if implementation not in [
"permutation", "matrix", "coxeter3", "reflection", None
]:
raise ValueError("invalid type implementation")
try:
cartan_type = CartanType(data)
except (
TypeError, ValueError
): # If it is not a Cartan type, try to see if we can represent it as a matrix group
return CoxeterMatrixGroup(data, base_ring, index_set)
if implementation is None:
implementation = "matrix"
if implementation == "reflection":
return CoxeterMatrixGroup(cartan_type, base_ring, index_set)
if implementation == "coxeter3":
try:
from sage.libs.coxeter3.coxeter_group import CoxeterGroup
except ImportError:
raise RuntimeError("coxeter3 must be installed")
else:
return CoxeterGroup(cartan_type)
if implementation == "permutation" and is_chevie_available() and \
cartan_type.is_finite() and cartan_type.is_irreducible():
return CoxeterGroupAsPermutationGroup(cartan_type)
elif implementation == "matrix":
if cartan_type.is_crystallographic():
return WeylGroup(cartan_type)
return CoxeterMatrixGroup(cartan_type, base_ring, index_set)
raise NotImplementedError(
"Coxeter group of type {} as {} group not implemented".format(
cartan_type, implementation))
def CoxeterGroup(cartan_type, implementation=None):
"""
INPUT:
- ``cartan_type`` -- a cartan type (or coercible into; see :class:`CartanType`)
- ``implementation`` -- "permutation", "matrix", "coxeter3", or None (default: None)
Returns an implementation of the Coxeter group of type
``cartan_type``.
EXAMPLES:
If ``implementation`` is not specified, a permutation
representation is returned whenever possible (finite irreducible
Cartan type, with the GAP3 Chevie package available)::
sage: W = CoxeterGroup(["A",2])
sage: W # optional - chevie
Permutation Group with generators [(1,3)(2,5)(4,6), (1,4)(2,3)(5,6)]
Otherwise, a Weyl group is returned::
sage: W = CoxeterGroup(["A",3,1])
sage: W
Weyl Group of type ['A', 3, 1] (as a matrix group acting on the root space)
We now use the ``implementation`` option::
sage: W = CoxeterGroup(["A",2], implementation = "permutation") # optional - chevie
sage: W # optional - chevie
Permutation Group with generators [(1,3)(2,5)(4,6), (1,4)(2,3)(5,6)]
sage: W.category() # optional - chevie
Join of Category of finite permutation groups and Category of finite coxeter groups
sage: W = CoxeterGroup(["A",2], implementation = "matrix")
sage: W
Weyl Group of type ['A', 2] (as a matrix group acting on the ambient space)
sage: W = CoxeterGroup(["H",3], implementation = "matrix")
Traceback (most recent call last):
...
NotImplementedError: Coxeter group of type ['H', 3] as matrix group not implemented
sage: W = CoxeterGroup(["A",4,1], implementation = "permutation")
Traceback (most recent call last):
...
NotImplementedError: Coxeter group of type ['A', 4, 1] as permutation group not implemented
"""
assert implementation in ["permutation", "matrix", "coxeter3", None]
cartan_type = CartanType(cartan_type)
if implementation is None:
if cartan_type.is_finite() and cartan_type.is_irreducible(
) and is_chevie_available():
implementation = "permutation"
else:
implementation = "matrix"
if implementation == "coxeter3":
try:
from sage.libs.coxeter3.coxeter_group import CoxeterGroup
except ImportError:
raise RuntimeError, "coxeter3 must be installed"
else:
return CoxeterGroup(cartan_type)
if implementation == "permutation" and is_chevie_available() and \
cartan_type.is_finite() and cartan_type.is_irreducible():
return CoxeterGroupAsPermutationGroup(cartan_type)
elif implementation == "matrix" and cartan_type.is_crystalographic():
return WeylGroup(cartan_type)
else:
raise NotImplementedError, "Coxeter group of type %s as %s group not implemented " % (
cartan_type, implementation)
