Common category for Generalized Coxeter Groups or Complex Reflection Groups#

class sage.categories.complex_reflection_or_generalized_coxeter_groups.ComplexReflectionOrGeneralizedCoxeterGroups[source]#

Bases: Category_singleton

The category of complex reflection groups or generalized Coxeter groups.

Finite Coxeter groups can be defined equivalently as groups generated by reflections, or by presentations. Over the last decades, the theory has been generalized in both directions, leading to the study of (finite) complex reflection groups on the one hand, and (finite) generalized Coxeter groups on the other hand. Many of the features remain similar, yet, in the current state of the art, there is no general theory covering both directions.

This is reflected by the name of this category which is about factoring out the common code, tests, and declarations.

A group in this category has:

  • A distinguished finite set of generators \((s_i)_I\), called simple reflections. The set \(I\) is called the index set. The name “reflection” is somewhat of an abuse as they can have higher order; still, they are all of finite order: \(s_i^k=1\) for some \(k\).

  • A collection of distinguished reflections which are the conjugates of the simple reflections. For complex reflection groups, they are in one-to-one correspondence with the reflection hyperplanes and share the same index set.

  • A collection of reflections which are the conjugates of all the non trivial powers of the simple reflections.

The usual notions of reduced words, length, irreducibility, etc can be canonically defined from the above.

The following methods must be implemented:

Optionally one can define analog methods for distinguished reflections and reflections (see below).

At least one of the following methods must be implemented:

It’s recommended to implement either _mul_ or both apply_simple_reflection_left and apply_simple_reflection_right.

See also

  • complex_reflection_groups.ComplexReflectionGroups

  • generalized_coxeter_groups.GeneralizedCoxeterGroups

EXAMPLES:

sage: from sage.categories.complex_reflection_or_generalized_coxeter_groups import ComplexReflectionOrGeneralizedCoxeterGroups
sage: C = ComplexReflectionOrGeneralizedCoxeterGroups(); C
Category of complex reflection or generalized Coxeter groups
sage: C.super_categories()
[Category of finitely generated enumerated groups]

sage: C.required_methods()
{'element': {'optional': ['reflection_length'],
             'required': []},
  'parent': {'optional': ['distinguished_reflection', 'hyperplane_index_set',
                          'irreducible_components',
                          'reflection', 'reflection_index_set'],
            'required':  ['__contains__', 'index_set']}}
>>> from sage.all import *
>>> from sage.categories.complex_reflection_or_generalized_coxeter_groups import ComplexReflectionOrGeneralizedCoxeterGroups
>>> C = ComplexReflectionOrGeneralizedCoxeterGroups(); C
Category of complex reflection or generalized Coxeter groups
>>> C.super_categories()
[Category of finitely generated enumerated groups]

>>> C.required_methods()
{'element': {'optional': ['reflection_length'],
             'required': []},
  'parent': {'optional': ['distinguished_reflection', 'hyperplane_index_set',
                          'irreducible_components',
                          'reflection', 'reflection_index_set'],
            'required':  ['__contains__', 'index_set']}}
class ElementMethods[source]#

Bases: object

apply_conjugation_by_simple_reflection(i)[source]#

Conjugate self by the i-th simple reflection.

EXAMPLES:

sage: W = WeylGroup(['A',3])                                            # needs sage.rings.number_field
sage: w = W.from_reduced_word([3,1,2,1])                                # needs sage.rings.number_field
sage: w.apply_conjugation_by_simple_reflection(1).reduced_word()        # needs sage.rings.number_field
[3, 2]
>>> from sage.all import *
>>> W = WeylGroup(['A',Integer(3)])                                            # needs sage.rings.number_field
>>> w = W.from_reduced_word([Integer(3),Integer(1),Integer(2),Integer(1)])                                # needs sage.rings.number_field
>>> w.apply_conjugation_by_simple_reflection(Integer(1)).reduced_word()        # needs sage.rings.number_field
[3, 2]
apply_reflections(word, side='right', word_type='all')[source]#

Return the result of the (left/right) multiplication of self by word.

INPUT:

  • word – a sequence of indices of reflections

  • side – (default: 'right') indicates multiplying from left or right

  • word_type – (default: 'all'): either 'simple', 'distinguished', or 'all'

EXAMPLES:

sage: # optional - gap3
sage: W = ReflectionGroup((1,1,3))
sage: W.one().apply_reflections([1])
(1,4)(2,3)(5,6)
sage: W.one().apply_reflections([2])
(1,3)(2,5)(4,6)
sage: W.one().apply_reflections([2,1])
(1,2,6)(3,4,5)


sage: W = CoxeterGroups().example()
sage: w = W.an_element(); w
(1, 2, 3, 0)
sage: w.apply_reflections([0,1], word_type='simple')
(2, 3, 1, 0)
sage: w
(1, 2, 3, 0)
sage: w.apply_reflections([0,1], side='left', word_type='simple')
(0, 1, 3, 2)

sage: # needs sage.rings.number_field
sage: W = WeylGroup("A3", prefix='s')
sage: w = W.an_element(); w
s1*s2*s3
sage: AS = W.domain()
sage: r1 = AS.roots()[4]; r1
(0, 1, 0, -1)
sage: r2 = AS.roots()[5]; r2
(0, 0, 1, -1)
sage: w.apply_reflections([r1, r2], word_type='all')
s1

sage: # optional - gap3
sage: W = ReflectionGroup((1,1,3))
sage: W.one().apply_reflections([1],   word_type='distinguished')
(1,4)(2,3)(5,6)
sage: W.one().apply_reflections([2],   word_type='distinguished')
(1,3)(2,5)(4,6)
sage: W.one().apply_reflections([3],   word_type='distinguished')
(1,5)(2,4)(3,6)
sage: W.one().apply_reflections([2,1], word_type='distinguished')
(1,2,6)(3,4,5)

sage: # optional - gap3
sage: W = ReflectionGroup((1,1,3), hyperplane_index_set=['A','B','C']); W
Irreducible real reflection group of rank 2 and type A2
sage: W.one().apply_reflections(['A'], word_type='distinguished')
(1,4)(2,3)(5,6)
>>> from sage.all import *
>>> # optional - gap3
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(3)))
>>> W.one().apply_reflections([Integer(1)])
(1,4)(2,3)(5,6)
>>> W.one().apply_reflections([Integer(2)])
(1,3)(2,5)(4,6)
>>> W.one().apply_reflections([Integer(2),Integer(1)])
(1,2,6)(3,4,5)


>>> W = CoxeterGroups().example()
>>> w = W.an_element(); w
(1, 2, 3, 0)
>>> w.apply_reflections([Integer(0),Integer(1)], word_type='simple')
(2, 3, 1, 0)
>>> w
(1, 2, 3, 0)
>>> w.apply_reflections([Integer(0),Integer(1)], side='left', word_type='simple')
(0, 1, 3, 2)

>>> # needs sage.rings.number_field
>>> W = WeylGroup("A3", prefix='s')
>>> w = W.an_element(); w
s1*s2*s3
>>> AS = W.domain()
>>> r1 = AS.roots()[Integer(4)]; r1
(0, 1, 0, -1)
>>> r2 = AS.roots()[Integer(5)]; r2
(0, 0, 1, -1)
>>> w.apply_reflections([r1, r2], word_type='all')
s1

>>> # optional - gap3
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(3)))
>>> W.one().apply_reflections([Integer(1)],   word_type='distinguished')
(1,4)(2,3)(5,6)
>>> W.one().apply_reflections([Integer(2)],   word_type='distinguished')
(1,3)(2,5)(4,6)
>>> W.one().apply_reflections([Integer(3)],   word_type='distinguished')
(1,5)(2,4)(3,6)
>>> W.one().apply_reflections([Integer(2),Integer(1)], word_type='distinguished')
(1,2,6)(3,4,5)

