Finite complex reflection groups

Let \(V\) be a finite-dimensional complex vector space. A reflection of \(V\) is an operator \(r \in \operatorname{GL}(V)\) that has finite order and fixes pointwise a hyperplane in \(V\).

For more definitions and classification types of finite complex reflection groups, see Wikipedia article Complex_reflection_group.

The point of entry to work with reflection groups is ReflectionGroup() which can be used with finite Cartan-Killing types:

sage: ReflectionGroup(['A',2])                                      # optional - gap3
Irreducible real reflection group of rank 2 and type A2
sage: ReflectionGroup(['F',4])                                      # optional - gap3
Irreducible real reflection group of rank 4 and type F4
sage: ReflectionGroup(['H',3])                                      # optional - gap3
Irreducible real reflection group of rank 3 and type H3

or with Shephard-Todd types:

sage: ReflectionGroup((1,1,3))                                      # optional - gap3
Irreducible real reflection group of rank 2 and type A2
sage: ReflectionGroup((2,1,3))                                      # optional - gap3
Irreducible real reflection group of rank 3 and type B3
sage: ReflectionGroup((3,1,3))                                      # optional - gap3
Irreducible complex reflection group of rank 3 and type G(3,1,3)
sage: ReflectionGroup((4,2,3))                                      # optional - gap3
Irreducible complex reflection group of rank 3 and type G(4,2,3)
sage: ReflectionGroup(4)                                            # optional - gap3
Irreducible complex reflection group of rank 2 and type ST4
sage: ReflectionGroup(31)                                           # optional - gap3
Irreducible complex reflection group of rank 4 and type ST31

Also reducible types are allowed using concatenation:

sage: ReflectionGroup(['A',3],(4,2,3))                              # optional - gap3
Reducible complex reflection group of rank 6 and type A3 x G(4,2,3)

Some special cases also occur, among them are:

sage: W = ReflectionGroup((2,2,2)); W                               # optional - gap3
Reducible real reflection group of rank 2 and type A1 x A1
sage: W = ReflectionGroup((2,2,3)); W                               # optional - gap3
Irreducible real reflection group of rank 3 and type A3

Warning

Uses the GAP3 package Chevie which is available as an experimental package (installed by sage -i gap3) or to download by hand from Jean Michel’s website.

A guided tour

We start with the example type \(B_2\):

sage: W = ReflectionGroup(['B',2]); W                               # optional - gap3
Irreducible real reflection group of rank 2 and type B2

Most importantly, observe that the group elements are usually represented by permutations of the roots:

sage: for w in W: print(w)                                          # optional - gap3
()
(1,3)(2,6)(5,7)
(1,5)(2,4)(6,8)
(1,7,5,3)(2,4,6,8)
(1,3,5,7)(2,8,6,4)
(2,8)(3,7)(4,6)
(1,7)(3,5)(4,8)
(1,5)(2,6)(3,7)(4,8)

This has the drawback that one can hardly see anything. Usually, one would look at elements with either of the following methods:

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

sage: for w in W: w.reduced_word_in_reflections()                   # optional - gap3
[]
[2]
[1]
[1, 2]
[1, 4]
[3]
[4]
[1, 3]

sage: for w in W: w.reduced_word(); w.to_matrix(); print("")        # optional - gap3
[]
[1 0]
[0 1]
<BLANKLINE>
[2]
[ 1  1]
[ 0 -1]
<BLANKLINE>
[1]
[-1  0]
[ 2  1]
<BLANKLINE>
[1, 2]
[-1 -1]
[ 2  1]
<BLANKLINE>
[2, 1]
[ 1  1]
[-2 -1]
<BLANKLINE>
[2, 1, 2]
[ 1  0]
[-2 -1]
<BLANKLINE>
[1, 2, 1]
[-1 -1]
[ 0  1]
<BLANKLINE>
[1, 2, 1, 2]
[-1  0]
[ 0 -1]
<BLANKLINE>

The standard references for actions of complex reflection groups have the matrices acting on the right, so:

sage: W.simple_reflection(1).to_matrix()                            # optional - gap3
[-1  0]
[ 2  1]

sends the simple root \(\alpha_0\), or (1,0) in vector notation, to its negative, while sending \(\alpha_1\) to \(2\alpha_0+\alpha_1\).

Todo

  • properly provide root systems for real reflection groups

  • element class should be unique to be able to work with large groups without creating elements multiple times

  • is_shephard_group, is_generalized_coxeter_group

  • exponents and coexponents

  • coinvariant ring:

    • fake degrees from Torsten Hoge
    • operation of linear characters on all characters
    • harmonic polynomials

  • linear forms for hyperplanes

  • field of definition

  • intersection lattice and characteristic polynomial:

    X = [ alpha(t) for t in W.distinguished_reflections() ]
X = Matrix(CF,X).transpose()
Y = Matroid(X)

  • linear characters

  • permutation pi on irreducibles

  • hyperplane orbits (76.13 in Gap Manual)

  • improve invariant_form with a code similar to the one in reflection_group_real.py

  • add a method reflection_to_root or distinguished_reflection_to_positive_root

  • diagrams in ASCII-art (76.15)

  • standard (BMR) presentations

  • character table directly from Chevie

  • GenericOrder (76.20), TorusOrder (76.21)

  • correct fundamental invariants for \(G_34\), check the others

  • copy hardcoded data (degrees, invariants, braid relations...) into sage

  • add other hardcoded data from the tables in chevie (location is SAGEDIR/local/gap3/gap-jm5-2015-02-01/gap3/pkg/chevie/tbl): basic derivations, discriminant, ...

  • transfer code for reduced_word_in_reflections into Gap4 or Sage

  • list of reduced words for an element

  • list of reduced words in reflections for an element

  • Hurwitz action?

  • is_crystallographic() should be hardcoded

AUTHORS:

  • Christian Stump (2015): initial version
class sage.combinat.root_system.reflection_group_complex.ComplexReflectionGroup(W_types, index_set=None, hyperplane_index_set=None, reflection_index_set=None)

Bases: sage.structure.unique_representation.UniqueRepresentation, sage.groups.perm_gps.permgroup.PermutationGroup_generic

A complex reflection group given as a permutation group.

See also

ReflectionGroup()

class Element

Bases: sage.groups.perm_gps.permgroup_element.PermutationGroupElement

action(vec, on_space='primal')

Return the image of vec under the action of self.

INPUT:

  • vec – vector in the basis given by the simple root
  • on_space – optional (default: "primal") whether to act as the reflection representation on the given basis, or to act on the dual reflection representation on the dual basis

EXAMPLES:

sage: W = ReflectionGroup((3,1,2))                      # optional - gap3
sage: w = W.from_reduced_word([1, 2, 1, 1, 2])          # optional - gap3
sage: for alpha in W.independent_roots():               # optional - gap3
....:     print("%s -> %s"%(alpha,w.action(alpha)))     # optional - gap3
(1, 0) -> (E(3), 0)
(-1, 1) -> (-E(3), E(3)^2)
action_on_root(root)

Return the root obtained by applying self to root on the right.

INPUT:

  • root – the root to act on

EXAMPLES:

sage: W = ReflectionGroup(['A',2])                      # optional - gap3
sage: for w in W:                                       # optional - gap3
....:     print("%s %s"%(w.reduced_word(),              # optional - gap3
....:           [w.action_on_root(beta,side="left") for beta in W.positive_roots()]))  # optional - gap3
[] [(1, 0), (0, 1), (1, 1)]
[2] [(1, 1), (0, -1), (1, 0)]
[1] [(-1, 0), (1, 1), (0, 1)]
[1, 2] [(0, 1), (-1, -1), (-1, 0)]
[2, 1] [(-1, -1), (1, 0), (0, -1)]
[1, 2, 1] [(0, -1), (-1, 0), (-1, -1)]

TESTS:

sage: W = ReflectionGroup(4); Phi = sorted(W.roots())   # optional - gap3
sage: all(sorted([w.action_on_root(beta) for beta in Phi]) == Phi for w in W)   # optional - gap3
True
action_on_root_indices(i)

Return the right action on the set of roots.

INPUT:

  • i – index of the root to act on

EXAMPLES:

sage: W = ReflectionGroup(['A',3])           # optional - gap3
sage: w = W.w0                               # optional - gap3
sage: N = len(W.roots())                     # optional - gap3
sage: [w.action_on_root_indices(i) for i in range(N)]    # optional - gap3
[8, 7, 6, 10, 9, 11, 2, 1, 0, 4, 3, 5]

sage: W = ReflectionGroup(['A',2], reflection_index_set=['A','B','C'])   # optional - gap3
sage: w = W.w0                               # optional - gap3
sage: N = len(W.roots())                     # optional - gap3
sage: [w.action_on_root_indices(i) for i in range(N)]    # optional - gap3
[4, 3, 5, 1, 0, 2]

TESTS:

sage: W = ReflectionGroup(4)                 # optional - gap3
sage: N = len(W.roots())                     # optional - gap3
sage: all(sorted([w.action_on_root_indices(i) for i in range(N)]) == list(range(N)) for w in W)   # optional - gap3
True
conjugacy_class()

Return the conjugacy class of self.

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                      # optional - gap3
sage: for w in W: sorted(w.conjugacy_class())           # optional - gap3
[()]
[(1,3)(2,5)(4,6), (1,4)(2,3)(5,6), (1,5)(2,4)(3,6)]
[(1,3)(2,5)(4,6), (1,4)(2,3)(5,6), (1,5)(2,4)(3,6)]
[(1,2,6)(3,4,5), (1,6,2)(3,5,4)]
[(1,2,6)(3,4,5), (1,6,2)(3,5,4)]
[(1,3)(2,5)(4,6), (1,4)(2,3)(5,6), (1,5)(2,4)(3,6)]
conjugacy_class_representative()

Return a representative of the conjugacy class of self.

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                      # optional - gap3
sage: for w in W:                                       # optional - gap3
....:     print('%s %s'%(w.reduced_word(), w.conjugacy_class_representative().reduced_word()))  # optional - gap3
[] []
[2] [1]
[1] [1]
[1, 2] [1, 2]
[2, 1] [1, 2]
[1, 2, 1] [1]
fix_space()

Return the fix space of self.

This is the sub vector space of the underlying vector space on which self acts trivially.

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                      # optional - gap3
sage: for w in W:                                       # optional - gap3
....:     w.reduced_word()                              # optional - gap3
....:     w.fix_space()                                 # optional - gap3
[]
Vector space of degree 2 and dimension 2 over Rational Field
Basis matrix:
[1 0]
[0 1]
[2]
Vector space of degree 2 and dimension 1 over Rational Field
Basis matrix:
[1 0]
[1]
Vector space of degree 2 and dimension 1 over Rational Field
Basis matrix:
[0 1]
[1, 2]
Vector space of degree 2 and dimension 0 over Rational Field
Basis matrix:
[]
[2, 1]
Vector space of degree 2 and dimension 0 over Rational Field
Basis matrix:
[]
[1, 2, 1]
Vector space of degree 2 and dimension 1 over Rational Field
Basis matrix:
[ 1 -1]

sage: W = ReflectionGroup(23)                           # optional - gap3
sage: W.an_element().fix_space()                        # optional - gap3
Vector space of degree 3 and dimension 2 over Universal Cyclotomic Field
Basis matrix:
[0 1 0]
[0 0 1]
galois_conjugates()

Return all Galois conjugates of self.

EXAMPLES:

sage: W = ReflectionGroup(4)                            # optional - gap3
sage: for w in W: print(w.galois_conjugates())          # optional - gap3
[[1 0]
 [0 1]]
[[   1    0]
 [   0 E(3)], [     1      0]
 [     0 E(3)^2]]
[[ 1/3*E(3) - 1/3*E(3)^2  2/3*E(3) + 1/3*E(3)^2]
 [ 4/3*E(3) + 2/3*E(3)^2 -1/3*E(3) - 2/3*E(3)^2],
 [-1/3*E(3) + 1/3*E(3)^2  1/3*E(3) + 2/3*E(3)^2]
 [ 2/3*E(3) + 4/3*E(3)^2 -2/3*E(3) - 1/3*E(3)^2]]
[[     1      0]
 [     0 E(3)^2], [   1    0]
 [   0 E(3)]]
[[ 1/3*E(3) - 1/3*E(3)^2  2/3*E(3) + 1/3*E(3)^2]
 [-2/3*E(3) + 2/3*E(3)^2  2/3*E(3) + 1/3*E(3)^2],
 [-1/3*E(3) + 1/3*E(3)^2  1/3*E(3) + 2/3*E(3)^2]
 [ 2/3*E(3) - 2/3*E(3)^2  1/3*E(3) + 2/3*E(3)^2]]
[[ 1/3*E(3) - 1/3*E(3)^2 -1/3*E(3) + 1/3*E(3)^2]
 [ 4/3*E(3) + 2/3*E(3)^2  2/3*E(3) + 1/3*E(3)^2],
 [-1/3*E(3) + 1/3*E(3)^2  1/3*E(3) - 1/3*E(3)^2]
 [ 2/3*E(3) + 4/3*E(3)^2  1/3*E(3) + 2/3*E(3)^2]]
[[-1/3*E(3) + 1/3*E(3)^2  1/3*E(3) + 2/3*E(3)^2]
 [ 2/3*E(3) + 4/3*E(3)^2 -2/3*E(3) - 1/3*E(3)^2],
 [ 1/3*E(3) - 1/3*E(3)^2  2/3*E(3) + 1/3*E(3)^2]
 [ 4/3*E(3) + 2/3*E(3)^2 -1/3*E(3) - 2/3*E(3)^2]]
[[ 1/3*E(3) - 1/3*E(3)^2  2/3*E(3) + 1/3*E(3)^2]
 [-2/3*E(3) - 4/3*E(3)^2 -1/3*E(3) + 1/3*E(3)^2],
 [-1/3*E(3) + 1/3*E(3)^2  1/3*E(3) + 2/3*E(3)^2]
 [-4/3*E(3) - 2/3*E(3)^2  1/3*E(3) - 1/3*E(3)^2]]
[[ 1/3*E(3) - 1/3*E(3)^2 -1/3*E(3) + 1/3*E(3)^2]
 [-2/3*E(3) + 2/3*E(3)^2 -1/3*E(3) + 1/3*E(3)^2],
 [-1/3*E(3) + 1/3*E(3)^2  1/3*E(3) - 1/3*E(3)^2]
 [ 2/3*E(3) - 2/3*E(3)^2  1/3*E(3) - 1/3*E(3)^2]]
[[-1/3*E(3) + 1/3*E(3)^2  1/3*E(3) + 2/3*E(3)^2]
 [-4/3*E(3) - 2/3*E(3)^2  1/3*E(3) - 1/3*E(3)^2],
 [ 1/3*E(3) - 1/3*E(3)^2  2/3*E(3) + 1/3*E(3)^2]
 [-2/3*E(3) - 4/3*E(3)^2 -1/3*E(3) + 1/3*E(3)^2]]
[[ 1/3*E(3) - 1/3*E(3)^2 -1/3*E(3) - 2/3*E(3)^2]
 [ 4/3*E(3) + 2/3*E(3)^2 -1/3*E(3) + 1/3*E(3)^2],
 [-1/3*E(3) + 1/3*E(3)^2 -2/3*E(3) - 1/3*E(3)^2]
 [ 2/3*E(3) + 4/3*E(3)^2  1/3*E(3) - 1/3*E(3)^2]]
[[-1/3*E(3) + 1/3*E(3)^2 -2/3*E(3) - 1/3*E(3)^2]
 [ 2/3*E(3) + 4/3*E(3)^2  1/3*E(3) - 1/3*E(3)^2],
 [ 1/3*E(3) - 1/3*E(3)^2 -1/3*E(3) - 2/3*E(3)^2]
 [ 4/3*E(3) + 2/3*E(3)^2 -1/3*E(3) + 1/3*E(3)^2]]
[[ 1/3*E(3) - 1/3*E(3)^2 -1/3*E(3) + 1/3*E(3)^2]
 [-2/3*E(3) - 4/3*E(3)^2 -1/3*E(3) - 2/3*E(3)^2],
 [-1/3*E(3) + 1/3*E(3)^2  1/3*E(3) - 1/3*E(3)^2]
 [-4/3*E(3) - 2/3*E(3)^2 -2/3*E(3) - 1/3*E(3)^2]]
