# Finite Complex Reflection Groups¶

class sage.categories.finite_complex_reflection_groups.FiniteComplexReflectionGroups(base_category)

The category of finite complex reflection groups.

See ComplexReflectionGroups for the definition of complex reflection group. In the finite case, most of the information about the group can be recovered from its degrees and codegrees, and to a lesser extent to the explicit realization as subgroup of $$GL(V)$$. Hence the most important optional methods to implement are:

• ComplexReflectionGroups.Finite.ParentMethods.degrees(),

• ComplexReflectionGroups.Finite.ParentMethods.codegrees(),

• ComplexReflectionGroups.Finite.ElementMethods.to_matrix().

Finite complex reflection groups are completely classified. In particular, if the group is irreducible, then it’s uniquely determined by its degrees and codegrees and whether it’s reflection representation is primitive or not (see [LT2009] Chapter 2.1 for the definition of primitive).

EXAMPLES:

sage: from sage.categories.complex_reflection_groups import ComplexReflectionGroups
sage: ComplexReflectionGroups().Finite()
Category of finite complex reflection groups
sage: ComplexReflectionGroups().Finite().super_categories()
[Category of complex reflection groups,
Category of finite groups,
Category of finite finitely generated semigroups]


An example of a finite reflection group:

sage: W = ComplexReflectionGroups().Finite().example(); W       # optional - gap3
Reducible real reflection group of rank 4 and type A2 x B2

sage: W.reflections()                              # optional - gap3
Finite family {1: (1,8)(2,5)(9,12), 2: (1,5)(2,9)(8,12),
3: (3,10)(4,7)(11,14), 4: (3,6)(4,11)(10,13),
5: (1,9)(2,8)(5,12), 6: (4,14)(6,13)(7,11),
7: (3,13)(6,10)(7,14)}


W is in the category of complex reflection groups:

sage: W in ComplexReflectionGroups().Finite()      # optional - gap3
True

class ElementMethods

Bases: object

character_value()

Return the value at self of the character of the reflection representation given by to_matrix().

EXAMPLES:

sage: W = ColoredPermutations(1,3); W
1-colored permutations of size 3
sage: [t.character_value() for t in W]
[3, 1, 1, 0, 0, 1]


Note that this could be a different (faithful) representation than that given by the corresponding root system:

sage: W = ReflectionGroup((1,1,3)); W      # optional - gap3
Irreducible real reflection group of rank 2 and type A2
sage: [t.character_value() for t in W]     # optional - gap3
[2, 0, 0, -1, -1, 0]

sage: W = ColoredPermutations(2,2); W
2-colored permutations of size 2
sage: [t.character_value() for t in W]
[2, 0, 0, -2, 0, 0, 0, 0]

sage: W = ColoredPermutations(3,1); W
3-colored permutations of size 1
sage: [t.character_value() for t in W]
[1, zeta3, -zeta3 - 1]

reflection_length(in_unitary_group=False)

Return the reflection length of self.

This is the minimal numbers of reflections needed to obtain self.

INPUT:

• in_unitary_group – (default: False) if True, the reflection length is computed in the unitary group which is the dimension of the move space of self

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                      # optional - gap3
sage: sorted([t.reflection_length() for t in W])        # optional - gap3
[0, 1, 1, 1, 2, 2]

sage: W = ReflectionGroup((2,1,2))                      # optional - gap3
sage: sorted([t.reflection_length() for t in W])        # optional - gap3
[0, 1, 1, 1, 1, 2, 2, 2]

sage: W = ReflectionGroup((2,2,2))                      # optional - gap3
sage: sorted([t.reflection_length() for t in W])        # optional - gap3
[0, 1, 1, 2]

sage: W = ReflectionGroup((3,1,2))                      # optional - gap3
sage: sorted([t.reflection_length() for t in W])        # optional - gap3
[0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]

to_matrix()

Return the matrix presentation of self acting on a vector space $$V$$.

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))         # optional - gap3
sage: [t.to_matrix() for t in W]           # optional - gap3
[
[1 0]  [ 1  1]  [-1  0]  [-1 -1]  [ 0  1]  [ 0 -1]
[0 1], [ 0 -1], [ 1  1], [ 1  0], [-1 -1], [-1  0]
]