>>> # optional - gap3
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(3)), hyperplane_index_set=['A','B','C']); W
Irreducible real reflection group of rank 2 and type A2
>>> W.one().apply_reflections(['A'], word_type='distinguished')
(1,4)(2,3)(5,6)
apply_simple_reflection(i, side='right')[source]#

Return self multiplied by the simple reflection s[i].

INPUT:

  • i – an element of the index set

  • side – (default: "right") "left" or "right"

This default implementation simply calls apply_simple_reflection_left() or apply_simple_reflection_right().

EXAMPLES:

sage: W = CoxeterGroups().example()
sage: w = W.an_element(); w
(1, 2, 3, 0)
sage: w.apply_simple_reflection(0, side="left")
(0, 2, 3, 1)
sage: w.apply_simple_reflection(1, side="left")
(2, 1, 3, 0)
sage: w.apply_simple_reflection(2, side="left")
(1, 3, 2, 0)
sage: w.apply_simple_reflection(0, side="right")
(2, 1, 3, 0)
sage: w.apply_simple_reflection(1, side="right")
(1, 3, 2, 0)
sage: w.apply_simple_reflection(2, side="right")
(1, 2, 0, 3)
>>> from sage.all import *
>>> W = CoxeterGroups().example()
>>> w = W.an_element(); w
(1, 2, 3, 0)
>>> w.apply_simple_reflection(Integer(0), side="left")
(0, 2, 3, 1)
>>> w.apply_simple_reflection(Integer(1), side="left")
(2, 1, 3, 0)
>>> w.apply_simple_reflection(Integer(2), side="left")
(1, 3, 2, 0)
>>> w.apply_simple_reflection(Integer(0), side="right")
(2, 1, 3, 0)
>>> w.apply_simple_reflection(Integer(1), side="right")
(1, 3, 2, 0)
>>> w.apply_simple_reflection(Integer(2), side="right")
(1, 2, 0, 3)

By default, side is "right":

sage: w.apply_simple_reflection(0)
(2, 1, 3, 0)
>>> from sage.all import *
>>> w.apply_simple_reflection(Integer(0))
(2, 1, 3, 0)

Some tests with a complex reflection group:

sage: # needs sage.combinat
sage: from sage.categories.complex_reflection_groups import ComplexReflectionGroups
sage: W = ComplexReflectionGroups().example(); W
5-colored permutations of size 3
sage: w = W.an_element(); w
[[1, 0, 0], [3, 1, 2]]
sage: w.apply_simple_reflection(1, side="left")
[[0, 1, 0], [1, 3, 2]]
sage: w.apply_simple_reflection(2, side="left")
[[1, 0, 0], [3, 2, 1]]
sage: w.apply_simple_reflection(3, side="left")
[[1, 0, 1], [3, 1, 2]]
sage: w.apply_simple_reflection(1, side="right")
[[1, 0, 0], [3, 2, 1]]
sage: w.apply_simple_reflection(2, side="right")
[[1, 0, 0], [2, 1, 3]]
sage: w.apply_simple_reflection(3, side="right")
[[2, 0, 0], [3, 1, 2]]
>>> from sage.all import *
>>> # needs sage.combinat
>>> from sage.categories.complex_reflection_groups import ComplexReflectionGroups
>>> W = ComplexReflectionGroups().example(); W
5-colored permutations of size 3
>>> w = W.an_element(); w
[[1, 0, 0], [3, 1, 2]]
>>> w.apply_simple_reflection(Integer(1), side="left")
[[0, 1, 0], [1, 3, 2]]
>>> w.apply_simple_reflection(Integer(2), side="left")
[[1, 0, 0], [3, 2, 1]]
>>> w.apply_simple_reflection(Integer(3), side="left")
[[1, 0, 1], [3, 1, 2]]
>>> w.apply_simple_reflection(Integer(1), side="right")
[[1, 0, 0], [3, 2, 1]]
>>> w.apply_simple_reflection(Integer(2), side="right")
[[1, 0, 0], [2, 1, 3]]
>>> w.apply_simple_reflection(Integer(3), side="right")
[[2, 0, 0], [3, 1, 2]]
apply_simple_reflection_left(i)[source]#

Return self multiplied by the simple reflection s[i] on the left.

This low level method is used intensively. Coxeter groups are encouraged to override this straightforward implementation whenever a faster approach exists.

EXAMPLES:

sage: W = CoxeterGroups().example()
sage: w = W.an_element(); w
(1, 2, 3, 0)
sage: w.apply_simple_reflection_left(0)
(0, 2, 3, 1)
sage: w.apply_simple_reflection_left(1)
(2, 1, 3, 0)
sage: w.apply_simple_reflection_left(2)
(1, 3, 2, 0)
>>> from sage.all import *
>>> W = CoxeterGroups().example()
>>> w = W.an_element(); w
(1, 2, 3, 0)
>>> w.apply_simple_reflection_left(Integer(0))
(0, 2, 3, 1)
>>> w.apply_simple_reflection_left(Integer(1))
(2, 1, 3, 0)
>>> w.apply_simple_reflection_left(Integer(2))
(1, 3, 2, 0)

EXAMPLES:

sage: # needs sage.combinat
sage: from sage.categories.complex_reflection_groups import ComplexReflectionGroups
sage: W = ComplexReflectionGroups().example()
sage: w = W.an_element(); w
[[1, 0, 0], [3, 1, 2]]
sage: w.apply_simple_reflection_left(1)
[[0, 1, 0], [1, 3, 2]]
sage: w.apply_simple_reflection_left(2)
[[1, 0, 0], [3, 2, 1]]
sage: w.apply_simple_reflection_left(3)
[[1, 0, 1], [3, 1, 2]]
>>> from sage.all import *
>>> # needs sage.combinat
>>> from sage.categories.complex_reflection_groups import ComplexReflectionGroups
>>> W = ComplexReflectionGroups().example()
>>> w = W.an_element(); w
[[1, 0, 0], [3, 1, 2]]
>>> w.apply_simple_reflection_left(Integer(1))
[[0, 1, 0], [1, 3, 2]]
>>> w.apply_simple_reflection_left(Integer(2))
[[1, 0, 0], [3, 2, 1]]
>>> w.apply_simple_reflection_left(Integer(3))
[[1, 0, 1], [3, 1, 2]]
apply_simple_reflection_right(i)[source]#

Return self multiplied by the simple reflection s[i] on the right.

This low level method is used intensively. Coxeter groups are encouraged to override this straightforward implementation whenever a faster approach exists.

EXAMPLES:

sage: W = CoxeterGroups().example()
sage: w = W.an_element(); w
(1, 2, 3, 0)
sage: w.apply_simple_reflection_right(0)
(2, 1, 3, 0)
sage: w.apply_simple_reflection_right(1)
(1, 3, 2, 0)
sage: w.apply_simple_reflection_right(2)
(1, 2, 0, 3)

sage: # needs sage.combinat
sage: from sage.categories.complex_reflection_groups import ComplexReflectionGroups
sage: W = ComplexReflectionGroups().example()
sage: w = W.an_element(); w
[[1, 0, 0], [3, 1, 2]]
sage: w.apply_simple_reflection_right(1)
[[1, 0, 0], [3, 2, 1]]
sage: w.apply_simple_reflection_right(2)
[[1, 0, 0], [2, 1, 3]]
sage: w.apply_simple_reflection_right(3)
[[2, 0, 0], [3, 1, 2]]
>>> from sage.all import *
>>> W = CoxeterGroups().example()
>>> w = W.an_element(); w
(1, 2, 3, 0)
>>> w.apply_simple_reflection_right(Integer(0))
(2, 1, 3, 0)
>>> w.apply_simple_reflection_right(Integer(1))
(1, 3, 2, 0)
>>> w.apply_simple_reflection_right(Integer(2))
(1, 2, 0, 3)