[[-1/3*E(3) + 1/3*E(3)^2  1/3*E(3) + 2/3*E(3)^2]
 [ 2/3*E(3) - 2/3*E(3)^2  1/3*E(3) + 2/3*E(3)^2],
 [ 1/3*E(3) - 1/3*E(3)^2  2/3*E(3) + 1/3*E(3)^2]
 [-2/3*E(3) + 2/3*E(3)^2  2/3*E(3) + 1/3*E(3)^2]]
[[ 1/3*E(3) - 1/3*E(3)^2 -1/3*E(3) - 2/3*E(3)^2]
 [-2/3*E(3) + 2/3*E(3)^2 -1/3*E(3) - 2/3*E(3)^2],
 [-1/3*E(3) + 1/3*E(3)^2 -2/3*E(3) - 1/3*E(3)^2]
 [ 2/3*E(3) - 2/3*E(3)^2 -2/3*E(3) - 1/3*E(3)^2]]
[[-1/3*E(3) + 1/3*E(3)^2 -2/3*E(3) - 1/3*E(3)^2]
 [-4/3*E(3) - 2/3*E(3)^2  1/3*E(3) + 2/3*E(3)^2],
 [ 1/3*E(3) - 1/3*E(3)^2 -1/3*E(3) - 2/3*E(3)^2]
 [-2/3*E(3) - 4/3*E(3)^2  2/3*E(3) + 1/3*E(3)^2]]
[[   -1     0]
 [    0 -E(3)], [     -1       0]
 [      0 -E(3)^2]]
[[-1/3*E(3) + 1/3*E(3)^2  1/3*E(3) - 1/3*E(3)^2]
 [ 2/3*E(3) + 4/3*E(3)^2  1/3*E(3) + 2/3*E(3)^2],
 [ 1/3*E(3) - 1/3*E(3)^2 -1/3*E(3) + 1/3*E(3)^2]
 [ 4/3*E(3) + 2/3*E(3)^2  2/3*E(3) + 1/3*E(3)^2]]
[[ 1/3*E(3) - 1/3*E(3)^2 -1/3*E(3) - 2/3*E(3)^2]
 [-2/3*E(3) - 4/3*E(3)^2  2/3*E(3) + 1/3*E(3)^2],
 [-1/3*E(3) + 1/3*E(3)^2 -2/3*E(3) - 1/3*E(3)^2]
 [-4/3*E(3) - 2/3*E(3)^2  1/3*E(3) + 2/3*E(3)^2]]
[[-1/3*E(3) + 1/3*E(3)^2 -2/3*E(3) - 1/3*E(3)^2]
 [ 2/3*E(3) - 2/3*E(3)^2 -2/3*E(3) - 1/3*E(3)^2],
 [ 1/3*E(3) - 1/3*E(3)^2 -1/3*E(3) - 2/3*E(3)^2]
 [-2/3*E(3) + 2/3*E(3)^2 -1/3*E(3) - 2/3*E(3)^2]]
[[     -1       0]
 [      0 -E(3)^2], [   -1     0]
 [    0 -E(3)]]
[[-1/3*E(3) + 1/3*E(3)^2  1/3*E(3) - 1/3*E(3)^2]
 [-4/3*E(3) - 2/3*E(3)^2 -2/3*E(3) - 1/3*E(3)^2],
 [ 1/3*E(3) - 1/3*E(3)^2 -1/3*E(3) + 1/3*E(3)^2]
 [-2/3*E(3) - 4/3*E(3)^2 -1/3*E(3) - 2/3*E(3)^2]]
[[-1  0]
 [ 0 -1]]
[[-1/3*E(3) + 1/3*E(3)^2  1/3*E(3) - 1/3*E(3)^2]
 [ 2/3*E(3) - 2/3*E(3)^2  1/3*E(3) - 1/3*E(3)^2],
 [ 1/3*E(3) - 1/3*E(3)^2 -1/3*E(3) + 1/3*E(3)^2]
 [-2/3*E(3) + 2/3*E(3)^2 -1/3*E(3) + 1/3*E(3)^2]]
length()

Return the length of self in generating reflections.

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

EXAMPLES:

sage: W = ReflectionGroup(4)                            # optional - gap3
sage: for w in W:         # optional - gap3
....:     print("{} {}".format(w.reduced_word(), w.length()))
[] 0
[1] 1
[2] 1
[1, 1] 2
[1, 2] 2
[2, 1] 2
[2, 2] 2
[1, 1, 2] 3
[1, 2, 1] 3
[1, 2, 2] 3
[2, 1, 1] 3
[2, 2, 1] 3
[1, 1, 2, 1] 4
[1, 1, 2, 2] 4
[1, 2, 1, 1] 4
[1, 2, 2, 1] 4
[2, 1, 1, 2] 4
[2, 2, 1, 1] 4
[1, 1, 2, 1, 1] 5
[1, 1, 2, 2, 1] 5
[1, 2, 1, 1, 2] 5
[1, 2, 2, 1, 1] 5
[1, 1, 2, 1, 1, 2] 6
[1, 1, 2, 2, 1, 1] 6
matrix(on_space='primal')

Return self as a matrix acting on the underlying vector space.

  • on_space – optional (default: "primal") whether to act as the reflection representation on the given basis, or to act on the dual reflection representation on the dual basis

EXAMPLES:

sage: W = ReflectionGroup((3,1,2))          # optional - gap3
sage: for w in W:                           # optional - gap3
....:     w.reduced_word()                  # optional - gap3
....:     [w.to_matrix(), w.to_matrix(on_space="dual")] # optional - gap3
[]
[
[1 0]  [1 0]
[0 1], [0 1]
]
[1]
[
[E(3)    0]  [E(3)^2      0]
[   0    1], [     0      1]
]
[2]
[
[0 1]  [0 1]
[1 0], [1 0]
]
[1, 1]
[
[E(3)^2      0]  [E(3)    0]
[     0      1], [   0    1]
]
[1, 2]
[
[   0 E(3)]  [     0 E(3)^2]
[   1    0], [     1      0]
]
[2, 1]
[
[   0    1]  [     0      1]
[E(3)    0], [E(3)^2      0]
]
[1, 1, 2]
[
[     0 E(3)^2]  [   0 E(3)]
[     1      0], [   1    0]
]
[1, 2, 1]
[
[   0 E(3)]  [     0 E(3)^2]
[E(3)    0], [E(3)^2      0]
]
[2, 1, 1]
[
[     0      1]  [   0    1]
[E(3)^2      0], [E(3)    0]
]
[2, 1, 2]
[
[   1    0]  [     1      0]
[   0 E(3)], [     0 E(3)^2]
]
[1, 1, 2, 1]
[
[     0 E(3)^2]  [     0   E(3)]
[  E(3)      0], [E(3)^2      0]
]
[1, 2, 1, 1]
[
[     0   E(3)]  [     0 E(3)^2]
[E(3)^2      0], [  E(3)      0]
]
[1, 2, 1, 2]
[
[E(3)    0]  [E(3)^2      0]
[   0 E(3)], [     0 E(3)^2]
]
[2, 1, 1, 2]
[
[     1      0]  [   1    0]
[     0 E(3)^2], [   0 E(3)]
]
[1, 1, 2, 1, 1]
[
[     0 E(3)^2]  [   0 E(3)]
[E(3)^2      0], [E(3)    0]
]
[1, 1, 2, 1, 2]
[
[E(3)^2      0]  [  E(3)      0]
[     0   E(3)], [     0 E(3)^2]
]
[1, 2, 1, 1, 2]
[
[  E(3)      0]  [E(3)^2      0]
[     0 E(3)^2], [     0   E(3)]
]
[1, 1, 2, 1, 1, 2]
[
[E(3)^2      0]  [E(3)    0]
[     0 E(3)^2], [   0 E(3)]
]
reduced_word()

Return a word in the simple reflections to obtain self.

EXAMPLES:

sage: W = ReflectionGroup((5,1,1), index_set=['a'], hyperplane_index_set=['x'], reflection_index_set=['A','B','C','D']) # optional - gap3
sage: [w.reduced_word() for w in W]                     # optional - gap3
[[], ['a'], ['a', 'a'], ['a', 'a', 'a'], ['a', 'a', 'a', 'a']]

See also

reduced_word_in_reflections()

reduced_word_in_reflections()