sage: W = ColoredPermutations(1,3)
sage: [t.to_matrix() for t in W]
[
[1 0 0]  [1 0 0]  [0 1 0]  [0 0 1]  [0 1 0]  [0 0 1]
[0 1 0]  [0 0 1]  [1 0 0]  [1 0 0]  [0 0 1]  [0 1 0]
[0 0 1], [0 1 0], [0 0 1], [0 1 0], [1 0 0], [1 0 0]
]


A different representation is given by the colored permutations:

sage: W = ColoredPermutations(3, 1)
sage: [t.to_matrix() for t in W]
[[1], [zeta3], [-zeta3 - 1]]

class Irreducible(base_category)
class ParentMethods

Bases: object

absolute_order_ideal(gens=None, in_unitary_group=True, return_lengths=False)

Return all elements in self below given elements in the absolute order of self.

This order is defined by

$\omega \leq_R \tau \Leftrightarrow \ell_R(\omega) + \ell_R(\omega^{-1} \tau) = \ell_R(\tau),$

where $$\ell_R$$ denotes the reflection length.

This is, if in_unitary_group is False, then

$\ell_R(w) = \min\{ \ell: w = r_1\cdots r_\ell, r_i \in R \},$

and otherwise

$\ell_R(w) = \dim\operatorname{im}(w - 1).$

Note

If gens are not given, self is assumed to be well-generated.

INPUT:

• gens – (default: None) if one or more elements are given, the order ideal in the absolute order generated by gens is returned. Otherwise, the standard Coxeter element is used as unique maximal element.

• in_unitary_group (default:True) determines the length function used to compute the order. For real groups, both possible orders coincide, and for complex non-real groups, the order in the unitary group is much faster to compute.

• return_lengths (default:False) whether or not to also return the lengths of the elements.

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                          # optional - gap3

sage: sorted( w.reduced_word() for w in W.absolute_order_ideal() )    # optional - gap3
[[], [1], [1, 2], [1, 2, 1], [2]]

sage: sorted( w.reduced_word() for w in W.absolute_order_ideal(W.from_reduced_word([2,1])) )  # optional - gap3
[[], [1], [1, 2, 1], [2], [2, 1]]

sage: sorted( w.reduced_word() for w in W.absolute_order_ideal(W.from_reduced_word([2])) )    # optional - gap3
[[], [2]]

sage: W = CoxeterGroup(['A', 3])
sage: len(list(W.absolute_order_ideal()))
14

sage: W = CoxeterGroup(['A', 2])
sage: for (w, l) in W.absolute_order_ideal(return_lengths=True):
....:     print(w.reduced_word(), l)
[1, 2] 2
[1, 2, 1] 1
[2] 1
[1] 1
[] 0

absolute_poset(in_unitary_group=False)

Return the poset induced by the absolute order of self as a finite lattice.

INPUT:

• in_unitary_group – (default: False) if False, the relation is given by \sigma \leq \tau if $$l_R(\sigma) + l_R(\sigma^{-1}\tau) = l_R(\tau)$$ If True, the relation is given by $$\sigma \leq \tau$$ if $$\dim(\mathrm{Fix}(\sigma)) + \dim(\mathrm{Fix}(\sigma^{-1}\tau)) = \dim(\mathrm{Fix}(\tau))$$

EXAMPLES:

sage: P = ReflectionGroup((1,1,3)).absolute_poset(); P      # optional - gap3
Finite poset containing 6 elements

sage: sorted(w.reduced_word() for w in P)                   # optional - gap3
[[], [1], [1, 2], [1, 2, 1], [2], [2, 1]]

sage: W = ReflectionGroup(4); W                             # optional - gap3
Irreducible complex reflection group of rank 2 and type ST4
sage: W.absolute_poset()                                    # optional - gap3
Finite poset containing 24 elements

coxeter_number()

Return the Coxeter number of an irreducible reflection group.