>>> # needs sage.combinat
>>> from sage.categories.complex_reflection_groups import ComplexReflectionGroups
>>> W = ComplexReflectionGroups().example()
>>> w = W.an_element(); w
[[1, 0, 0], [3, 1, 2]]
>>> w.apply_simple_reflection_right(Integer(1))
[[1, 0, 0], [3, 2, 1]]
>>> w.apply_simple_reflection_right(Integer(2))
[[1, 0, 0], [2, 1, 3]]
>>> w.apply_simple_reflection_right(Integer(3))
[[2, 0, 0], [3, 1, 2]]
apply_simple_reflections(word, side='right', type='simple')[source]#

Return the result of the (left/right) multiplication of self by word.

INPUT:

  • word – a sequence of indices of simple reflections

  • side – (default: 'right') indicates multiplying from left or right

This is a specialized implementation of apply_reflections() for the simple reflections. The rationale for its existence are:

  • It can take advantage of apply_simple_reflection, which often is less expensive than computing a product.

  • It reduced burden on implementations that would want to provide an optimized version of this method.

EXAMPLES:

sage: W = CoxeterGroups().example()
sage: w = W.an_element(); w
(1, 2, 3, 0)
sage: w.apply_simple_reflections([0,1])
(2, 3, 1, 0)
sage: w
(1, 2, 3, 0)
sage: w.apply_simple_reflections([0,1],side='left')
(0, 1, 3, 2)
>>> from sage.all import *
>>> W = CoxeterGroups().example()
>>> w = W.an_element(); w
(1, 2, 3, 0)
>>> w.apply_simple_reflections([Integer(0),Integer(1)])
(2, 3, 1, 0)
>>> w
(1, 2, 3, 0)
>>> w.apply_simple_reflections([Integer(0),Integer(1)],side='left')
(0, 1, 3, 2)
is_reflection()[source]#

Return whether self is a reflection.

EXAMPLES:

sage: # optional - gap3
sage: W = ReflectionGroup((1,1,4))
sage: [t.is_reflection() for t in W.reflections()]
[True, True, True, True, True, True]
sage: len([t for t in W.reflections() if t.is_reflection()])
6
sage: W = ReflectionGroup((2,1,3))
sage: [t.is_reflection() for t in W.reflections()]
[True, True, True, True, True, True, True, True, True]
sage: len([t for t in W.reflections() if t.is_reflection()])
9
>>> from sage.all import *
>>> # optional - gap3
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(4)))
>>> [t.is_reflection() for t in W.reflections()]
[True, True, True, True, True, True]
>>> len([t for t in W.reflections() if t.is_reflection()])
6
>>> W = ReflectionGroup((Integer(2),Integer(1),Integer(3)))
>>> [t.is_reflection() for t in W.reflections()]
[True, True, True, True, True, True, True, True, True]
>>> len([t for t in W.reflections() if t.is_reflection()])
9
reflection_length()[source]#

Return the reflection length of self.

This is the minimal length of a factorization of self into reflections.

EXAMPLES:

sage: # optional - gap3
sage: W = ReflectionGroup((1,1,2))
sage: sorted([t.reflection_length() for t in W])
[0, 1]
sage: W = ReflectionGroup((2,1,2))
sage: sorted([t.reflection_length() for t in W])
[0, 1, 1, 1, 1, 2, 2, 2]
sage: W = ReflectionGroup((3,1,2))
sage: sorted([t.reflection_length() for t in W])
[0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
sage: W = ReflectionGroup((2,2,2))
sage: sorted([t.reflection_length() for t in W])
[0, 1, 1, 2]
>>> from sage.all import *
>>> # optional - gap3
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(2)))
>>> sorted([t.reflection_length() for t in W])
[0, 1]
>>> W = ReflectionGroup((Integer(2),Integer(1),Integer(2)))
>>> sorted([t.reflection_length() for t in W])
[0, 1, 1, 1, 1, 2, 2, 2]
>>> W = ReflectionGroup((Integer(3),Integer(1),Integer(2)))
>>> sorted([t.reflection_length() for t in W])
[0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
>>> W = ReflectionGroup((Integer(2),Integer(2),Integer(2)))
>>> sorted([t.reflection_length() for t in W])
[0, 1, 1, 2]
class Irreducible(base_category)[source]#

Bases: CategoryWithAxiom

class ParentMethods[source]#

Bases: object

irreducible_components()[source]#

Return a list containing all irreducible components of self as finite reflection groups.

EXAMPLES:

sage: W = ColoredPermutations(4, 3)                                 # needs sage.combinat
sage: W.irreducible_components()                                    # needs sage.combinat
[4-colored permutations of size 3]
>>> from sage.all import *
>>> W = ColoredPermutations(Integer(4), Integer(3))                                 # needs sage.combinat
>>> W.irreducible_components()                                    # needs sage.combinat
[4-colored permutations of size 3]
class ParentMethods[source]#

Bases: object

distinguished_reflection(i)[source]#

Return the \(i\)-th distinguished reflection of self.

INPUT:

  • i – an element of the index set of the distinguished reflections.

EXAMPLES:

sage: # optional - gap3
sage: W = ReflectionGroup((1,1,4),
....:                     hyperplane_index_set=('a','b','c','d','e','f'))
sage: for i in W.hyperplane_index_set():
....:     print('%s %s'%(i, W.distinguished_reflection(i)))
a (1,7)(2,4)(5,6)(8,10)(11,12)
b (1,4)(2,8)(3,5)(7,10)(9,11)
c (2,5)(3,9)(4,6)(8,11)(10,12)
d (1,8)(2,7)(3,6)(4,10)(9,12)
e (1,6)(2,9)(3,8)(5,11)(7,12)
f (1,11)(3,10)(4,9)(5,7)(6,12)
>>> from sage.all import *
>>> # optional - gap3
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(4)),
...                     hyperplane_index_set=('a','b','c','d','e','f'))
>>> for i in W.hyperplane_index_set():
...     print('%s %s'%(i, W.distinguished_reflection(i)))
a (1,7)(2,4)(5,6)(8,10)(11,12)
b (1,4)(2,8)(3,5)(7,10)(9,11)
c (2,5)(3,9)(4,6)(8,11)(10,12)
d (1,8)(2,7)(3,6)(4,10)(9,12)
e (1,6)(2,9)(3,8)(5,11)(7,12)
f (1,11)(3,10)(4,9)(5,7)(6,12)
distinguished_reflections()[source]#

Return a finite family containing the distinguished reflections of self, indexed by hyperplane_index_set().

A distinguished reflection is a conjugate of a simple reflection. For a Coxeter group, reflections and distinguished reflections coincide. For a Complex reflection groups this is a reflection acting on the complement of the fixed hyperplane \(H\) as \(\operatorname{exp}(2 \pi i / n)\), where \(n\) is the order of the reflection subgroup fixing \(H\).

EXAMPLES:

sage: # optional - gap3
sage: W = ReflectionGroup((1,1,3))
sage: distinguished_reflections = W.distinguished_reflections()
sage: for index in sorted(distinguished_reflections.keys()):
....:     print('%s %s'%(index, distinguished_reflections[index]))
1 (1,4)(2,3)(5,6)
2 (1,3)(2,5)(4,6)
3 (1,5)(2,4)(3,6)
sage: W = ReflectionGroup((1,1,3), hyperplane_index_set=['a','b','c'])
sage: distinguished_reflections = W.distinguished_reflections()
sage: for index in sorted(distinguished_reflections.keys()):
....:     print('%s %s'%(index, distinguished_reflections[index]))
a (1,4)(2,3)(5,6)
b (1,3)(2,5)(4,6)
c (1,5)(2,4)(3,6)
sage: W = ReflectionGroup((3,1,1))
sage: distinguished_reflections = W.distinguished_reflections()
sage: for index in sorted(distinguished_reflections.keys()):
....:     print('%s %s'%(index, distinguished_reflections[index]))
1 (1,2,3)
sage: W = ReflectionGroup((1,1,3), (3,1,2))
sage: distinguished_reflections = W.distinguished_reflections()
sage: for index in sorted(distinguished_reflections.keys()):
....:     print('%s %s'%(index, distinguished_reflections[index]))
1 (1,6)(2,5)(7,8)
2 (1,5)(2,7)(6,8)
3 (3,9,15)(4,10,16)(12,17,23)(14,18,24)(20,25,29)(21,22,26)(27,28,30)
4 (3,11)(4,12)(9,13)(10,14)(15,19)(16,20)(17,21)(18,22)(23,27)(24,28)(25,26)(29,30)
5 (1,7)(2,6)(5,8)
6 (3,19)(4,25)(9,11)(10,17)(12,28)(13,15)(14,30)(16,18)(20,27)(21,29)(22,23)(24,26)
7 (4,21,27)(10,22,28)(11,13,19)(12,14,20)(16,26,30)(17,18,25)(23,24,29)
8 (3,13)(4,24)(9,19)(10,29)(11,15)(12,26)(14,21)(16,23)(17,30)(18,27)(20,22)(25,28)
>>> from sage.all import *
>>> # optional - gap3
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(3)))
>>> distinguished_reflections = W.distinguished_reflections()
>>> for index in sorted(distinguished_reflections.keys()):
...     print('%s %s'%(index, distinguished_reflections[index]))
1 (1,4)(2,3)(5,6)
2 (1,3)(2,5)(4,6)
3 (1,5)(2,4)(3,6)
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(3)), hyperplane_index_set=['a','b','c'])
>>> distinguished_reflections = W.distinguished_reflections()
>>> for index in sorted(distinguished_reflections.keys()):
...     print('%s %s'%(index, distinguished_reflections[index]))
a (1,4)(2,3)(5,6)
b (1,3)(2,5)(4,6)
c (1,5)(2,4)(3,6)
>>> W = ReflectionGroup((Integer(3),Integer(1),Integer(1)))
>>> distinguished_reflections = W.distinguished_reflections()
>>> for index in sorted(distinguished_reflections.keys()):
...     print('%s %s'%(index, distinguished_reflections[index]))
1 (1,2,3)
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(3)), (Integer(3),Integer(1),Integer(2)))
>>> distinguished_reflections = W.distinguished_reflections()
>>> for index in sorted(distinguished_reflections.keys()):
...     print('%s %s'%(index, distinguished_reflections[index]))
1 (1,6)(2,5)(7,8)
2 (1,5)(2,7)(6,8)
3 (3,9,15)(4,10,16)(12,17,23)(14,18,24)(20,25,29)(21,22,26)(27,28,30)
4 (3,11)(4,12)(9,13)(10,14)(15,19)(16,20)(17,21)(18,22)(23,27)(24,28)(25,26)(29,30)
5 (1,7)(2,6)(5,8)
6 (3,19)(4,25)(9,11)(10,17)(12,28)(13,15)(14,30)(16,18)(20,27)(21,29)(22,23)(24,26)
7 (4,21,27)(10,22,28)(11,13,19)(12,14,20)(16,26,30)(17,18,25)(23,24,29)
8 (3,13)(4,24)(9,19)(10,29)(11,15)(12,26)(14,21)(16,23)(17,30)(18,27)(20,22)(25,28)
from_reduced_word(word, word_type='simple')[source]#

Return an element of self from its (reduced) word.

INPUT:

  • word – a list (or iterable) of elements of the index set of self (resp. of the distinguished or of all reflections)

  • word_type – (default: 'simple'): either 'simple', 'distinguished', or 'all'

If word is \([i_1,i_2,\ldots,i_k]\), then this returns the corresponding product of simple reflections \(s_{i_1} s_{i_2} \cdots s_{i_k}\).

If word_type is 'distinguished' (resp. 'all'), then the product of the distinguished reflections (resp. all reflections) is returned.

Note

The main use case is for constructing elements from reduced words, hence the name of this method. However, the input word need not be reduced.

EXAMPLES:

sage: W = CoxeterGroups().example(); W
The symmetric group on {0, ..., 3}
sage: s = W.simple_reflections()
sage: W.from_reduced_word([0,2,0,1])
(0, 3, 1, 2)
sage: W.from_reduced_word((0,2,0,1))
(0, 3, 1, 2)
sage: s[0]*s[2]*s[0]*s[1]
(0, 3, 1, 2)
>>> from sage.all import *
>>> W = CoxeterGroups().example(); W
The symmetric group on {0, ..., 3}
>>> s = W.simple_reflections()
>>> W.from_reduced_word([Integer(0),Integer(2),Integer(0),Integer(1)])
(0, 3, 1, 2)
>>> W.from_reduced_word((Integer(0),Integer(2),Integer(0),Integer(1)))
(0, 3, 1, 2)
>>> s[Integer(0)]*s[Integer(2)]*s[Integer(0)]*s[Integer(1)]
(0, 3, 1, 2)

We now experiment with the different values for word_type for the colored symmetric group:

sage: # needs sage.combinat
sage: W = ColoredPermutations(1,4)
sage: W.from_reduced_word([1,2,1,2,1,2])
[[0, 0, 0, 0], [1, 2, 3, 4]]
sage: W.from_reduced_word([1, 2, 3]).reduced_word()
[1, 2, 3]

sage: # needs sage.rings.number_field
sage: W = WeylGroup("A3", prefix='s')
sage: AS = W.domain()
sage: r1 = AS.roots()[4]; r1
(0, 1, 0, -1)
sage: r2 = AS.roots()[5]; r2
(0, 0, 1, -1)
sage: W.from_reduced_word([r1, r2], word_type='all')
s3*s2

sage: W = WeylGroup("G2", prefix='s')                                   # needs sage.rings.number_field
sage: W.from_reduced_word(W.domain().positive_roots(),                  # needs sage.rings.number_field
....:                     word_type='all')
s1*s2

sage: # optional - gap3
sage: W = ReflectionGroup((1,1,4))
sage: W.from_reduced_word([1,2,3], word_type='all').reduced_word()
[1, 2, 3]
sage: W.from_reduced_word([1,2,3], word_type='all').reduced_word_in_reflections()
[1, 2, 3]
sage: W.from_reduced_word([1,2,3]).reduced_word_in_reflections()
[1, 2, 3]
>>> from sage.all import *
>>> # needs sage.combinat
>>> W = ColoredPermutations(Integer(1),Integer(4))
>>> W.from_reduced_word([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1),Integer(2)])
[[0, 0, 0, 0], [1, 2, 3, 4]]
>>> W.from_reduced_word([Integer(1), Integer(2), Integer(3)]).reduced_word()
[1, 2, 3]