Return a word in the reflections to obtain self.

EXAMPLES:

sage: W = ReflectionGroup((5,1,1), index_set=['a'], reflection_index_set=['A','B','C','D']) # optional - gap3
sage: [w.reduced_word_in_reflections() for w in W]      # optional - gap3
[[], ['A'], ['B'], ['C'], ['D']]

See also

reduced_word()

reflection_eigenvalues(is_class_representative=False)

Return the reflection eigenvalues of self.

INPUT:

  • is_class_representative – (default: False) whether to first replace self by the representative of its conjugacy class

EXAMPLES:

sage: W = ReflectionGroup(4)                            # optional - gap3
sage: for w in W: w.reflection_eigenvalues()            # optional - gap3
[0, 0]
[1/3, 0]
[1/3, 0]
[2/3, 0]
[1/6, 1/2]
[1/6, 1/2]
[2/3, 0]
[1/4, 3/4]
[1/4, 3/4]
[1/4, 3/4]
[1/4, 3/4]
[1/4, 3/4]
[1/3, 0]
[1/2, 5/6]
[1/3, 0]
[1/2, 5/6]
[1/2, 5/6]
[1/2, 5/6]
[1/6, 1/2]
[2/3, 0]
[1/6, 1/2]
[2/3, 0]
[1/2, 1/2]
[1/4, 3/4]
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(on_space='primal')

Return self as a matrix acting on the underlying vector space.

  • on_space – optional (default: "primal") whether to act as the reflection representation on the given basis, or to act on the dual reflection representation on the dual basis

EXAMPLES:

sage: W = ReflectionGroup((3,1,2))          # optional - gap3
sage: for w in W:                           # optional - gap3
....:     w.reduced_word()                  # optional - gap3
....:     [w.to_matrix(), w.to_matrix(on_space="dual")] # optional - gap3
[]
[
[1 0]  [1 0]
[0 1], [0 1]
]
[1]
[
[E(3)    0]  [E(3)^2      0]
[   0    1], [     0      1]
]
[2]
[
[0 1]  [0 1]
[1 0], [1 0]
]
[1, 1]
[
[E(3)^2      0]  [E(3)    0]
[     0      1], [   0    1]
]
[1, 2]
[
[   0 E(3)]  [     0 E(3)^2]
[   1    0], [     1      0]
]
[2, 1]
[
[   0    1]  [     0      1]
[E(3)    0], [E(3)^2      0]
]
[1, 1, 2]
[
[     0 E(3)^2]  [   0 E(3)]
[     1      0], [   1    0]
]
[1, 2, 1]
[
[   0 E(3)]  [     0 E(3)^2]
[E(3)    0], [E(3)^2      0]
]
[2, 1, 1]
[
[     0      1]  [   0    1]
[E(3)^2      0], [E(3)    0]
]
[2, 1, 2]
[
[   1    0]  [     1      0]
[   0 E(3)], [     0 E(3)^2]
]
[1, 1, 2, 1]
[
[     0 E(3)^2]  [     0   E(3)]
[  E(3)      0], [E(3)^2      0]
]
[1, 2, 1, 1]
[
[     0   E(3)]  [     0 E(3)^2]
[E(3)^2      0], [  E(3)      0]
]
[1, 2, 1, 2]
[
[E(3)    0]  [E(3)^2      0]
[   0 E(3)], [     0 E(3)^2]
]
[2, 1, 1, 2]
[
[     1      0]  [   1    0]
[     0 E(3)^2], [   0 E(3)]
]
[1, 1, 2, 1, 1]
[
[     0 E(3)^2]  [   0 E(3)]
[E(3)^2      0], [E(3)    0]
]
[1, 1, 2, 1, 2]
[
[E(3)^2      0]  [  E(3)      0]
[     0   E(3)], [     0 E(3)^2]
]
[1, 2, 1, 1, 2]
[
[  E(3)      0]  [E(3)^2      0]
[     0 E(3)^2], [     0   E(3)]
]
[1, 1, 2, 1, 1, 2]
[
[E(3)^2      0]  [E(3)    0]
[     0 E(3)^2], [   0 E(3)]
]
to_permutation_of_roots()

Return self as a permutation of the roots with indexing starting at \(1\).

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                      # optional - gap3
sage: for w in W:       # optional - gap3
....:     perm = w.to_permutation_of_roots()
....:     print("{} {}".format(perm, perm == w))
() True
(1,3)(2,5)(4,6) True
(1,4)(2,3)(5,6) True
(1,6,2)(3,5,4) True
(1,2,6)(3,4,5) True
(1,5)(2,4)(3,6) True
ComplexReflectionGroup.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]
ComplexReflectionGroup.braid_relations()

Return the braid relations of self.

EXAMPLES:

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

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

sage: W = ReflectionGroup((2,2,3))                          # optional - gap3
sage: W.braid_relations()                                   # optional - gap3
[[[2, 1, 2], [1, 2, 1]], [[3, 1], [1, 3]], [[3, 2, 3], [2, 3, 2]]]
ComplexReflectionGroup.cartan_matrix()

Return the Cartan matrix associated with self.

If self is crystallographic, the returned Cartan matrix is an instance of CartanMatrix, and a normal matrix otherwise.

Let \(s_1, \ldots, s_n\) be a set of reflections which generate self with associated simple roots \(s_1,\ldots,s_n\) and simple coroots \(s^\vee_i\). Then the Cartan matrix \(C = (c_{ij})\) is given by \(s^\vee_i(s_j)\). The Cartan matrix completely determines the reflection representation if the \(s_i\) are linearly independent.

EXAMPLES:

sage: ReflectionGroup(['A',4]).cartan_matrix()              # optional - gap3
[ 2 -1  0  0]
[-1  2 -1  0]
[ 0 -1  2 -1]
[ 0  0 -1  2]

sage: ReflectionGroup(['H',4]).cartan_matrix()              # optional - gap3
[              2 E(5)^2 + E(5)^3               0               0]
[E(5)^2 + E(5)^3               2              -1               0]
[              0              -1               2              -1]
[              0               0              -1               2]

sage: ReflectionGroup(4).cartan_matrix()                    # optional - gap3
[-2*E(3) - E(3)^2           E(3)^2]
[         -E(3)^2 -2*E(3) - E(3)^2]

sage: ReflectionGroup((4,2,2)).cartan_matrix()              # optional - gap3
[       2  -2*E(4)       -2]
[    E(4)        2 1 - E(4)]
[      -1 1 + E(4)        2]
ComplexReflectionGroup.codegrees()

Return the codegrees of self ordered within each irreducible component of self.

EXAMPLES:

sage: W = ReflectionGroup((1,1,4))                          # optional - gap3
sage: W.codegrees()                                         # optional - gap3
(2, 1, 0)

sage: W = ReflectionGroup((2,1,4))                          # optional - gap3
sage: W.codegrees()                                         # optional - gap3
(6, 4, 2, 0)

sage: W = ReflectionGroup((4,1,4))                          # optional - gap3
sage: W.codegrees()                                         # optional - gap3
(12, 8, 4, 0)

sage: W = ReflectionGroup((4,2,4))                          # optional - gap3
sage: W.codegrees()                                         # optional - gap3
(12, 8, 4, 0)

sage: W = ReflectionGroup((4,4,4))                          # optional - gap3
sage: W.codegrees()                                         # optional - gap3
(8, 8, 4, 0)

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

sage: W = ReflectionGroup((1,1,4), (6,1,12), 23)            # optional - gap3 # fails in GAP3
sage: W.codegrees()                                         # optional - gap3
(2, 1, 0, 66, 60, 54, 48, 42, 36, 30, 24, 18, 12, 6, 0, 8, 4, 0)
ComplexReflectionGroup.conjugacy_classes()

Return the conjugacy classes of self.

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                          # optional - gap3
sage: for C in W.conjugacy_classes(): sorted(C)             # optional - gap3
[()]
[(1,3)(2,5)(4,6), (1,4)(2,3)(5,6), (1,5)(2,4)(3,6)]
[(1,2,6)(3,4,5), (1,6,2)(3,5,4)]

sage: W = ReflectionGroup((1,1,4))                          # optional - gap3
sage: sum(len(C) for C in W.conjugacy_classes()) == W.cardinality() # optional - gap3
True