This is defined as $$\frac{N + N^*}{n}$$ where $$N$$ is the number of reflections, $$N^*$$ is the number of reflection hyperplanes, and $$n$$ is the rank of self.

EXAMPLES:

sage: W = ReflectionGroup(31)          # optional - gap3
sage: W.coxeter_number()               # optional - gap3
30

elements_below_coxeter_element(c=None)

Deprecated method.

Superseded by absolute_order_ideal()

generalized_noncrossing_partitions(m, c=None, positive=False)

Return the set of all chains of length m in the noncrossing partition lattice of self, see noncrossing_partition_lattice().

Note

self is assumed to be well-generated.

INPUT:

• c – (default: None) if an element c in self is given, it is used as the maximal element in the interval

• positive – (default: False) if True, only those generalized noncrossing partitions of full support are returned

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                          # optional - gap3

sage: sorted([w.reduced_word() for w in chain]              # optional - gap3
....:        for chain in W.generalized_noncrossing_partitions(2))  # optional - gap3
[[[], [], [1, 2]],
[[], [1], [2]],
[[], [1, 2], []],
[[], [1, 2, 1], [1]],
[[], [2], [1, 2, 1]],
[[1], [], [2]],
[[1], [2], []],
[[1, 2], [], []],
[[1, 2, 1], [], [1]],
[[1, 2, 1], [1], []],
[[2], [], [1, 2, 1]],
[[2], [1, 2, 1], []]]

sage: sorted([w.reduced_word() for w in chain]              # optional - gap3
....:        for chain in W.generalized_noncrossing_partitions(2, positive=True))   # optional - gap3
[[[], [1, 2], []],
[[], [1, 2, 1], [1]],
[[1], [2], []],
[[1, 2], [], []],
[[1, 2, 1], [], [1]],
[[1, 2, 1], [1], []],
[[2], [1, 2, 1], []]]

noncrossing_partition_lattice(c=None, L=None, in_unitary_group=True)

Return the interval $$[1,c]$$ in the absolute order of self as a finite lattice.

INPUT:

• c – (default: None) if an element c in self is given, it is used as the maximal element in the interval

• L – (default: None) if a subset L (must be hashable!) of self is given, it is used as the underlying set (only cover relations are checked).

• in_unitary_group – (default: False) if False, the relation is given by $$\sigma \leq \tau$$ if $$l_R(\sigma) + l_R(\sigma^{-1}\tau) = l_R(\tau)$$; if True, the relation is given by $$\sigma \leq \tau$$ if $$\dim(\mathrm{Fix}(\sigma)) + \dim(\mathrm{Fix}(\sigma^{-1}\tau)) = \dim(\mathrm{Fix}(\tau))$$

Note

If L is given, the parameter c is ignored.

EXAMPLES:

sage: W = SymmetricGroup(4)
sage: W.noncrossing_partition_lattice()
Finite lattice containing 14 elements

sage: W = WeylGroup(['G', 2])
sage: W.noncrossing_partition_lattice()
Finite lattice containing 8 elements

sage: W = ReflectionGroup((1,1,3))                          # optional - gap3

sage: sorted( w.reduced_word() for w in W.noncrossing_partition_lattice() ) # optional - gap3
[[], [1], [1, 2], [1, 2, 1], [2]]

sage: sorted( w.reduced_word() for w in W.noncrossing_partition_lattice(W.from_reduced_word([2,1])) )   # optional - gap3
[[], [1], [1, 2, 1], [2], [2, 1]]

sage: sorted( w.reduced_word() for w in W.noncrossing_partition_lattice(W.from_reduced_word([2])) ) # optional - gap3
[[], [2]]

example()

Return an example of an irreducible complex reflection group.

EXAMPLES:

sage: from sage.categories.complex_reflection_groups import ComplexReflectionGroups
sage: ComplexReflectionGroups().Finite().Irreducible().example()    # optional - gap3
Irreducible complex reflection group of rank 3 and type G(4,2,3)

class ParentMethods

Bases: object

base_change_matrix()

Return the base change from the standard basis of the vector space of self to the basis given by the independent roots of self.

Todo