>>> # needs sage.rings.number_field
>>> W = WeylGroup("A3", prefix='s')
>>> AS = W.domain()
>>> r1 = AS.roots()[Integer(4)]; r1
(0, 1, 0, -1)
>>> r2 = AS.roots()[Integer(5)]; r2
(0, 0, 1, -1)
>>> W.from_reduced_word([r1, r2], word_type='all')
s3*s2

>>> W = WeylGroup("G2", prefix='s')                                   # needs sage.rings.number_field
>>> W.from_reduced_word(W.domain().positive_roots(),                  # needs sage.rings.number_field
...                     word_type='all')
s1*s2

>>> # optional - gap3
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(4)))
>>> W.from_reduced_word([Integer(1),Integer(2),Integer(3)], word_type='all').reduced_word()
[1, 2, 3]
>>> W.from_reduced_word([Integer(1),Integer(2),Integer(3)], word_type='all').reduced_word_in_reflections()
[1, 2, 3]
>>> W.from_reduced_word([Integer(1),Integer(2),Integer(3)]).reduced_word_in_reflections()
[1, 2, 3]
group_generators()[source]#

Return the simple reflections of self, as distinguished group generators.

EXAMPLES:

sage: D10 = FiniteCoxeterGroups().example(10)
sage: D10.group_generators()
Finite family {1: (1,), 2: (2,)}
sage: SymmetricGroup(5).group_generators()
Finite family {1: (1,2), 2: (2,3), 3: (3,4), 4: (4,5)}

sage: W = ColoredPermutations(3,2)                                      # needs sage.combinat
sage: W.group_generators()                                              # needs sage.combinat
Finite family {1: [[0, 0],
                   [2, 1]],
               2: [[0, 1],
                   [1, 2]]}
>>> from sage.all import *
>>> D10 = FiniteCoxeterGroups().example(Integer(10))
>>> D10.group_generators()
Finite family {1: (1,), 2: (2,)}
>>> SymmetricGroup(Integer(5)).group_generators()
Finite family {1: (1,2), 2: (2,3), 3: (3,4), 4: (4,5)}

>>> W = ColoredPermutations(Integer(3),Integer(2))                                      # needs sage.combinat
>>> W.group_generators()                                              # needs sage.combinat
Finite family {1: [[0, 0],
                   [2, 1]],
               2: [[0, 1],
                   [1, 2]]}

The simple reflections are also semigroup generators, even for an infinite group:

sage: W = WeylGroup(["A",2,1])                                          # needs sage.rings.number_field
sage: W.semigroup_generators()                                          # needs sage.rings.number_field
Finite family {0: [-1  1  1]
                  [ 0  1  0]
                  [ 0  0  1],
               1: [ 1  0  0]
                  [ 1 -1  1]
                  [ 0  0  1],
               2: [ 1  0  0]
                  [ 0  1  0]
                  [ 1  1 -1]}
>>> from sage.all import *
>>> W = WeylGroup(["A",Integer(2),Integer(1)])                                          # needs sage.rings.number_field
>>> W.semigroup_generators()                                          # needs sage.rings.number_field
Finite family {0: [-1  1  1]
                  [ 0  1  0]
                  [ 0  0  1],
               1: [ 1  0  0]
                  [ 1 -1  1]
                  [ 0  0  1],
               2: [ 1  0  0]
                  [ 0  1  0]
                  [ 1  1 -1]}
hyperplane_index_set()[source]#

Return the index set of the distinguished reflections of self.

This is also the index set of the reflection hyperplanes of self, hence the name. This name is slightly abusive since the concept of reflection hyperplanes is not defined for all generalized Coxeter groups. However for all practical purposes this is only used for complex reflection groups, and there this is the desirable name.

EXAMPLES:

sage: # optional - gap3
sage: W = ReflectionGroup((1,1,4))
sage: W.hyperplane_index_set()
(1, 2, 3, 4, 5, 6)
sage: W = ReflectionGroup((1,1,4), hyperplane_index_set=[1,3,'asdf',7,9,11])
sage: W.hyperplane_index_set()
(1, 3, 'asdf', 7, 9, 11)
sage: W = ReflectionGroup((1,1,4),
....:                     hyperplane_index_set=('a','b','c','d','e','f'))
sage: W.hyperplane_index_set()
('a', 'b', 'c', 'd', 'e', 'f')
>>> from sage.all import *
>>> # optional - gap3
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(4)))
>>> W.hyperplane_index_set()
(1, 2, 3, 4, 5, 6)
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(4)), hyperplane_index_set=[Integer(1),Integer(3),'asdf',Integer(7),Integer(9),Integer(11)])
>>> W.hyperplane_index_set()
(1, 3, 'asdf', 7, 9, 11)
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(4)),
...                     hyperplane_index_set=('a','b','c','d','e','f'))
>>> W.hyperplane_index_set()
('a', 'b', 'c', 'd', 'e', 'f')
index_set()[source]#

Return the index set of (the simple reflections of) self, as a list (or iterable).

EXAMPLES:

sage: W = CoxeterGroups().Finite().example(); W
The 5-th dihedral group of order 10
sage: W.index_set()
(1, 2)

sage: W = ColoredPermutations(1, 4)                                     # needs sage.combinat
sage: W.index_set()                                                     # needs sage.combinat
(1, 2, 3)

sage: # optional - gap3
sage: W = ReflectionGroup((1,1,4), index_set=[1,3,'asdf'])
sage: W.index_set()
(1, 3, 'asdf')
sage: W = ReflectionGroup((1,1,4), index_set=('a','b','c'))
sage: W.index_set()
('a', 'b', 'c')
>>> from sage.all import *
>>> W = CoxeterGroups().Finite().example(); W
The 5-th dihedral group of order 10
>>> W.index_set()
(1, 2)

>>> W = ColoredPermutations(Integer(1), Integer(4))                                     # needs sage.combinat
>>> W.index_set()                                                     # needs sage.combinat
(1, 2, 3)

>>> # optional - gap3
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(4)), index_set=[Integer(1),Integer(3),'asdf'])
>>> W.index_set()
(1, 3, 'asdf')
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(4)), index_set=('a','b','c'))
>>> W.index_set()
('a', 'b', 'c')
irreducible_component_index_sets()[source]#

Return a list containing the index sets of the irreducible components of self as finite reflection groups.

EXAMPLES:

sage: # needs sage.graphs
sage: W = ReflectionGroup([1,1,3], [3,1,3], 4); W       # optional - gap3
Reducible complex reflection group of rank 7 and type A2 x G(3,1,3) x ST4
sage: sorted(W.irreducible_component_index_sets())      # optional - gap3
[[1, 2], [3, 4, 5], [6, 7]]
>>> from sage.all import *
>>> # needs sage.graphs
>>> W = ReflectionGroup([Integer(1),Integer(1),Integer(3)], [Integer(3),Integer(1),Integer(3)], Integer(4)); W       # optional - gap3
Reducible complex reflection group of rank 7 and type A2 x G(3,1,3) x ST4
>>> sorted(W.irreducible_component_index_sets())      # optional - gap3
[[1, 2], [3, 4, 5], [6, 7]]

ALGORITHM:

Take the connected components of the graph on the index set with edges (i,j), where s[i] and s[j] do not commute.

irreducible_components()[source]#

Return the irreducible components of self as finite reflection groups.

EXAMPLES:

sage: # needs sage.graphs
sage: W = ReflectionGroup([1,1,3], [3,1,3], 4)          # optional - gap3
sage: W.irreducible_components()                        # optional - gap3
[Irreducible real reflection group of rank 2 and type A2,
 Irreducible complex reflection group of rank 3 and type G(3,1,3),
 Irreducible complex reflection group of rank 2 and type ST4]