sage: W = ReflectionGroup((3,1,2))                          # optional - gap3
sage: sum(len(C) for C in W.conjugacy_classes()) == W.cardinality() # optional - gap3
True

sage: W = ReflectionGroup(23)                               # optional - gap3
sage: sum(len(C) for C in W.conjugacy_classes()) == W.cardinality() # optional - gap3
True
ComplexReflectionGroup.conjugacy_classes_representatives()

Return the shortest representatives of the conjugacy classes of self.

EXAMPLES:

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

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

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

sage: W = ReflectionGroup(23)                               # optional - gap3
sage: [w.reduced_word() for w in W.conjugacy_classes_representatives()] # optional - gap3
    [[],
     [1],
     [1, 2],
     [1, 3],
     [2, 3],
     [1, 2, 3],
     [1, 2, 1, 2],
     [1, 2, 1, 2, 3],
     [1, 2, 1, 2, 3, 2, 1, 2, 3],
     [1, 2, 1, 2, 1, 3, 2, 1, 2, 1, 3, 2, 1, 2, 3]]
ComplexReflectionGroup.degrees()

Return the degrees of self ordered within each irreducible component of self.

EXAMPLES:

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

sage: W = ReflectionGroup((2,1,4))                          # optional - gap3
sage: W.degrees()                                           # optional - gap3
(2, 4, 6, 8)

sage: W = ReflectionGroup((4,1,4))                          # optional - gap3
sage: W.degrees()                                           # optional - gap3
(4, 8, 12, 16)

sage: W = ReflectionGroup((4,2,4))                          # optional - gap3
sage: W.degrees()                                           # optional - gap3
(4, 8, 8, 12)

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

Examples of reducible types:

sage: W = ReflectionGroup((1,1,4), (3,1,2)); W              # optional - gap3
Reducible complex reflection group of rank 5 and type A3 x G(3,1,2)
sage: W.degrees()                                           # optional - gap3
(2, 3, 4, 3, 6)

sage: W = ReflectionGroup((1,1,4), (6,1,12), 23)            # optional - gap3 # fails in GAP3
sage: W.degrees()                                           # optional - gap3
(2, 3, 4, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 2, 6, 10)
ComplexReflectionGroup.distinguished_reflection(i)

Return the i-th distinguished reflection of self.

These are the reflections in self 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: W = ReflectionGroup((1,1,3))                          # optional - gap3
sage: W.distinguished_reflection(1)                         # optional - gap3
(1,4)(2,3)(5,6)
sage: W.distinguished_reflection(2)                         # optional - gap3
(1,3)(2,5)(4,6)
sage: W.distinguished_reflection(3)                         # optional - gap3
(1,5)(2,4)(3,6)

sage: W = ReflectionGroup((3,1,1),hyperplane_index_set=['a'])   # optional - gap3
sage: W.distinguished_reflection('a')                       # optional - gap3
(1,2,3)

sage: W = ReflectionGroup((1,1,3),(3,1,2))                  # optional - gap3
sage: for i in range(W.number_of_reflection_hyperplanes()): # optional - gap3
....:     W.distinguished_reflection(i+1)                   # optional - gap3
(1,6)(2,5)(7,8)
(1,5)(2,7)(6,8)
(3,9,15)(4,10,16)(12,17,23)(14,18,24)(20,25,29)(21,22,26)(27,28,30)
(3,11)(4,12)(9,13)(10,14)(15,19)(16,20)(17,21)(18,22)(23,27)(24,28)(25,26)(29,30)
(1,7)(2,6)(5,8)
(3,19)(4,25)(9,11)(10,17)(12,28)(13,15)(14,30)(16,18)(20,27)(21,29)(22,23)(24,26)
(4,21,27)(10,22,28)(11,13,19)(12,14,20)(16,26,30)(17,18,25)(23,24,29)
(3,13)(4,24)(9,19)(10,29)(11,15)(12,26)(14,21)(16,23)(17,30)(18,27)(20,22)(25,28)
ComplexReflectionGroup.distinguished_reflections()

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

These are the reflections in self 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: W = ReflectionGroup((1,1,3))                          # optional - gap3
sage: W.distinguished_reflections()                         # optional - gap3
Finite family {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'])   # optional - gap3
sage: W.distinguished_reflections()                         # optional - gap3
Finite family {'a': (1,4)(2,3)(5,6), 'c': (1,5)(2,4)(3,6), 'b': (1,3)(2,5)(4,6)}

sage: W = ReflectionGroup((3,1,1))                          # optional - gap3
sage: W.distinguished_reflections()                         # optional - gap3
Finite family {1: (1,2,3)}

sage: W = ReflectionGroup((1,1,3),(3,1,2))                  # optional - gap3
sage: W.distinguished_reflections()                         # optional - gap3
Finite family {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)}
ComplexReflectionGroup.fundamental_invariants()

Return the fundamental invariants of self.

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                          # optional - gap3
sage: W.fundamental_invariants()                            # optional - gap3
(-2*x0^2 + 2*x0*x1 - 2*x1^2, 6*x0^2*x1 - 6*x0*x1^2)

sage: W = ReflectionGroup((3,1,2))                          # optional - gap3
sage: W.fundamental_invariants()                            # optional - gap3
(x0^3 + x1^3, x0^3*x1^3)
ComplexReflectionGroup.hyperplane_index_set()

Return the index set of the hyperplanes of self.

EXAMPLES:

sage: W = ReflectionGroup((1,1,4))                          # optional - gap3
sage: W.hyperplane_index_set()                              # optional - gap3
(1, 2, 3, 4, 5, 6)
sage: W = ReflectionGroup((1,1,4), hyperplane_index_set=[1,3,'asdf',7,9,11])    # optional - gap3
sage: W.hyperplane_index_set()                              # optional - gap3
(1, 3, 'asdf', 7, 9, 11)
sage: W = ReflectionGroup((1,1,4),hyperplane_index_set=('a','b','c','d','e','f'))   # optional - gap3
sage: W.hyperplane_index_set()                              # optional - gap3
('a', 'b', 'c', 'd', 'e', 'f')
ComplexReflectionGroup.independent_roots()

Return a collection of simple roots generating the underlying vector space of self.

For well-generated groups, these are all simple roots. Otherwise, a linearly independent subset of the simple roots is chosen.

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                          # optional - gap3
sage: W.independent_roots()                                 # optional - gap3
Finite family {1: (1, 0), 2: (0, 1)}

sage: W = ReflectionGroup((4,2,3))                          # optional - gap3
sage: W.simple_roots()                                      # optional - gap3
Finite family {1: (1, 0, 0), 2: (-E(4), 1, 0), 3: (-1, 1, 0), 4: (0, -1, 1)}
sage: W.independent_roots()                                 # optional - gap3
Finite family {1: (1, 0, 0), 2: (-E(4), 1, 0), 4: (0, -1, 1)}
ComplexReflectionGroup.index_set()

Return the index set of the simple reflections of self.

EXAMPLES:

sage: W = ReflectionGroup((1,1,4))                          # optional - gap3
sage: W.index_set()                                         # optional - gap3
(1, 2, 3)
sage: W = ReflectionGroup((1,1,4), index_set=[1,3,'asdf'])  # optional - gap3
sage: W.index_set()                                         # optional - gap3
(1, 3, 'asdf')
sage: W = ReflectionGroup((1,1,4), index_set=('a', 'b', 'c'))   # optional - gap3
sage: W.index_set()                                         # optional - gap3
('a', 'b', 'c')
ComplexReflectionGroup.invariant_form(brute_force=False)

Return the form that is invariant under the action of self.

This is unique only up to a global scalar on the irreducible components.

INPUT:

  • brute_force – if True, the computation is done by applying the Reynolds operator; this is, the invariant form of \(e_i\) and \(e_j\) is computed as the sum \(\langle w(e_i), w(e_j)\rangle\), where \(\langle \cdot, \cdot\rangle\) is the standard scalar product

EXAMPLES:

sage: W = ReflectionGroup(['A',3])                          # optional - gap3
sage: F = W.invariant_form(); F                             # optional - gap3
[   1 -1/2    0]
[-1/2    1 -1/2]
[   0 -1/2    1]

To check that this is indeed the invariant form, see:

sage: S = W.simple_reflections()                            # optional - gap3
sage: all( F == S[i].matrix()*F*S[i].matrix().transpose() for i in W.index_set() )  # optional - gap3
True