For non-well-generated groups there is a conflict with construction of the matrix for an element.

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                          # optional - gap3
sage: W.base_change_matrix()                                # optional - gap3
[1 0]
[0 1]

sage: W = ReflectionGroup(23)                               # optional - gap3
sage: W.base_change_matrix()                                # optional - gap3
[1 0 0]
[0 1 0]
[0 0 1]

sage: W = ReflectionGroup((3,1,2))                          # optional - gap3
sage: W.base_change_matrix()                                # optional - gap3
[1 0]
[1 1]

sage: W = ReflectionGroup((4,2,2))                          # optional - gap3
sage: W.base_change_matrix()                                # optional - gap3
[   1    0]
[E(4)    1]

cardinality()

Return the cardinality of self.

It is given by the product of the degrees of self.

EXAMPLES:

sage: W = ColoredPermutations(1,3)
sage: W.cardinality()
6
sage: W = ColoredPermutations(2,3)
sage: W.cardinality()
48
sage: W = ColoredPermutations(4,3)
sage: W.cardinality()
384
sage: W = ReflectionGroup((4,2,3))         # optional - gap3
sage: W.cardinality()                      # optional - gap3
192

codegrees()

Return the codegrees of self.

OUTPUT: a tuple of Sage integers

EXAMPLES:

sage: W = ColoredPermutations(1,4)
sage: W.codegrees()
(2, 1, 0)

sage: W = ColoredPermutations(3,3)
sage: W.codegrees()
(6, 3, 0)

sage: W = ReflectionGroup(31)              # optional - gap3
sage: W.codegrees()                        # optional - gap3
(28, 16, 12, 0)

degrees()

Return the degrees of self.

OUTPUT: a tuple of Sage integers

EXAMPLES:

sage: W = ColoredPermutations(1,4)
sage: W.degrees()
(2, 3, 4)

sage: W = ColoredPermutations(3,3)
sage: W.degrees()
(3, 6, 9)

sage: W = ReflectionGroup(31)              # optional - gap3
sage: W.degrees()                          # optional - gap3
(8, 12, 20, 24)

is_real()

Return whether self is real.

A complex reflection group is real if it is isomorphic to a reflection group in $$GL(V)$$ over a real vector space $$V$$. Equivalently its character table has real entries.

This implementation uses the following statement: an irreducible complex reflection group is real if and only if $$2$$ is a degree of self with multiplicity one. Hence, in general we just need to compare the number of occurrences of $$2$$ as degree of self and the number of irreducible components.

EXAMPLES:

sage: W = ColoredPermutations(1,3)
sage: W.is_real()
True

sage: W = ColoredPermutations(4,3)
sage: W.is_real()
False


Todo

Add an example of non real finite complex reflection group that is generated by order 2 reflections.

is_well_generated()

Return whether self is well-generated.

A finite complex reflection group is well generated if the number of its simple reflections coincides with its rank.

ComplexReflectionGroups.Finite.WellGenerated()

Note

• All finite real reflection groups are well generated.

• The complex reflection groups of type $$G(r,1,n)$$ and of type $$G(r,r,n)$$ are well generated.

• The complex reflection groups of type $$G(r,p,n)$$ with $$1 < p < r$$ are not well generated.

• The direct product of two well generated finite complex reflection group is still well generated.

EXAMPLES:

sage: W = ColoredPermutations(1,3)
sage: W.is_well_generated()
True

sage: W = ColoredPermutations(4,3)
sage: W.is_well_generated()
True

sage: W = ReflectionGroup((4,2,3))         # optional - gap3
sage: W.is_well_generated()                # optional - gap3
False

sage: W = ReflectionGroup((4,4,3))         # optional - gap3
sage: W.is_well_generated()                # optional - gap3
True

number_of_reflection_hyperplanes()

Return the number of reflection hyperplanes of self.

This is also the number of distinguished reflections. For real groups, this coincides with the number of reflections.

This implementation uses that it is given by the sum of the codegrees of self plus its rank.

EXAMPLES:

sage: W = ColoredPermutations(1,3)
sage: W.number_of_reflection_hyperplanes()
3
sage: W = ColoredPermutations(2,3)
sage: W.number_of_reflection_hyperplanes()
9
sage: W = ColoredPermutations(4,3)
sage: W.number_of_reflection_hyperplanes()
15
sage: W = ReflectionGroup((4,2,3))          # optional - gap3
sage: W.number_of_reflection_hyperplanes()  # optional - gap3
15

number_of_reflections()

Return the number of reflections of self.

For real groups, this coincides with the number of reflection hyperplanes.

This implementation uses that it is given by the sum of the degrees of self minus its rank.

EXAMPLES:

sage: [SymmetricGroup(i).number_of_reflections() for i in range(int(8))]
[0, 0, 1, 3, 6, 10, 15, 21]

sage: W = ColoredPermutations(1,3)
sage: W.number_of_reflections()
3
sage: W = ColoredPermutations(2,3)
sage: W.number_of_reflections()
9
sage: W = ColoredPermutations(4,3)
sage: W.number_of_reflections()
21
sage: W = ReflectionGroup((4,2,3))         # optional - gap3
sage: W.number_of_reflections()            # optional - gap3
15

rank()

Return the rank of self.

The rank of self is the dimension of the smallest faithfull reflection representation of self.

This default implementation uses that the rank is the number of degrees().

ComplexReflectionGroups.rank()

EXAMPLES:

sage: W = ColoredPermutations(1,3)
sage: W.rank()
2
sage: W = ColoredPermutations(2,3)
sage: W.rank()
3
sage: W = ColoredPermutations(4,3)
sage: W.rank()
3
sage: W = ReflectionGroup((4,2,3))         # optional - gap3
sage: W.rank()                             # optional - gap3
3

class SubcategoryMethods

Bases: object

WellGenerated()

Return the full subcategory of well-generated objects of self.

A finite complex generated group is well generated if it is isomorphic to a subgroup of the general linear group $$GL_n$$ generated by $$n$$ reflections.

ComplexReflectionGroups.Finite.ParentMethods.is_well_generated()

EXAMPLES:

sage: from sage.categories.complex_reflection_groups import ComplexReflectionGroups
sage: C = ComplexReflectionGroups().Finite().WellGenerated(); C
Category of well generated finite complex reflection groups


Here is an example of a finite well-generated complex reflection group:

sage: W = C.example(); W                # optional - gap3
Reducible complex reflection group of rank 4 and type A2 x G(3,1,2)


All finite Coxeter groups are well generated:

sage: CoxeterGroups().Finite().is_subcategory(C)
True
sage: SymmetricGroup(3) in C
True


Note

The category of well generated finite complex reflection groups is currently implemented as an axiom. See discussion on trac ticket #11187. This may be a bit of overkill. Still it’s nice to have a full subcategory.

class WellGenerated(base_category)
class Irreducible(base_category)

The category of finite irreducible well-generated finite complex reflection groups.

class ParentMethods

Bases: object

catalan_number(positive=False, polynomial=False)

Return the Catalan number associated to self.

It is defined by

$\prod_{i = 1}^n \frac{d_i + h}{d_i},$

where $$d_1, \ldots, d_n$$ are the degrees and where $$h$$ is the Coxeter number. See [Ar2006] for further information.

INPUT:

• positive – optional boolean (default False) if True, return instead the positive Catalan number

• polynomial – optional boolean (default False) if True, return instead the $$q$$-analogue as a polynomial in $$q$$

Note

• For the symmetric group $$S_n$$, it reduces to the Catalan number $$\frac{1}{n+1} \binom{2n}{n}$$.

• The Catalan numbers for $$G(r,1,n)$$ all coincide for $$r > 1$$.

EXAMPLES:

sage: [ColoredPermutations(1,n).catalan_number() for n in [3,4,5]]
[5, 14, 42]

sage: [ColoredPermutations(2,n).catalan_number() for n in [3,4,5]]
[20, 70, 252]

sage: [ReflectionGroup((2,2,n)).catalan_number() for n in [3,4,5]]  # optional - gap3
[14, 50, 182]

coxeter_number()