>>> from sage.all import *
>>> # needs sage.graphs
>>> W = ReflectionGroup([Integer(1),Integer(1),Integer(3)], [Integer(3),Integer(1),Integer(3)], Integer(4))          # optional - gap3
>>> W.irreducible_components()                        # optional - gap3
[Irreducible real reflection group of rank 2 and type A2,
 Irreducible complex reflection group of rank 3 and type G(3,1,3),
 Irreducible complex reflection group of rank 2 and type ST4]
is_irreducible()[source]#

Return True if self is irreducible.

EXAMPLES:

sage: # needs sage.graphs
sage: W = ColoredPermutations(1,3); W                                   # needs sage.combinat
1-colored permutations of size 3
sage: W.is_irreducible()                                                # needs sage.combinat
True
sage: W = ReflectionGroup((1,1,3),(2,1,3)); W           # optional - gap3
Reducible real reflection group of rank 5 and type A2 x B3
sage: W.is_irreducible()                                # optional - gap3
False
>>> from sage.all import *
>>> # needs sage.graphs
>>> W = ColoredPermutations(Integer(1),Integer(3)); W                                   # needs sage.combinat
1-colored permutations of size 3
>>> W.is_irreducible()                                                # needs sage.combinat
True
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(3)),(Integer(2),Integer(1),Integer(3))); W           # optional - gap3
Reducible real reflection group of rank 5 and type A2 x B3
>>> W.is_irreducible()                                # optional - gap3
False
is_reducible()[source]#

Return True if self is not irreducible.

EXAMPLES:

sage: # needs sage.graphs
sage: W = ColoredPermutations(1,3); W                                   # needs sage.combinat
1-colored permutations of size 3
sage: W.is_reducible()                                                  # needs sage.combinat
False
sage: W = ReflectionGroup((1,1,3), (2,1,3)); W          # optional - gap3
Reducible real reflection group of rank 5 and type A2 x B3
sage: W.is_reducible()                                  # optional - gap3
True
>>> from sage.all import *
>>> # needs sage.graphs
>>> W = ColoredPermutations(Integer(1),Integer(3)); W                                   # needs sage.combinat
1-colored permutations of size 3
>>> W.is_reducible()                                                  # needs sage.combinat
False
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(3)), (Integer(2),Integer(1),Integer(3))); W          # optional - gap3
Reducible real reflection group of rank 5 and type A2 x B3
>>> W.is_reducible()                                  # optional - gap3
True
number_of_irreducible_components()[source]#

Return the number of irreducible components of self.

EXAMPLES:

sage: # needs sage.graphs
sage: SymmetricGroup(3).number_of_irreducible_components()
1
sage: ColoredPermutations(1,3).number_of_irreducible_components()       # needs sage.combinat
1
sage: ReflectionGroup((1,1,3),(2,1,3)).number_of_irreducible_components()   # optional - gap3
2
>>> from sage.all import *
>>> # needs sage.graphs
>>> SymmetricGroup(Integer(3)).number_of_irreducible_components()
1
>>> ColoredPermutations(Integer(1),Integer(3)).number_of_irreducible_components()       # needs sage.combinat
1
>>> ReflectionGroup((Integer(1),Integer(1),Integer(3)),(Integer(2),Integer(1),Integer(3))).number_of_irreducible_components()   # optional - gap3
2
number_of_simple_reflections()[source]#

Return the number of simple reflections of self.

EXAMPLES:

sage: # needs sage.combinat
sage: W = ColoredPermutations(1,3)
sage: W.number_of_simple_reflections()
2
sage: W = ColoredPermutations(2,3)
sage: W.number_of_simple_reflections()
3
sage: W = ColoredPermutations(4,3)
sage: W.number_of_simple_reflections()
3

sage: W = ReflectionGroup((4,2,3))                              # optional - gap3
sage: W.number_of_simple_reflections()                          # optional - gap3
4
>>> from sage.all import *
>>> # needs sage.combinat
>>> W = ColoredPermutations(Integer(1),Integer(3))
>>> W.number_of_simple_reflections()
2
>>> W = ColoredPermutations(Integer(2),Integer(3))
>>> W.number_of_simple_reflections()
3
>>> W = ColoredPermutations(Integer(4),Integer(3))
>>> W.number_of_simple_reflections()
3

>>> W = ReflectionGroup((Integer(4),Integer(2),Integer(3)))                              # optional - gap3
>>> W.number_of_simple_reflections()                          # optional - gap3
4
reflection(i)[source]#

Return the \(i\)-th reflection of self.

For \(i\) in \(1,\dots,N\), this gives the \(i\)-th reflection of self.

See also

EXAMPLES:

sage: W = ReflectionGroup((1,1,4))                      # optional - gap3
sage: for i in W.reflection_index_set():                # optional - gap3
....:     print('%s %s'%(i, W.reflection(i)))
1 (1,7)(2,4)(5,6)(8,10)(11,12)
2 (1,4)(2,8)(3,5)(7,10)(9,11)
3 (2,5)(3,9)(4,6)(8,11)(10,12)
4 (1,8)(2,7)(3,6)(4,10)(9,12)
5 (1,6)(2,9)(3,8)(5,11)(7,12)
6 (1,11)(3,10)(4,9)(5,7)(6,12)
>>> from sage.all import *
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(4)))                      # optional - gap3
>>> for i in W.reflection_index_set():                # optional - gap3
...     print('%s %s'%(i, W.reflection(i)))
1 (1,7)(2,4)(5,6)(8,10)(11,12)
2 (1,4)(2,8)(3,5)(7,10)(9,11)
3 (2,5)(3,9)(4,6)(8,11)(10,12)
4 (1,8)(2,7)(3,6)(4,10)(9,12)
5 (1,6)(2,9)(3,8)(5,11)(7,12)
6 (1,11)(3,10)(4,9)(5,7)(6,12)
reflection_index_set()[source]#

Return the index set of the reflections of self.

EXAMPLES:

sage: # optional - gap3
sage: W = ReflectionGroup((1,1,4))
sage: W.reflection_index_set()
(1, 2, 3, 4, 5, 6)
sage: W = ReflectionGroup((1,1,4), reflection_index_set=[1,3,'asdf',7,9,11])
sage: W.reflection_index_set()
(1, 3, 'asdf', 7, 9, 11)
sage: W = ReflectionGroup((1,1,4), reflection_index_set=('a','b','c','d','e','f'))
sage: W.reflection_index_set()
('a', 'b', 'c', 'd', 'e', 'f')
>>> from sage.all import *
>>> # optional - gap3
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(4)))
>>> W.reflection_index_set()
(1, 2, 3, 4, 5, 6)
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(4)), reflection_index_set=[Integer(1),Integer(3),'asdf',Integer(7),Integer(9),Integer(11)])
>>> W.reflection_index_set()
(1, 3, 'asdf', 7, 9, 11)
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(4)), reflection_index_set=('a','b','c','d','e','f'))
>>> W.reflection_index_set()
('a', 'b', 'c', 'd', 'e', 'f')
reflections()[source]#

Return a finite family containing the reflections of self, indexed by reflection_index_set().

EXAMPLES:

sage: # optional - gap3
sage: W = ReflectionGroup((1,1,3))
sage: reflections = W.reflections()
sage: for index in sorted(reflections.keys()):
....:     print('%s %s'%(index, reflections[index]))
1 (1,4)(2,3)(5,6)
2 (1,3)(2,5)(4,6)
3 (1,5)(2,4)(3,6)
sage: W = ReflectionGroup((1,1,3),
....:                     reflection_index_set=['a','b','c'])
sage: reflections = W.reflections()
sage: for index in sorted(reflections.keys()):
....:     print('%s %s'%(index, reflections[index]))
a (1,4)(2,3)(5,6)
b (1,3)(2,5)(4,6)
c (1,5)(2,4)(3,6)
sage: W = ReflectionGroup((3,1,1))
sage: reflections = W.reflections()
sage: for index in sorted(reflections.keys()):
....:     print('%s %s'%(index, reflections[index]))
1 (1,2,3)
2 (1,3,2)
sage: W = ReflectionGroup((1,1,3), (3,1,2))
sage: reflections = W.reflections()
sage: for index in sorted(reflections.keys()):
....:     print('%s %s'%(index, reflections[index]))
1 (1,6)(2,5)(7,8)
2 (1,5)(2,7)(6,8)
3 (3,9,15)(4,10,16)(12,17,23)(14,18,24)(20,25,29)(21,22,26)(27,28,30)
4 (3,11)(4,12)(9,13)(10,14)(15,19)(16,20)(17,21)(18,22)(23,27)(24,28)(25,26)(29,30)
5 (1,7)(2,6)(5,8)
6 (3,19)(4,25)(9,11)(10,17)(12,28)(13,15)(14,30)(16,18)(20,27)(21,29)(22,23)(24,26)
7 (4,21,27)(10,22,28)(11,13,19)(12,14,20)(16,26,30)(17,18,25)(23,24,29)
8 (3,13)(4,24)(9,19)(10,29)(11,15)(12,26)(14,21)(16,23)(17,30)(18,27)(20,22)(25,28)
9 (3,15,9)(4,16,10)(12,23,17)(14,24,18)(20,29,25)(21,26,22)(27,30,28)
10 (4,27,21)(10,28,22)(11,19,13)(12,20,14)(16,30,26)(17,25,18)(23,29,24)
>>> from sage.all import *
>>> # optional - gap3
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(3)))
>>> reflections = W.reflections()
>>> for index in sorted(reflections.keys()):
...     print('%s %s'%(index, reflections[index]))
1 (1,4)(2,3)(5,6)
2 (1,3)(2,5)(4,6)
3 (1,5)(2,4)(3,6)
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(3)),
...                     reflection_index_set=['a','b','c'])
>>> reflections = W.reflections()
>>> for index in sorted(reflections.keys()):
...     print('%s %s'%(index, reflections[index]))
a (1,4)(2,3)(5,6)
b (1,3)(2,5)(4,6)
c (1,5)(2,4)(3,6)
>>> W = ReflectionGroup((Integer(3),Integer(1),Integer(1)))
>>> reflections = W.reflections()
>>> for index in sorted(reflections.keys()):
...     print('%s %s'%(index, reflections[index]))
1 (1,2,3)
2 (1,3,2)
>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(3)), (Integer(3),Integer(1),Integer(2)))
>>> reflections = W.reflections()
>>> for index in sorted(reflections.keys()):
...     print('%s %s'%(index, reflections[index]))
1 (1,6)(2,5)(7,8)
2 (1,5)(2,7)(6,8)
3 (3,9,15)(4,10,16)(12,17,23)(14,18,24)(20,25,29)(21,22,26)(27,28,30)
4 (3,11)(4,12)(9,13)(10,14)(15,19)(16,20)(17,21)(18,22)(23,27)(24,28)(25,26)(29,30)
5 (1,7)(2,6)(5,8)
6 (3,19)(4,25)(9,11)(10,17)(12,28)(13,15)(14,30)(16,18)(20,27)(21,29)(22,23)(24,26)
7 (4,21,27)(10,22,28)(11,13,19)(12,14,20)(16,26,30)(17,18,25)(23,24,29)
8 (3,13)(4,24)(9,19)(10,29)(11,15)(12,26)(14,21)(16,23)(17,30)(18,27)(20,22)(25,28)
9 (3,15,9)(4,16,10)(12,23,17)(14,24,18)(20,29,25)(21,26,22)(27,30,28)
10 (4,27,21)(10,28,22)(11,19,13)(12,20,14)(16,30,26)(17,25,18)(23,29,24)
semigroup_generators()[source]#

Return the simple reflections of self, as distinguished group generators.

EXAMPLES:

sage: D10 = FiniteCoxeterGroups().example(10)
sage: D10.group_generators()
Finite family {1: (1,), 2: (2,)}
sage: SymmetricGroup(5).group_generators()
Finite family {1: (1,2), 2: (2,3), 3: (3,4), 4: (4,5)}

sage: W = ColoredPermutations(3,2)                                      # needs sage.combinat
sage: W.group_generators()                                              # needs sage.combinat
Finite family {1: [[0, 0],
                   [2, 1]],
               2: [[0, 1],
                   [1, 2]]}
>>> from sage.all import *
>>> D10 = FiniteCoxeterGroups().example(Integer(10))
>>> D10.group_generators()
Finite family {1: (1,), 2: (2,)}
>>> SymmetricGroup(Integer(5)).group_generators()
Finite family {1: (1,2), 2: (2,3), 3: (3,4), 4: (4,5)}

>>> W = ColoredPermutations(Integer(3),Integer(2))                                      # needs sage.combinat
>>> W.group_generators()                                              # needs sage.combinat
Finite family {1: [[0, 0],
                   [2, 1]],
               2: [[0, 1],
                   [1, 2]]}

The simple reflections are also semigroup generators, even for an infinite group:

sage: W = WeylGroup(["A",2,1])                                          # needs sage.rings.number_field
sage: W.semigroup_generators()                                          # needs sage.rings.number_field
Finite family {0: [-1  1  1]
                  [ 0  1  0]
                  [ 0  0  1],
               1: [ 1  0  0]
                  [ 1 -1  1]
                  [ 0  0  1],
               2: [ 1  0  0]
                  [ 0  1  0]
                  [ 1  1 -1]}
>>> from sage.all import *
>>> W = WeylGroup(["A",Integer(2),Integer(1)])                                          # needs sage.rings.number_field
>>> W.semigroup_generators()                                          # needs sage.rings.number_field
Finite family {0: [-1  1  1]
                  [ 0  1  0]
                  [ 0  0  1],
               1: [ 1  0  0]
                  [ 1 -1  1]
                  [ 0  0  1],
               2: [ 1  0  0]
                  [ 0  1  0]
                  [ 1  1 -1]}
simple_reflection(i)[source]#

Return the \(i\)-th simple reflection \(s_i\) of self.

INPUT:

  • i – an element from the index set

EXAMPLES:

sage: W = CoxeterGroups().example(); W
The symmetric group on {0, ..., 3}
sage: W.simple_reflection(1)
(0, 2, 1, 3)
sage: s = W.simple_reflections()
sage: s[1]
(0, 2, 1, 3)

sage: W = ReflectionGroup((1,1,4), index_set=[1,3,'asdf'])      # optional - gap3
sage: for i in W.index_set():                                   # optional - gap3
....:     print('%s %s'%(i, W.simple_reflection(i)))
1 (1,7)(2,4)(5,6)(8,10)(11,12)
3 (1,4)(2,8)(3,5)(7,10)(9,11)
asdf (2,5)(3,9)(4,6)(8,11)(10,12)
>>> from sage.all import *
>>> W = CoxeterGroups().example(); W
The symmetric group on {0, ..., 3}
>>> W.simple_reflection(Integer(1))
(0, 2, 1, 3)
>>> s = W.simple_reflections()
>>> s[Integer(1)]
(0, 2, 1, 3)