sage: W = ReflectionGroup(['B',3])                          # optional - gap3
sage: F = W.invariant_form(); F                             # optional - gap3
[ 1 -1  0]
[-1  2 -1]
[ 0 -1  2]
sage: w = W.an_element().to_matrix()                        # optional - gap3
sage: w * F * w.transpose().conjugate() == F                # optional - gap3
True

sage: S = W.simple_reflections()                            # optional - gap3
sage: all( F == S[i].matrix()*F*S[i].matrix().transpose() for i in W.index_set() )  # optional - gap3
True

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

sage: S = W.simple_reflections()                            # optional - gap3
sage: all( F == S[i].matrix()*F*S[i].matrix().transpose().conjugate() for i in W.index_set() )  # optional - gap3
True

It also worked for badly generated groups:

sage: W = ReflectionGroup(7)                                # optional - gap3
sage: W.is_well_generated()                                 # optional - gap3
False

sage: F = W.invariant_form(); F                             # optional - gap3
[1 0]
[0 1]
sage: S = W.simple_reflections()                            # optional - gap3
sage: all( F == S[i].matrix()*F*S[i].matrix().transpose().conjugate() for i in W.index_set() )  # optional - gap3
True

And also for reducible types:

sage: W = ReflectionGroup(['B',3],(4,2,3),4,7); W           # optional - gap3
Reducible complex reflection group of rank 10 and type B3 x G(4,2,3) x ST4 x ST7
sage: F = W.invariant_form(); S = W.simple_reflections()    # optional - gap3
sage: all( F == S[i].matrix()*F*S[i].matrix().transpose().conjugate() for i in W.index_set() )  # optional - gap3
True

TESTS:

sage: tests = [['A',3],['B',3],['F',4],(4,2,2),4,7]         # optional - gap3
sage: for ty in tests:                                      # optional - gap3
....:     W = ReflectionGroup(ty)                           # optional - gap3
....:     A = W.invariant_form()                            # optional - gap3
....:     B = W.invariant_form(brute_force=True)            # optional - gap3
....:     print("{} {}".format(ty, A == B/B[0,0]))          # optional - gap3
['A', 3] True
['B', 3] True
['F', 4] True
(4, 2, 2) True
4 True
7 True
ComplexReflectionGroup.irreducible_components()

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

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                          # optional - gap3
sage: W.irreducible_components()                            # optional - gap3
[Irreducible real reflection group of rank 2 and type A2]

sage: W = ReflectionGroup((1,1,3),(2,1,3))                  # optional - gap3
sage: W.irreducible_components()                            # optional - gap3
[Irreducible real reflection group of rank 2 and type A2,
Irreducible real reflection group of rank 3 and type B3]
ComplexReflectionGroup.is_crystallographic()

Return True if self is crystallographic.

This is, if the field of definition is the rational field.

Todo

Make this more robust and do not use the matrix representation of the simple reflections.

EXAMPLES:

sage: W = ReflectionGroup((1,1,3)); W                       # optional - gap3
Irreducible real reflection group of rank 2 and type A2
sage: W.is_crystallographic()                               # optional - gap3
True

sage: W = ReflectionGroup((2,1,3)); W                       # optional - gap3
Irreducible real reflection group of rank 3 and type B3
sage: W.is_crystallographic()                               # optional - gap3
True

sage: W = ReflectionGroup(23); W                            # optional - gap3
Irreducible real reflection group of rank 3 and type H3
sage: W.is_crystallographic()                               # optional - gap3
False

sage: W = ReflectionGroup((3,1,3)); W                       # optional - gap3
Irreducible complex reflection group of rank 3 and type G(3,1,3)
sage: W.is_crystallographic()                               # optional - gap3
False

sage: W = ReflectionGroup((4,2,2)); W                       # optional - gap3
Irreducible complex reflection group of rank 2 and type G(4,2,2)
sage: W.is_crystallographic()                               # optional - gap3
False
ComplexReflectionGroup.number_of_irreducible_components()

Return the number of irreducible components of self.

EXAMPLES:

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

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

Return the rank of self.

This is the dimension of the underlying vector space.

EXAMPLES:

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

Return the i-th reflection of self.

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                          # optional - gap3
sage: W.reflection(1)                                       # optional - gap3
(1,4)(2,3)(5,6)
sage: W.reflection(2)                                       # optional - gap3
(1,3)(2,5)(4,6)
sage: W.reflection(3)                                       # optional - gap3
(1,5)(2,4)(3,6)

sage: W = ReflectionGroup((3,1,1),reflection_index_set=['a','b'])   # optional - gap3
sage: W.reflection('a')                                     # optional - gap3
(1,2,3)
sage: W.reflection('b')                                     # optional - gap3
(1,3,2)
ComplexReflectionGroup.reflection_character()

Return the reflection characters of self.

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                          # optional - gap3
sage: W.reflection_character()                              # optional - gap3
[2, 0, -1]
ComplexReflectionGroup.reflection_eigenvalues(w, is_class_representative=False)

Return the reflection eigenvalue of w in self.

INPUT:

  • is_class_representative – boolean (default True) whether to compute instead on the conjugacy class representative.

See also

reflection_eigenvalues_family()

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                          # optional - gap3
sage: for w in W:                                           # optional - gap3
....:     print('%s %s'%(w.reduced_word(), W.reflection_eigenvalues(w)))    # optional - gap3
[] [0, 0]
[2] [1/2, 0]
[1] [1/2, 0]
[1, 2] [1/3, 2/3]
[2, 1] [1/3, 2/3]
[1, 2, 1] [1/2, 0]
ComplexReflectionGroup.reflection_eigenvalues_family()

Return the reflection eigenvalues of self as a finite family indexed by the class representatives of self.

OUTPUT:

  • list with entries \(k/n\) representing the eigenvalue \(\zeta_n^k\).

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                          # optional - gap3
sage: W.reflection_eigenvalues_family()                     # optional - gap3
Finite family {(): [0, 0], (1,4)(2,3)(5,6): [1/2, 0], (1,6,2)(3,5,4): [1/3, 2/3]}

sage: W = ReflectionGroup((3,1,2))                          # optional - gap3
sage: reflection_eigenvalues = W.reflection_eigenvalues_family()    # optional - gap3
sage: for elt in sorted(reflection_eigenvalues):     # optional - gap3
....:     print('%s %s'%(elt, reflection_eigenvalues[elt])) # optional - gap3
() [0, 0]
(1,3,9)(2,4,10)(6,11,17)(8,12,18)(14,19,23)(15,16,20)(21,22,24) [1/3, 0]
(1,3,9)(2,16,24)(4,20,21)(5,7,13)(6,12,23)(8,19,17)(10,15,22)(11,18,14) [1/3, 1/3]
(1,5)(2,6)(3,7)(4,8)(9,13)(10,14)(11,15)(12,16)(17,21)(18,22)(19,20)(23,24) [1/2, 0]
(1,7,3,13,9,5)(2,8,16,19,24,17)(4,14,20,11,21,18)(6,15,12,22,23,10) [1/6, 2/3]
(1,9,3)(2,10,4)(6,17,11)(8,18,12)(14,23,19)(15,20,16)(21,24,22) [2/3, 0]
(1,9,3)(2,20,22)(4,15,24)(5,7,13)(6,18,19)(8,23,11)(10,16,21)(12,14,17) [1/3, 2/3]
(1,9,3)(2,24,16)(4,21,20)(5,13,7)(6,23,12)(8,17,19)(10,22,15)(11,14,18) [2/3, 2/3]
(1,13,9,7,3,5)(2,14,24,18,16,11)(4,6,21,23,20,12)(8,22,17,15,19,10) [1/3, 5/6]