Return the Coxeter number of a well-generated, irreducible reflection group. This is defined to be the order of a regular element in self, and is equal to the highest degree of self.

ComplexReflectionGroups.Finite.Irreducible()

Note

This method overwrites the more general method for complex reflection groups since the expression given here is quicker to compute.

EXAMPLES:

sage: W = ColoredPermutations(1,3)
sage: W.coxeter_number()
3

sage: W = ColoredPermutations(4,3)
sage: W.coxeter_number()
12

sage: W = ReflectionGroup((4,4,3))  # optional - gap3
sage: W.coxeter_number()            # optional - gap3
8

fuss_catalan_number(m, positive=False, polynomial=False)

Return the m-th Fuss-Catalan number associated to self.

This is defined by

$\prod_{i = 1}^n \frac{d_i + mh}{d_i},$

where $$d_1, \ldots, d_n$$ are the degrees and $$h$$ is the Coxeter number.

INPUT:

• positive – optional boolean (default False) if True, return instead the positive Fuss-Catalan number

• polynomial – optional boolean (default False) if True, return instead the $$q$$-analogue as a polynomial in $$q$$

See [Ar2006] for further information.

Note

• For the symmetric group $$S_n$$, it reduces to the Fuss-Catalan number $$\frac{1}{mn+1}\binom{(m+1)n}{n}$$.

• The Fuss-Catalan numbers for $$G(r, 1, n)$$ all coincide for $$r > 1$$.

EXAMPLES:

sage: W = ColoredPermutations(1,3)
sage: [W.fuss_catalan_number(i) for i in [1,2,3]]
[5, 12, 22]

sage: W = ColoredPermutations(1,4)
sage: [W.fuss_catalan_number(i) for i in [1,2,3]]
[14, 55, 140]

sage: W = ColoredPermutations(1,5)
sage: [W.fuss_catalan_number(i) for i in [1,2,3]]
[42, 273, 969]

sage: W = ColoredPermutations(2,2)
sage: [W.fuss_catalan_number(i) for i in [1,2,3]]
[6, 15, 28]

sage: W = ColoredPermutations(2,3)
sage: [W.fuss_catalan_number(i) for i in [1,2,3]]
[20, 84, 220]

sage: W = ColoredPermutations(2,4)
sage: [W.fuss_catalan_number(i) for i in [1,2,3]]
[70, 495, 1820]

number_of_reflections_of_full_support()

Return the number of reflections with full support.

EXAMPLES:

sage: W = Permutations(4)
sage: W.number_of_reflections_of_full_support()
1

sage: W = ColoredPermutations(1,4)
sage: W.number_of_reflections_of_full_support()
1

sage: W = CoxeterGroup("B3")
sage: W.number_of_reflections_of_full_support()
3

sage: W = ColoredPermutations(3,3)
sage: W.number_of_reflections_of_full_support()
3

rational_catalan_number(p, polynomial=False)

Return the p-th rational Catalan number associated to self.

It is defined by

$\prod_{i = 1}^n \frac{p + (p(d_i-1)) \mod h)}{d_i},$

where $$d_1, \ldots, d_n$$ are the degrees and $$h$$ is the Coxeter number. See [STW2016] for this formula.

INPUT:

• polynomial – optional boolean (default False) if True, return instead the $$q$$-analogue as a polynomial in $$q$$

EXAMPLES:

sage: W = ColoredPermutations(1,3)
sage: [W.rational_catalan_number(p) for p in [5,7,8]]
[7, 12, 15]

sage: W = ColoredPermutations(2,2)
sage: [W.rational_catalan_number(p) for p in [7,9,11]]
[10, 15, 21]

example()

Return an example of an irreducible well-generated complex reflection group.

EXAMPLES:

sage: from sage.categories.complex_reflection_groups import ComplexReflectionGroups
sage: ComplexReflectionGroups().Finite().WellGenerated().Irreducible().example()
4-colored permutations of size 3

class ParentMethods

Bases: object

coxeter_element()

Return a Coxeter element.

The result is the product of the simple reflections, in some order.

Note