>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(4)), index_set=[Integer(1),Integer(3),'asdf'])      # optional - gap3
>>> for i in W.index_set():                                   # optional - gap3
...     print('%s %s'%(i, W.simple_reflection(i)))
1 (1,7)(2,4)(5,6)(8,10)(11,12)
3 (1,4)(2,8)(3,5)(7,10)(9,11)
asdf (2,5)(3,9)(4,6)(8,11)(10,12)
simple_reflection_orders()[source]#

Return the orders of the simple reflections.

EXAMPLES:

sage: # needs sage.rings.number_field
sage: W = WeylGroup(['B',3])
sage: W.simple_reflection_orders()
[2, 2, 2]
sage: W = CoxeterGroup(['C',4])
sage: W.simple_reflection_orders()
[2, 2, 2, 2]

sage: SymmetricGroup(5).simple_reflection_orders()
[2, 2, 2, 2]

sage: C = ColoredPermutations(4, 3)                                     # needs sage.combinat
sage: C.simple_reflection_orders()                                      # needs sage.combinat
[2, 2, 4]
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> W = WeylGroup(['B',Integer(3)])
>>> W.simple_reflection_orders()
[2, 2, 2]
>>> W = CoxeterGroup(['C',Integer(4)])
>>> W.simple_reflection_orders()
[2, 2, 2, 2]

>>> SymmetricGroup(Integer(5)).simple_reflection_orders()
[2, 2, 2, 2]

>>> C = ColoredPermutations(Integer(4), Integer(3))                                     # needs sage.combinat
>>> C.simple_reflection_orders()                                      # needs sage.combinat
[2, 2, 4]
simple_reflections()[source]#

Return the simple reflections \((s_i)_{i\in I}\) of self as a family indexed by index_set().

EXAMPLES:

For the symmetric group, we recognize the simple transpositions:

sage: W = SymmetricGroup(4); W
Symmetric group of order 4! as a permutation group
sage: s = W.simple_reflections(); s
Finite family {1: (1,2), 2: (2,3), 3: (3,4)}
sage: s[1]
(1,2)
sage: s[2]
(2,3)
sage: s[3]
(3,4)
>>> from sage.all import *
>>> W = SymmetricGroup(Integer(4)); W
Symmetric group of order 4! as a permutation group
>>> s = W.simple_reflections(); s
Finite family {1: (1,2), 2: (2,3), 3: (3,4)}
>>> s[Integer(1)]
(1,2)
>>> s[Integer(2)]
(2,3)
>>> s[Integer(3)]
(3,4)

Here are the simple reflections for a colored symmetric group and a reflection group:

sage: W = ColoredPermutations(1,3)                                      # needs sage.combinat
sage: W.simple_reflections()                                            # needs sage.combinat
Finite family {1: [[0, 0, 0], [2, 1, 3]], 2: [[0, 0, 0], [1, 3, 2]]}

sage: W = ReflectionGroup((1,1,3), index_set=['a','b'])         # optional - gap3
sage: W.simple_reflections()                                    # optional - gap3
Finite family {'a': (1,4)(2,3)(5,6), 'b': (1,3)(2,5)(4,6)}
>>> from sage.all import *
>>> W = ColoredPermutations(Integer(1),Integer(3))                                      # needs sage.combinat
>>> W.simple_reflections()                                            # needs sage.combinat
Finite family {1: [[0, 0, 0], [2, 1, 3]], 2: [[0, 0, 0], [1, 3, 2]]}

>>> W = ReflectionGroup((Integer(1),Integer(1),Integer(3)), index_set=['a','b'])         # optional - gap3
>>> W.simple_reflections()                                    # optional - gap3
Finite family {'a': (1,4)(2,3)(5,6), 'b': (1,3)(2,5)(4,6)}

This default implementation uses index_set() and simple_reflection().

some_elements()[source]#

Implement Sets.ParentMethods.some_elements() by returning some typical elements of self.

The result is currently composed of the simple reflections together with the unit and the result of an_element().

EXAMPLES:

sage: W = WeylGroup(['A',3])                                            # needs sage.rings.number_field
sage: W.some_elements()                                                 # needs sage.rings.number_field
[
[0 1 0 0]  [1 0 0 0]  [1 0 0 0]  [1 0 0 0]  [0 0 0 1]
[1 0 0 0]  [0 0 1 0]  [0 1 0 0]  [0 1 0 0]  [1 0 0 0]
[0 0 1 0]  [0 1 0 0]  [0 0 0 1]  [0 0 1 0]  [0 1 0 0]
[0 0 0 1], [0 0 0 1], [0 0 1 0], [0 0 0 1], [0 0 1 0]
]

sage: W = ColoredPermutations(1,4)                                      # needs sage.combinat
sage: W.some_elements()                                                 # needs sage.combinat
[[[0, 0, 0, 0], [2, 1, 3, 4]],
 [[0, 0, 0, 0], [1, 3, 2, 4]],
 [[0, 0, 0, 0], [1, 2, 4, 3]],
 [[0, 0, 0, 0], [1, 2, 3, 4]],
 [[0, 0, 0, 0], [4, 1, 2, 3]]]
>>> from sage.all import *
>>> W = WeylGroup(['A',Integer(3)])                                            # needs sage.rings.number_field
>>> W.some_elements()                                                 # needs sage.rings.number_field
[
[0 1 0 0]  [1 0 0 0]  [1 0 0 0]  [1 0 0 0]  [0 0 0 1]
[1 0 0 0]  [0 0 1 0]  [0 1 0 0]  [0 1 0 0]  [1 0 0 0]
[0 0 1 0]  [0 1 0 0]  [0 0 0 1]  [0 0 1 0]  [0 1 0 0]
[0 0 0 1], [0 0 0 1], [0 0 1 0], [0 0 0 1], [0 0 1 0]
]

>>> W = ColoredPermutations(Integer(1),Integer(4))                                      # needs sage.combinat
>>> W.some_elements()                                                 # needs sage.combinat
[[[0, 0, 0, 0], [2, 1, 3, 4]],
 [[0, 0, 0, 0], [1, 3, 2, 4]],
 [[0, 0, 0, 0], [1, 2, 4, 3]],
 [[0, 0, 0, 0], [1, 2, 3, 4]],
 [[0, 0, 0, 0], [4, 1, 2, 3]]]
class SubcategoryMethods[source]#

Bases: object

Irreducible()[source]#

Return the full subcategory of irreducible objects of self.

A complex reflection group, or generalized Coxeter group is reducible if its simple reflections can be split in two sets \(X\) and \(Y\) such that the elements of \(X\) commute with that of \(Y\). In particular, the group is then direct product of \(\langle X \rangle\) and \(\langle Y \rangle\). It’s irreducible otherwise.

EXAMPLES:

sage: from sage.categories.complex_reflection_groups import ComplexReflectionGroups
sage: ComplexReflectionGroups().Irreducible()
Category of irreducible complex reflection groups
sage: CoxeterGroups().Irreducible()
Category of irreducible Coxeter groups
>>> from sage.all import *
>>> from sage.categories.complex_reflection_groups import ComplexReflectionGroups
>>> ComplexReflectionGroups().Irreducible()
Category of irreducible complex reflection groups
>>> CoxeterGroups().Irreducible()
Category of irreducible Coxeter groups
super_categories()[source]#

Return the super categories of self.

EXAMPLES:

sage: from sage.categories.complex_reflection_groups import ComplexReflectionGroups
sage: ComplexReflectionGroups().super_categories()
[Category of complex reflection or generalized Coxeter groups]
>>> from sage.all import *
>>> from sage.categories.complex_reflection_groups import ComplexReflectionGroups
>>> ComplexReflectionGroups().super_categories()
[Category of complex reflection or generalized Coxeter groups]