sage: W = ReflectionGroup(23)                               # optional - gap3
sage: reflection_eigenvalues = W.reflection_eigenvalues_family()    # optional - gap3
sage: for elt in sorted(reflection_eigenvalues):     # optional - gap3
....:     print('%s %s'%(elt, reflection_eigenvalues[elt])) # optional - gap3
() [0, 0, 0]
(1,8,4)(2,21,3)(5,10,11)(6,18,17)(7,9,12)(13,14,15)(16,23,19)(20,25,26)(22,24,27)(28,29,30) [1/3, 2/3, 0]
(1,16)(2,5)(4,7)(6,9)(8,10)(11,13)(12,14)(17,20)(19,22)(21,24)(23,25)(26,28)(27,29) [1/2, 0, 0]
(1,16)(2,9)(3,18)(4,10)(5,6)(7,8)(11,14)(12,13)(17,24)(19,25)(20,21)(22,23)(26,29)(27,28) [1/2, 1/2, 0]
(1,16)(2,17)(3,18)(4,19)(5,20)(6,21)(7,22)(8,23)(9,24)(10,25)(11,26)(12,27)(13,28)(14,29)(15,30) [1/2, 1/2, 1/2]
(1,19,20,2,7)(3,6,11,13,9)(4,5,17,22,16)(8,12,15,14,10)(18,21,26,28,24)(23,27,30,29,25) [1/5, 4/5, 0]
(1,20,7,19,2)(3,11,9,6,13)(4,17,16,5,22)(8,15,10,12,14)(18,26,24,21,28)(23,30,25,27,29) [2/5, 3/5, 0]
(1,23,26,29,22,16,8,11,14,7)(2,10,4,9,18,17,25,19,24,3)(5,21,27,30,28,20,6,12,15,13) [1/10, 1/2, 9/10]
(1,24,17,16,9,2)(3,12,13,18,27,28)(4,21,29,19,6,14)(5,25,26,20,10,11)(7,23,30,22,8,15) [1/6, 1/2, 5/6]
(1,29,8,7,26,16,14,23,22,11)(2,9,25,3,4,17,24,10,18,19)(5,30,6,13,27,20,15,21,28,12) [3/10, 1/2, 7/10]
ComplexReflectionGroup.reflection_hyperplane(i, as_linear_functional=False)

Return the i-th reflection hyperplane of self.

The i-th reflection hyperplane corresponds to the i distinguished reflection.

INPUT:

  • i – an index in the index set
  • as_linear_functionals – (default:False) flag whether to return the hyperplane or its linear functional in the basis dual to the given root basis

EXAMPLES:

sage: W = ReflectionGroup((2,1,2))                          # optional - gap3
sage: W.reflection_hyperplane(3)                            # optional - gap3
Vector space of degree 2 and dimension 1 over Rational Field
Basis matrix:
[1 0]

One can ask for the result as a linear form:

sage: W.reflection_hyperplane(3, True)                      # optional - gap3
(0, 1)
ComplexReflectionGroup.reflection_hyperplanes(as_linear_functionals=False)

Return the list of all reflection hyperplanes of self, either as a codimension 1 space, or as its linear functional.

INPUT:

  • as_linear_functionals – (default:False) flag whether to return the hyperplane or its linear functional in the basis dual to the given root basis

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                          # optional - gap3
sage: for H in W.reflection_hyperplanes(): H                # optional - gap3
Vector space of degree 2 and dimension 1 over Rational Field
Basis matrix:
[1 2]
Vector space of degree 2 and dimension 1 over Rational Field
Basis matrix:
[  1 1/2]
Vector space of degree 2 and dimension 1 over Rational Field
Basis matrix:
[ 1 -1]

sage: for H in W.reflection_hyperplanes(as_linear_functionals=True): H  # optional - gap3
(1, -1/2)
(1, -2)
(1, 1)


sage: W = ReflectionGroup((2,1,2))                          # optional - gap3
sage: for H in W.reflection_hyperplanes(): H                # optional - gap3
Vector space of degree 2 and dimension 1 over Rational Field
Basis matrix:
[1 1]
Vector space of degree 2 and dimension 1 over Rational Field
Basis matrix:
[  1 1/2]
Vector space of degree 2 and dimension 1 over Rational Field
Basis matrix:
[1 0]
Vector space of degree 2 and dimension 1 over Rational Field
Basis matrix:
[0 1]

sage: for H in W.reflection_hyperplanes(as_linear_functionals=True): H  # optional - gap3
(1, -1)
(1, -2)
(0, 1)
(1, 0)
ComplexReflectionGroup.reflection_index_set()

Return the index set of the reflections of self.

EXAMPLES:

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

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

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                          # optional - gap3
sage: W.reflections()                                       # optional - gap3
Finite family {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'])   # optional - gap3
sage: W.reflections()                                       # optional - gap3
Finite family {'a': (1,4)(2,3)(5,6), 'c': (1,5)(2,4)(3,6), 'b': (1,3)(2,5)(4,6)}

sage: W = ReflectionGroup((3,1,1))                          # optional - gap3
sage: W.reflections()                                       # optional - gap3
Finite family {1: (1,2,3), 2: (1,3,2)}

sage: W = ReflectionGroup((1,1,3),(3,1,2))                  # optional - gap3
sage: W.reflections()                                       # optional - gap3
Finite family {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)}
ComplexReflectionGroup.roots()

Return all roots corresponding to all reflections of self.

EXAMPLES:

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

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

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

sage: W = ReflectionGroup((1,1,4), (3,1,2))                 # optional - gap3
sage: W.roots()                                             # optional - gap3
[(1, 0, 0, 0, 0), (0, 1, 0, 0, 0), (0, 0, 1, 0, 0),
 (0, 0, 0, 1, 0), (0, 0, 0, -1, 1), (1, 1, 0, 0, 0),
 (0, 1, 1, 0, 0), (1, 1, 1, 0, 0), (-1, 0, 0, 0, 0),
 (0, -1, 0, 0, 0), (0, 0, -1, 0, 0), (-1, -1, 0, 0, 0),
 (0, -1, -1, 0, 0), (-1, -1, -1, 0, 0), (0, 0, 0, E(3), 0),
 (0, 0, 0, -E(3), 1), (0, 0, 0, 0, 1), (0, 0, 0, 1, -1),
 (0, 0, 0, 0, E(3)), (0, 0, 0, 1, -E(3)), (0, 0, 0, E(3)^2, 0),
 (0, 0, 0, -E(3)^2, 1), (0, 0, 0, E(3), -1), (0, 0, 0, E(3), -E(3)),
 (0, 0, 0, 0, E(3)^2), (0, 0, 0, 1, -E(3)^2), (0, 0, 0, -1, E(3)),
 (0, 0, 0, -E(3), E(3)), (0, 0, 0, E(3)^2, -1),
 (0, 0, 0, E(3)^2, -E(3)), (0, 0, 0, E(3), -E(3)^2),
 (0, 0, 0, -E(3)^2, E(3)), (0, 0, 0, -1, E(3)^2),
 (0, 0, 0, -E(3), E(3)^2), (0, 0, 0, E(3)^2, -E(3)^2),
 (0, 0, 0, -E(3)^2, E(3)^2)]
ComplexReflectionGroup.series()

Return the series of the classification type to which self belongs.

For real reflection groups, these are the Cartan-Killing classification types “A”,”B”,”C”,”D”,”E”,”F”,”G”,”H”,”I”, and for complx non-real reflection groups these are the Shephard-Todd classification type “ST”.

EXAMPLES:

sage: ReflectionGroup((1,1,3)).series()                     # optional - gap3
['A']
sage: ReflectionGroup((3,1,3)).series()                     # optional - gap3
['ST']
ComplexReflectionGroup.set_reflection_representation(refl_repr=None)

Set the reflection representation of self.

INPUT:

  • refl_repr – a dictionary representing the matrices of the generators of self with keys given by the index set, or None to reset to the default reflection representation

EXAMPLES:

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

sage: W.set_reflection_representation({1: matrix([[0,1,0],[1,0,0],[0,0,1]]), 2: matrix([[1,0,0],[0,0,1],[0,1,0]])}) # optional - gap3
sage: for w in W: w.to_matrix(); print("-----")             # optional - gap3
[1 0 0]
[0 1 0]
[0 0 1]
-----
[1 0 0]
[0 0 1]
[0 1 0]
-----
[0 1 0]
[1 0 0]
[0 0 1]
-----
[0 0 1]
[1 0 0]
[0 1 0]
-----
[0 1 0]
[0 0 1]
[1 0 0]
-----
[0 0 1]
[0 1 0]
[1 0 0]
-----
sage: W.set_reflection_representation()                     # optional - gap3
ComplexReflectionGroup.simple_coroot(i)

Return the simple root with index i.

EXAMPLES:

sage: W = ReflectionGroup(['A',3])                          # optional - gap3
sage: W.simple_coroot(1)                                    # optional - gap3
(2, -1, 0)
ComplexReflectionGroup.simple_coroots()

Return the simple coroots of self.

These are the coroots corresponding to the simple reflections.

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                          # optional - gap3
sage: W.simple_coroots()                                    # optional - gap3
Finite family {1: (2, -1), 2: (-1, 2)}

sage: W = ReflectionGroup((1,1,4), (2,1,2))                 # optional - gap3
sage: W.simple_coroots()                                    # optional - gap3
Finite family {1: (2, -1, 0, 0, 0), 2: (-1, 2, -1, 0, 0), 3: (0, -1, 2, 0, 0), 4: (0, 0, 0, 2, -2), 5: (0, 0, 0, -1, 2)}

sage: W = ReflectionGroup((3,1,2))                          # optional - gap3
sage: W.simple_coroots()                                    # optional - gap3
Finite family {1: (-2*E(3) - E(3)^2, 0), 2: (-1, 1)}

sage: W = ReflectionGroup((1,1,4), (3,1,2))                 # optional - gap3
sage: W.simple_coroots()                                    # optional - gap3
Finite family {1: (2, -1, 0, 0, 0), 2: (-1, 2, -1, 0, 0), 3: (0, -1, 2, 0, 0), 4: (0, 0, 0, -2*E(3) - E(3)^2, 0), 5: (0, 0, 0, -1, 1)}
ComplexReflectionGroup.simple_reflection(i)

Return the i-th simple reflection of self.

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                          # optional - gap3
sage: W.simple_reflection(1)                                # optional - gap3
(1,4)(2,3)(5,6)
sage: W.simple_reflections()                                # optional - gap3
Finite family {1: (1,4)(2,3)(5,6), 2: (1,3)(2,5)(4,6)}
ComplexReflectionGroup.simple_root(i)

Return the simple root with index i.

EXAMPLES:

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

TESTS:

sage: W.simple_root(0)                                      # optional - gap3
Traceback (most recent call last):
...
KeyError: 0
ComplexReflectionGroup.simple_roots()

Return the simple roots of self.

These are the roots corresponding to the simple reflections.

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                          # optional - gap3
sage: W.simple_roots()                                      # optional - gap3
Finite family {1: (1, 0), 2: (0, 1)}

sage: W = ReflectionGroup((1,1,4), (2,1,2))                 # optional - gap3
sage: W.simple_roots()                                      # optional - gap3
Finite family {1: (1, 0, 0, 0, 0), 2: (0, 1, 0, 0, 0), 3: (0, 0, 1, 0, 0), 4: (0, 0, 0, 1, 0), 5: (0, 0, 0, 0, 1)}

sage: W = ReflectionGroup((3,1,2))                          # optional - gap3
sage: W.simple_roots()                                      # optional - gap3
Finite family {1: (1, 0), 2: (-1, 1)}

sage: W = ReflectionGroup((1,1,4), (3,1,2))                 # optional - gap3
sage: W.simple_roots()                                      # optional - gap3
Finite family {1: (1, 0, 0, 0, 0), 2: (0, 1, 0, 0, 0), 3: (0, 0, 1, 0, 0), 4: (0, 0, 0, 1, 0), 5: (0, 0, 0, -1, 1)}
class sage.combinat.root_system.reflection_group_complex.IrreducibleComplexReflectionGroup(W_types, index_set=None, hyperplane_index_set=None, reflection_index_set=None)

Bases: sage.combinat.root_system.reflection_group_complex.ComplexReflectionGroup

TESTS:

sage: from sage.categories.complex_reflection_groups import ComplexReflectionGroups
sage: W = ComplexReflectionGroups().example()               # optional - gap3
sage: TestSuite(W).run()                                    # optional - gap3
class Element

Bases: sage.combinat.root_system.reflection_group_complex.ComplexReflectionGroup.Element

is_coxeter_element(which_primitive=1, is_class_representative=False)

Return True if self is a Coxeter element.

INPUT:

  • which_primitive – (default:1) for which power of the first primitive h-th root of unity to look as a reflection eigenvalue for a regular element
  • is_class_representative – boolean (default True) whether to compute instead on the conjugacy class representative

See also

coxeter_element()

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                      # optional - gap3
sage: for w in W:                                       # optional - gap3
....:     print('%s %s'%(w.reduced_word(), w.is_coxeter_element())) # optional - gap3
[] False
[2] False
[1] False
[1, 2] True
[2, 1] True
[1, 2, 1] False
is_h_regular(is_class_representative=False)

Return whether self is regular.

This is if self has an eigenvector with eigenvalue \(h\) and which does not lie in any reflection hyperplane. Here, \(h\) denotes the Coxeter number.

EXAMPLES:

sage: W = ReflectionGroup((1,1,3))                      # optional - gap3
sage: for w in W:                                       # optional - gap3
....:     print('%s %s'%(w.reduced_word(), w.is_h_regular()))   # optional - gap3
[] False
[2] False
[1] False
[1, 2] True
[2, 1] True
[1, 2, 1] False
is_regular(h, is_class_representative=False)

Return whether self is regular.

This is, if self has an eigenvector with eigenvalue h and which does not lie in any reflection hyperplane.

  • is_class_representative – boolean (default True) whether to compute instead on the conjugacy class representative

EXAMPLES:

sage: W = ReflectionGroup((1,1,3)); h = W.coxeter_number()  # optional - gap3
sage: for w in W:                                       # optional - gap3
....:     print("{} {}".format(w.reduced_word(), w.is_regular(h)))
[] False
[2] False
[1] False
[1, 2] True
[2, 1] True
[1, 2, 1] False

sage: W = ReflectionGroup(23); h = W.coxeter_number()   # optional - gap3
sage: for w in W:                                       # optional - gap3
....:     if w.is_regular(h):                           # optional - gap3
....:         w.reduced_word()                          # optional - gap3
[1, 2, 3]
[2, 1, 3]
[1, 3, 2]
[3, 2, 1]
[2, 1, 2, 3, 2]
[2, 3, 2, 1, 2]
[1, 2, 1, 2, 3, 2, 1]
[1, 2, 3, 2, 1, 2, 1]
[1, 2, 1, 2, 3, 2, 1, 2, 3]
[2, 1, 2, 1, 3, 2, 1, 2, 3]
[2, 1, 2, 3, 2, 1, 2, 1, 3]
[1, 2, 3, 2, 1, 2, 1, 3, 2]
[3, 2, 1, 2, 1, 3, 2, 1, 2]
[1, 2, 1, 2, 1, 3, 2, 1, 2]
[2, 3, 2, 1, 2, 1, 3, 2, 1]
[2, 1, 2, 1, 3, 2, 1, 2, 1]
[2, 3, 2, 1, 2, 1, 3, 2, 1, 2, 3]
[1, 3, 2, 1, 2, 1, 3, 2, 1, 2, 3]
[1, 2, 1, 2, 1, 3, 2, 1, 2, 1, 3]
[1, 2, 1, 2, 3, 2, 1, 2, 1, 3, 2]
[1, 2, 3, 2, 1, 2, 1, 3, 2, 1, 2]
[2, 1, 2, 3, 2, 1, 2, 1, 3, 2, 1]
[2, 1, 2, 3, 2, 1, 2, 1, 3, 2, 1, 2, 3]
[1, 2, 1, 3, 2, 1, 2, 1, 3, 2, 1, 2, 3]
IrreducibleComplexReflectionGroup.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))\).

See also

noncrossing_partition_lattice()

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
IrreducibleComplexReflectionGroup.elements_below_coxeter_element(c=None)

Return all elements in self in the interval \([1,c]\) 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.

Note

self is assumed to be well-generated.

INPUT:

  • c – (default: None) if an element c is given, it is used as the maximal element in the interval; if a list is given, the union of the various maximal elements is computed

EXAMPLES:

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

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

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

sage: sorted( w.reduced_word() for w in W.elements_below_coxeter_element(W.from_reduced_word([2])) )    # optional - gap3
[[], [2]]
IrreducibleComplexReflectionGroup.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], []]]
IrreducibleComplexReflectionGroup.noncrossing_partition_lattice(c=None, L=None, in_unitary_group=False)

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

See also

elements_below_coxeter_element()

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))\)

EXAMPLES:

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]]