This implementation is shared with well generated complex reflection groups. It would be nicer to put it in some joint super category; however, in the current state of the art, there is none where it is clear that this is the right construction for obtaining a Coxeter element.

In this context, this is an element having a regular eigenvector (a vector not contained in any reflection hyperplane of self).

EXAMPLES:

sage: CoxeterGroup(['A', 4]).coxeter_element().reduced_word()
[1, 2, 3, 4]
sage: CoxeterGroup(['B', 4]).coxeter_element().reduced_word()
[1, 2, 3, 4]
sage: CoxeterGroup(['D', 4]).coxeter_element().reduced_word()
[1, 2, 4, 3]
sage: CoxeterGroup(['F', 4]).coxeter_element().reduced_word()
[1, 2, 3, 4]
sage: CoxeterGroup(['E', 8]).coxeter_element().reduced_word()
[1, 3, 2, 4, 5, 6, 7, 8]
sage: CoxeterGroup(['H', 3]).coxeter_element().reduced_word()
[1, 2, 3]


This method is also used for well generated finite complex reflection groups:

sage: W = ReflectionGroup((1,1,4))          # optional - gap3
sage: W.coxeter_element().reduced_word()    # optional - gap3
[1, 2, 3]

sage: W = ReflectionGroup((2,1,4))          # optional - gap3
sage: W.coxeter_element().reduced_word()    # optional - gap3
[1, 2, 3, 4]

sage: W = ReflectionGroup((4,1,4))          # optional - gap3
sage: W.coxeter_element().reduced_word()    # optional - gap3
[1, 2, 3, 4]

sage: W = ReflectionGroup((4,4,4))          # optional - gap3
sage: W.coxeter_element().reduced_word()    # optional - gap3
[1, 2, 3, 4]

coxeter_elements()

Return the (unique) conjugacy class in self containing all Coxeter elements.

A Coxeter element is an element that has an eigenvalue $$e^{2\pi i/h}$$ where $$h$$ is the Coxeter number.

In case of finite Coxeter groups, these are exactly the elements that are conjugate to one (or, equivalently, all) standard Coxeter element, this is, to an element that is the product of the simple generators in some order.

standard_coxeter_elements()

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))     # optional - gap3
sage: sorted(c.reduced_word() for c in W.coxeter_elements())    # optional - gap3
[[1, 2], [2, 1]]

sage: W = ReflectionGroup((1,1,4))     # optional - gap3
sage: sorted(c.reduced_word() for c in W.coxeter_elements())    # optional - gap3
[[1, 2, 1, 3, 2], [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 1, 3, 2, 1], [3, 2, 1]]

is_well_generated()

Return True as self is well-generated.

EXAMPLES:

sage: W = ReflectionGroup((3,1,2))     # optional - gap3
sage: W.is_well_generated()            # optional - gap3
True

standard_coxeter_elements()

Return all standard Coxeter elements in self.

This is the set of all elements in self obtained from any product of the simple reflections in self.

Note

• self is assumed to be well-generated.

• This works even beyond real reflection groups, but the conjugacy class is not unique and we only obtain one such class.

EXAMPLES:

sage: W = ReflectionGroup(4)                 # optional - gap3
sage: sorted(W.standard_coxeter_elements())  # optional - gap3
[(1,7,6,12,23,20)(2,8,17,24,9,5)(3,16,10,19,15,21)(4,14,11,22,18,13),
(1,10,4,12,21,22)(2,11,19,24,13,3)(5,15,7,17,16,23)(6,18,8,20,14,9)]

example()

Return an example of a well-generated complex reflection group.

EXAMPLES:

sage: from sage.categories.complex_reflection_groups import ComplexReflectionGroups
sage: ComplexReflectionGroups().Finite().WellGenerated().example()  # optional - gap3
Reducible complex reflection group of rank 4 and type A2 x G(3,1,2)

example()

Return an example of a complex reflection group.

EXAMPLES:

sage: from sage.categories.complex_reflection_groups import ComplexReflectionGroups
sage: ComplexReflectionGroups().Finite().example()          # optional - gap3
Reducible real reflection group of rank 4 and type A2 x B2