Subword complex - Combinatorics

Skip to content
Back to top
View this page
Edit this page

# Subword complex

Fix a Coxeter system \((W,S)\). The subword complex \(\mathcal{SC}(Q,w)\) associated to a word \(Q \in S^*\) and an element \(w \in W\) is the simplicial complex whose ground set is the set of positions in \(Q\) and whose facets are complements of sets of positions defining a reduced expression for \(w\).

A subword complex is a shellable sphere if and only if the Demazure product of \(Q\) equals \(w\), otherwise it is a shellable ball.

The code is optimized to be used with `ReflectionGroup`, it works as well with `CoxeterGroup`, but many methods fail for `WeylGroup`.

EXAMPLES:

Sage

    sage: W = ReflectionGroup(['A',3]); I = list(W.index_set())         # optional - gap3
    sage: Q = I + W.w0.coxeter_sorting_word(I); Q                       # optional - gap3
    [1, 2, 3, 1, 2, 3, 1, 2, 1]

    sage: S = SubwordComplex(Q,W.w0)                                    # optional - gap3
    sage: for F in S: print("{} {}".format(F, F.root_configuration()))                 # optional - gap3
    (0, 1, 2) [(1, 0, 0), (0, 1, 0), (0, 0, 1)]
    (0, 1, 8) [(1, 0, 0), (0, 1, 0), (0, 0, -1)]
    (0, 2, 6) [(1, 0, 0), (0, 1, 1), (0, -1, 0)]
    (0, 6, 7) [(1, 0, 0), (0, 0, 1), (0, -1, -1)]
    (0, 7, 8) [(1, 0, 0), (0, -1, 0), (0, 0, -1)]
    (1, 2, 3) [(1, 1, 0), (0, 0, 1), (-1, 0, 0)]
    (1, 3, 8) [(1, 1, 0), (-1, 0, 0), (0, 0, -1)]
    (2, 3, 4) [(1, 1, 1), (0, 1, 0), (-1, -1, 0)]
    (2, 4, 6) [(1, 1, 1), (-1, 0, 0), (0, -1, 0)]
    (3, 4, 5) [(0, 1, 0), (0, 0, 1), (-1, -1, -1)]
    (3, 5, 8) [(0, 1, 0), (-1, -1, 0), (0, 0, -1)]
    (4, 5, 6) [(0, 1, 1), (-1, -1, -1), (0, -1, 0)]
    (5, 6, 7) [(-1, 0, 0), (0, 0, 1), (0, -1, -1)]
    (5, 7, 8) [(-1, 0, 0), (0, -1, 0), (0, 0, -1)]

Python

    >>> from sage.all import *
    >>> W = ReflectionGroup(['A',Integer(3)]); I = list(W.index_set())         # optional - gap3
    >>> Q = I + W.w0.coxeter_sorting_word(I); Q                       # optional - gap3
    [1, 2, 3, 1, 2, 3, 1, 2, 1]

    >>> S = SubwordComplex(Q,W.w0)                                    # optional - gap3
    >>> for F in S: print("{} {}".format(F, F.root_configuration()))                 # optional - gap3
    (0, 1, 2) [(1, 0, 0), (0, 1, 0), (0, 0, 1)]
    (0, 1, 8) [(1, 0, 0), (0, 1, 0), (0, 0, -1)]
    (0, 2, 6) [(1, 0, 0), (0, 1, 1), (0, -1, 0)]
    (0, 6, 7) [(1, 0, 0), (0, 0, 1), (0, -1, -1)]
    (0, 7, 8) [(1, 0, 0), (0, -1, 0), (0, 0, -1)]
    (1, 2, 3) [(1, 1, 0), (0, 0, 1), (-1, 0, 0)]
    (1, 3, 8) [(1, 1, 0), (-1, 0, 0), (0, 0, -1)]
    (2, 3, 4) [(1, 1, 1), (0, 1, 0), (-1, -1, 0)]
    (2, 4, 6) [(1, 1, 1), (-1, 0, 0), (0, -1, 0)]
    (3, 4, 5) [(0, 1, 0), (0, 0, 1), (-1, -1, -1)]
    (3, 5, 8) [(0, 1, 0), (-1, -1, 0), (0, 0, -1)]
    (4, 5, 6) [(0, 1, 1), (-1, -1, -1), (0, -1, 0)]
    (5, 6, 7) [(-1, 0, 0), (0, 0, 1), (0, -1, -1)]
    (5, 7, 8) [(-1, 0, 0), (0, -1, 0), (0, 0, -1)]

Testing that the implementation also works with CoxeterGroup:

Sage

    sage: W = CoxeterGroup(['A',3]); I = list(W.index_set())
    sage: Q = I + W.w0.coxeter_sorting_word(I); Q
    [1, 2, 3, 1, 2, 3, 1, 2, 1]
    sage: S = SubwordComplex(Q,W.w0); S
    Subword complex of type ['A', 3] for Q = (1, 2, 3, 1, 2, 3, 1, 2, 1) and pi = [1, 2, 3, 1, 2, 1]
    sage: P = S.increasing_flip_poset(); P; len(P.cover_relations())
    Finite poset containing 14 elements
    21

[Python]

    >>> from sage.all import *
    >>> W = CoxeterGroup(['A',Integer(3)]); I = list(W.index_set())
    >>> Q = I + W.w0.coxeter_sorting_word(I); Q
    [1, 2, 3, 1, 2, 3, 1, 2, 1]
    >>> S = SubwordComplex(Q,W.w0); S
    Subword complex of type ['A', 3] for Q = (1, 2, 3, 1, 2, 3, 1, 2, 1) and pi = [1, 2, 3, 1, 2, 1]
    >>> P = S.increasing_flip_poset(); P; len(P.cover_relations())
    Finite poset containing 14 elements
    21

The root configuration works:

Sage

    sage: for F in S: print("{} {}".format(F, F.root_configuration()))
    (0, 1, 2) [(1, 0, 0), (0, 1, 0), (0, 0, 1)]
    (0, 1, 8) [(1, 0, 0), (0, 1, 0), (0, 0, -1)]
    (0, 2, 6) [(1, 0, 0), (0, 1, 1), (0, -1, 0)]
    (0, 6, 7) [(1, 0, 0), (0, 0, 1), (0, -1, -1)]
    (0, 7, 8) [(1, 0, 0), (0, -1, 0), (0, 0, -1)]
    (1, 2, 3) [(1, 1, 0), (0, 0, 1), (-1, 0, 0)]
    (1, 3, 8) [(1, 1, 0), (-1, 0, 0), (0, 0, -1)]
    (2, 3, 4) [(1, 1, 1), (0, 1, 0), (-1, -1, 0)]
    (2, 4, 6) [(1, 1, 1), (-1, 0, 0), (0, -1, 0)]
    (3, 4, 5) [(0, 1, 0), (0, 0, 1), (-1, -1, -1)]
    (3, 5, 8) [(0, 1, 0), (-1, -1, 0), (0, 0, -1)]
    (4, 5, 6) [(0, 1, 1), (-1, -1, -1), (0, -1, 0)]
    (5, 6, 7) [(-1, 0, 0), (0, 0, 1), (0, -1, -1)]
    (5, 7, 8) [(-1, 0, 0), (0, -1, 0), (0, 0, -1)]

Python

    >>> from sage.all import *
    >>> for F in S: print("{} {}".format(F, F.root_configuration()))
    (0, 1, 2) [(1, 0, 0), (0, 1, 0), (0, 0, 1)]
    (0, 1, 8) [(1, 0, 0), (0, 1, 0), (0, 0, -1)]
    (0, 2, 6) [(1, 0, 0), (0, 1, 1), (0, -1, 0)]
    (0, 6, 7) [(1, 0, 0), (0, 0, 1), (0, -1, -1)]
    (0, 7, 8) [(1, 0, 0), (0, -1, 0), (0, 0, -1)]
    (1, 2, 3) [(1, 1, 0), (0, 0, 1), (-1, 0, 0)]
    (1, 3, 8) [(1, 1, 0), (-1, 0, 0), (0, 0, -1)]
    (2, 3, 4) [(1, 1, 1), (0, 1, 0), (-1, -1, 0)]
    (2, 4, 6) [(1, 1, 1), (-1, 0, 0), (0, -1, 0)]
    (3, 4, 5) [(0, 1, 0), (0, 0, 1), (-1, -1, -1)]
    (3, 5, 8) [(0, 1, 0), (-1, -1, 0), (0, 0, -1)]
    (4, 5, 6) [(0, 1, 1), (-1, -1, -1), (0, -1, 0)]
    (5, 6, 7) [(-1, 0, 0), (0, 0, 1), (0, -1, -1)]
    (5, 7, 8) [(-1, 0, 0), (0, -1, 0), (0, 0, -1)]

And the weight configuration also works:

Sage

    sage: W = CoxeterGroup(['A',2])
    sage: w = W.from_reduced_word([1,2,1])
    sage: SC = SubwordComplex([1,2,1,2,1],w)
    sage: F = SC([1,2])
    sage: F.extended_weight_configuration()
    [(4/3, 2/3), (2/3, 4/3), (-2/3, 2/3), (2/3, 4/3), (-2/3, 2/3)]
    sage: F.extended_weight_configuration(coefficients=(1,2))
    [(4/3, 2/3), (4/3, 8/3), (-2/3, 2/3), (4/3, 8/3), (-2/3, 2/3)]

[Python]

    >>> from sage.all import *
    >>> W = CoxeterGroup(['A',Integer(2)])
    >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
    >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
    >>> F = SC([Integer(1),Integer(2)])
    >>> F.extended_weight_configuration()
    [(4/3, 2/3), (2/3, 4/3), (-2/3, 2/3), (2/3, 4/3), (-2/3, 2/3)]
    >>> F.extended_weight_configuration(coefficients=(Integer(1),Integer(2)))
    [(4/3, 2/3), (4/3, 8/3), (-2/3, 2/3), (4/3, 8/3), (-2/3, 2/3)]

One finally can compute the brick polytope, using all functionality on weight configurations, though it does not realize to live in real space:

Sage

    sage: W = CoxeterGroup(['A',3]); I = list(W.index_set())
    sage: Q = I + W.w0.coxeter_sorting_word(I)
    sage: S = SubwordComplex(Q,W.w0)
    sage: S.brick_polytope()                                                            # needs sage.geometry.polyhedron
    A 3-dimensional polyhedron in QQ^3 defined as the convex hull of 14 vertices

    sage: W = CoxeterGroup(['H',3]); I = list(W.index_set())
    sage: Q = I + W.w0.coxeter_sorting_word(I)
    sage: S = SubwordComplex(Q,W.w0)
    sage: S.brick_polytope()                                                            # needs sage.geometry.polyhedron
    doctest:...: RuntimeWarning: the polytope is built with rational vertices
    A 3-dimensional polyhedron in QQ^3 defined as the convex hull of 32 vertices

Python

    >>> from sage.all import *
    >>> W = CoxeterGroup(['A',Integer(3)]); I = list(W.index_set())
    >>> Q = I + W.w0.coxeter_sorting_word(I)
    >>> S = SubwordComplex(Q,W.w0)
    >>> S.brick_polytope()                                                            # needs sage.geometry.polyhedron
    A 3-dimensional polyhedron in QQ^3 defined as the convex hull of 14 vertices

    >>> W = CoxeterGroup(['H',Integer(3)]); I = list(W.index_set())
    >>> Q = I + W.w0.coxeter_sorting_word(I)
    >>> S = SubwordComplex(Q,W.w0)
    >>> S.brick_polytope()                                                            # needs sage.geometry.polyhedron
    doctest:...: RuntimeWarning: the polytope is built with rational vertices
    A 3-dimensional polyhedron in QQ^3 defined as the convex hull of 32 vertices

AUTHORS:

- Christian Stump: initial version

- Vincent Pilaud: greedy flip algorithm, minor improvements, documentation

class sage.combinat.subword_complex.SubwordComplex(Q, w, algorithm='inductive')

  Bases: `UniqueRepresentation`, `SimplicialComplex`

  Fix a Coxeter system \((W,S)\). The subword complex \(\mathcal{SC}(Q,w)\) associated to a word \(Q \in S^*\) and an element \(w \in W\) is the simplicial complex whose ground set is the set of positions in \(Q\) and whose facets are complements of sets of positions defining a reduced expression for \(w\).

  A subword complex is a shellable sphere if and only if the Demazure product of \(Q\) equals \(w\), otherwise it is a shellable ball.

  Warning

  This implementation only works for groups build using `CoxeterGroup`, and does not work with groups build using `WeylGroup`.

  EXAMPLES:

  As an example, dual associahedra are subword complexes in type \(A_{n-1}\) given by the word \([1, \dots, n, 1, \dots, n, 1, \dots, n-1, \dots, 1, 2, 1]\) and the permutation \(w_0\).

  Sage

      sage: # optional - gap3
      sage: W = ReflectionGroup(['A',2])
      sage: w = W.from_reduced_word([1,2,1])
      sage: SC = SubwordComplex([1,2,1,2,1], w); SC
      Subword complex of type ['A', 2] for Q = (1, 2, 1, 2, 1) and pi = [1, 2, 1]
      sage: SC.facets()
      [(0, 1), (0, 4), (1, 2), (2, 3), (3, 4)]

      sage: W = CoxeterGroup(['A',2])
      sage: w = W.from_reduced_word([1,2,1])
      sage: SC = SubwordComplex([1,2,1,2,1], w); SC
      Subword complex of type ['A', 2] for Q = (1, 2, 1, 2, 1) and pi = [1, 2, 1]
      sage: SC.facets()
      [(0, 1), (0, 4), (1, 2), (2, 3), (3, 4)]

  Python

      >>> from sage.all import *
      >>> # optional - gap3
      >>> W = ReflectionGroup(['A',Integer(2)])
      >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
      >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w); SC
      Subword complex of type ['A', 2] for Q = (1, 2, 1, 2, 1) and pi = [1, 2, 1]
      >>> SC.facets()
      [(0, 1), (0, 4), (1, 2), (2, 3), (3, 4)]

      >>> W = CoxeterGroup(['A',Integer(2)])
      >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
      >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w); SC
      Subword complex of type ['A', 2] for Q = (1, 2, 1, 2, 1) and pi = [1, 2, 1]
      >>> SC.facets()
      [(0, 1), (0, 4), (1, 2), (2, 3), (3, 4)]

  REFERENCES: [KnuMil], [PilStu]

  Element

    alias of `SubwordComplexFacet`

  barycenter()

    Return the barycenter of the brick polytope of `self`.

    See also

    `brick_polytope()`

    EXAMPLES:

    Sage

        sage: W = ReflectionGroup(['A',2])                          # optional - gap3
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)                # optional - gap3
        sage: SC.barycenter()                                       # optional - gap3
        (2/3, 4/3)

        sage: W = CoxeterGroup(['A',2])
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)
        sage: SC.barycenter()
        (4/3, 8/3)

    Python

        >>> from sage.all import *
        >>> W = ReflectionGroup(['A',Integer(2)])                          # optional - gap3
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)                # optional - gap3
        >>> SC.barycenter()                                       # optional - gap3
        (2/3, 4/3)

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)
        >>> SC.barycenter()
        (4/3, 8/3)

  brick_fan()

    Return the brick fan of `self`.

    It is the normal fan of the brick polytope of `self`. It is formed by the cones generated by the weight configurations of the facets of `self`.

    See also

    `weight_cone`

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1], w)
        sage: SC.brick_fan()
        Rational polyhedral fan in 2-d lattice N

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1], w)
        sage: SC.brick_fan()
        Rational polyhedral fan in 2-d lattice N

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
        >>> SC.brick_fan()
        Rational polyhedral fan in 2-d lattice N

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
        >>> SC.brick_fan()
        Rational polyhedral fan in 2-d lattice N

  brick_polytope(coefficients=None)

    Return the brick polytope of `self`.

    This polytope is the convex hull of the brick vectors of `self`.

    INPUT:

    - `coefficients` – (optional) a list of coefficients used to scale the fundamental weights

    See also

    `brick_vectors()`

    EXAMPLES:

    Sage

        sage: W = ReflectionGroup(['A',2])                          # optional - gap3
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)                # optional - gap3
        sage: X = SC.brick_polytope(); X                            # optional - gap3
        A 2-dimensional polyhedron in QQ^2 defined as the convex hull of 5 vertices

        sage: Y = SC.brick_polytope(coefficients=[1,2]); Y          # optional - gap3
        A 2-dimensional polyhedron in QQ^2 defined as the convex hull of 5 vertices

        sage: X == Y                                                # optional - gap3
        False

        sage: W = CoxeterGroup(['A',2])
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)
        sage: X = SC.brick_polytope(); X
        A 2-dimensional polyhedron in QQ^2 defined as the convex hull of 5 vertices

        sage: # optional - gap3
        sage: W = ReflectionGroup(['H',3])
        sage: c = W.index_set(); Q = c + tuple(W.w0.coxeter_sorting_word(c))
        sage: SC = SubwordComplex(Q,W.w0)
        sage: SC.brick_polytope()
        doctest:...:
        RuntimeWarning: the polytope is built with rational vertices
        A 3-dimensional polyhedron in QQ^3 defined as the convex hull of 32 vertices

    Python

        >>> from sage.all import *
        >>> W = ReflectionGroup(['A',Integer(2)])                          # optional - gap3
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)                # optional - gap3
        >>> X = SC.brick_polytope(); X                            # optional - gap3
        A 2-dimensional polyhedron in QQ^2 defined as the convex hull of 5 vertices

        >>> Y = SC.brick_polytope(coefficients=[Integer(1),Integer(2)]); Y          # optional - gap3
        A 2-dimensional polyhedron in QQ^2 defined as the convex hull of 5 vertices

        >>> X == Y                                                # optional - gap3
        False

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)
        >>> X = SC.brick_polytope(); X
        A 2-dimensional polyhedron in QQ^2 defined as the convex hull of 5 vertices

        >>> # optional - gap3
        >>> W = ReflectionGroup(['H',Integer(3)])
        >>> c = W.index_set(); Q = c + tuple(W.w0.coxeter_sorting_word(c))
        >>> SC = SubwordComplex(Q,W.w0)
        >>> SC.brick_polytope()
        doctest:...:
        RuntimeWarning: the polytope is built with rational vertices
        A 3-dimensional polyhedron in QQ^3 defined as the convex hull of 32 vertices

  brick_vectors(coefficients=None)

    Return the list of all brick vectors of facets of `self`.

    INPUT:

    - `coefficients` – (optional) a list of coefficients used to scale the fundamental weights

    See also

    `brick_vector`

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)
        sage: SC.brick_vectors()
        [(5/3, 7/3), (5/3, 1/3), (2/3, 7/3), (-1/3, 4/3), (-1/3, 1/3)]
        sage: SC.brick_vectors(coefficients=(1,2))
        [(7/3, 11/3), (7/3, 2/3), (4/3, 11/3), (-2/3, 5/3), (-2/3, 2/3)]

        sage: W = CoxeterGroup(['A',2])
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)
        sage: SC.brick_vectors()
        [(10/3, 14/3), (10/3, 2/3), (4/3, 14/3), (-2/3, 8/3), (-2/3, 2/3)]
        sage: SC.brick_vectors(coefficients=(1,2))
        [(14/3, 22/3), (14/3, 4/3), (8/3, 22/3), (-4/3, 10/3), (-4/3, 4/3)]

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)
        >>> SC.brick_vectors()
        [(5/3, 7/3), (5/3, 1/3), (2/3, 7/3), (-1/3, 4/3), (-1/3, 1/3)]
        >>> SC.brick_vectors(coefficients=(Integer(1),Integer(2)))
        [(7/3, 11/3), (7/3, 2/3), (4/3, 11/3), (-2/3, 5/3), (-2/3, 2/3)]

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)
        >>> SC.brick_vectors()
        [(10/3, 14/3), (10/3, 2/3), (4/3, 14/3), (-2/3, 8/3), (-2/3, 2/3)]
        >>> SC.brick_vectors(coefficients=(Integer(1),Integer(2)))
        [(14/3, 22/3), (14/3, 4/3), (8/3, 22/3), (-4/3, 10/3), (-4/3, 4/3)]

  cartan_type()

    Return the Cartan type of `self`.

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1], w)
        sage: SC.cartan_type()
        ['A', 2]

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1], w)
        sage: SC.cartan_type()
        ['A', 2]

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
        >>> SC.cartan_type()
        ['A', 2]

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
        >>> SC.cartan_type()
        ['A', 2]

  cover_relations(label=False)

    Return the set of cover relations in the associated poset.

    INPUT:

    - `label` – boolean (default: `False`); whether or not to label the cover relations by the position of flip

    OUTPUT: list of pairs of facets

    EXAMPLES:

    Sage

        sage: W = ReflectionGroup(['A',2])                          # optional - gap3
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)                # optional - gap3
        sage: sorted(SC.cover_relations())                          # optional - gap3
        [((0, 1), (0, 4)),
         ((0, 1), (1, 2)),
         ((0, 4), (3, 4)),
         ((1, 2), (2, 3)),
         ((2, 3), (3, 4))]

        sage: W = CoxeterGroup(['A',2])
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)
        sage: sorted(SC.cover_relations())
        [((0, 1), (0, 4)),
         ((0, 1), (1, 2)),
         ((0, 4), (3, 4)),
         ((1, 2), (2, 3)),
         ((2, 3), (3, 4))]

    Python

        >>> from sage.all import *
        >>> W = ReflectionGroup(['A',Integer(2)])                          # optional - gap3
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)                # optional - gap3
        >>> sorted(SC.cover_relations())                          # optional - gap3
        [((0, 1), (0, 4)),
         ((0, 1), (1, 2)),
         ((0, 4), (3, 4)),
         ((1, 2), (2, 3)),
         ((2, 3), (3, 4))]

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)
        >>> sorted(SC.cover_relations())
        [((0, 1), (0, 4)),
         ((0, 1), (1, 2)),
         ((0, 4), (3, 4)),
         ((1, 2), (2, 3)),
         ((2, 3), (3, 4))]

  dimension()

    Return the dimension of `self`.

    EXAMPLES:

    Sage

        sage: W = ReflectionGroup(['A',2])                          # optional - gap3
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)                # optional - gap3
        sage: SC.dimension()                                        # optional - gap3
        1

        sage: W = CoxeterGroup(['A',2])
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)
        sage: SC.dimension()
        1

    Python

        >>> from sage.all import *
        >>> W = ReflectionGroup(['A',Integer(2)])                          # optional - gap3
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)                # optional - gap3
        >>> SC.dimension()                                        # optional - gap3
        1

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)
        >>> SC.dimension()
        1

  facets()

    Return all facets of `self`.

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1], w)
        sage: SC.facets()
        [(0, 1), (0, 4), (1, 2), (2, 3), (3, 4)]

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1], w)
        sage: SC.facets()
        [(0, 1), (0, 4), (1, 2), (2, 3), (3, 4)]

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
        >>> SC.facets()
        [(0, 1), (0, 4), (1, 2), (2, 3), (3, 4)]

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
        >>> SC.facets()
        [(0, 1), (0, 4), (1, 2), (2, 3), (3, 4)]

  greedy_facet(side='positive')

    Return the negative (or positive) greedy facet of `self`.

    This is the lexicographically last (or first) facet of `self`.

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1], w)
        sage: SC.greedy_facet(side='positive')
        (0, 1)
        sage: SC.greedy_facet(side='negative')
        (3, 4)

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1], w)
        sage: SC.greedy_facet(side='positive')
        (0, 1)
        sage: SC.greedy_facet(side='negative')
        (3, 4)

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
        >>> SC.greedy_facet(side='positive')
        (0, 1)
        >>> SC.greedy_facet(side='negative')
        (3, 4)

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
        >>> SC.greedy_facet(side='positive')
        (0, 1)
        >>> SC.greedy_facet(side='negative')
        (3, 4)

  group()

    Return the group associated to `self`.

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1], w)
        sage: SC.group()
        Irreducible real reflection group of rank 2 and type A2

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1], w)
        sage: SC.group()
        Finite Coxeter group over Integer Ring with Coxeter matrix:
        [1 3]
        [3 1]

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
        >>> SC.group()
        Irreducible real reflection group of rank 2 and type A2

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
        >>> SC.group()
        Finite Coxeter group over Integer Ring with Coxeter matrix:
        [1 3]
        [3 1]

  increasing_flip_graph(label=True)

    Return the increasing flip graph of the subword complex.

    OUTPUT: a directed graph

    EXAMPLES:

    Sage

        sage: W = ReflectionGroup(['A',2])                          # optional - gap3
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)                # optional - gap3
        sage: SC.increasing_flip_graph()                            # optional - gap3
        Digraph on 5 vertices

        sage: W = CoxeterGroup(['A',2])
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)
        sage: SC.increasing_flip_graph()
        Digraph on 5 vertices

    Python

        >>> from sage.all import *
        >>> W = ReflectionGroup(['A',Integer(2)])                          # optional - gap3
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)                # optional - gap3
        >>> SC.increasing_flip_graph()                            # optional - gap3
        Digraph on 5 vertices

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)
        >>> SC.increasing_flip_graph()
        Digraph on 5 vertices

  increasing_flip_poset()

    Return the increasing flip poset of the subword complex.

    OUTPUT: a poset

    EXAMPLES:

    Sage

        sage: W = ReflectionGroup(['A',2])                          # optional - gap3
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)                # optional - gap3
        sage: SC.increasing_flip_poset()                            # optional - gap3
        Finite poset containing 5 elements

        sage: W = CoxeterGroup(['A',2])
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)
        sage: SC.increasing_flip_poset()
        Finite poset containing 5 elements

    Python

        >>> from sage.all import *
        >>> W = ReflectionGroup(['A',Integer(2)])                          # optional - gap3
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)                # optional - gap3
        >>> SC.increasing_flip_poset()                            # optional - gap3
        Finite poset containing 5 elements

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)
        >>> SC.increasing_flip_poset()
        Finite poset containing 5 elements

  interval(I, J)

    Return the interval [I,J] in the increasing flip graph subword complex.

    INPUT:

    - I, J – two facets

    OUTPUT: a set of facets

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)
        sage: F = SC([1,2])
        sage: SC.interval(F, F)
        {(1, 2)}

        sage: W = CoxeterGroup(['A',2])
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)
        sage: F = SC([1,2])
        sage: SC.interval(F, F)
        {(1, 2)}

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)
        >>> F = SC([Integer(1),Integer(2)])
        >>> SC.interval(F, F)
        {(1, 2)}

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)
        >>> F = SC([Integer(1),Integer(2)])
        >>> SC.interval(F, F)
        {(1, 2)}

  is_ball()

    Return `True` if the subword complex `self` is a ball.

    This is the case if and only if it is not a sphere.

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',3])
        sage: w = W.from_reduced_word([2,3,2])
        sage: SC = SubwordComplex([3,2,3,2,3], w)
        sage: SC.is_ball()
        False

        sage: SC = SubwordComplex([3,2,1,3,2,3], w)                 # optional - gap3
        sage: SC.is_ball()                                          # optional - gap3
        True

        sage: W = CoxeterGroup(['A',3])
        sage: w = W.from_reduced_word([2,3,2])
        sage: SC = SubwordComplex([3,2,3,2,3], w)
        sage: SC.is_ball()
        False

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(3)])
        >>> w = W.from_reduced_word([Integer(2),Integer(3),Integer(2)])
        >>> SC = SubwordComplex([Integer(3),Integer(2),Integer(3),Integer(2),Integer(3)], w)
        >>> SC.is_ball()
        False

        >>> SC = SubwordComplex([Integer(3),Integer(2),Integer(1),Integer(3),Integer(2),Integer(3)], w)                 # optional - gap3
        >>> SC.is_ball()                                          # optional - gap3
        True

        >>> W = CoxeterGroup(['A',Integer(3)])
        >>> w = W.from_reduced_word([Integer(2),Integer(3),Integer(2)])
        >>> SC = SubwordComplex([Integer(3),Integer(2),Integer(3),Integer(2),Integer(3)], w)
        >>> SC.is_ball()
        False

  is_double_root_free()

    Return `True` if `self` is double-root-free.

    This means that the root configurations of all facets do not contain a root twice.

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1], w)
        sage: SC.is_double_root_free()
        True

        sage: SC = SubwordComplex([1,1,2,2,1,1], w)                 # optional - gap3
        sage: SC.is_double_root_free()                              # optional - gap3
        True

        sage: SC = SubwordComplex([1,2,1,2,1,2], w)                 # optional - gap3
        sage: SC.is_double_root_free()                              # optional - gap3
        False

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1], w)
        sage: SC.is_double_root_free()
        True

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
        >>> SC.is_double_root_free()
        True

        >>> SC = SubwordComplex([Integer(1),Integer(1),Integer(2),Integer(2),Integer(1),Integer(1)], w)                 # optional - gap3
        >>> SC.is_double_root_free()                              # optional - gap3
        True

        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1),Integer(2)], w)                 # optional - gap3
        >>> SC.is_double_root_free()                              # optional - gap3
        False

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
        >>> SC.is_double_root_free()
        True

  is_pure()

    Return `True` since all subword complexes are pure.

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',3])
        sage: w = W.from_reduced_word([2,3,2])
        sage: SC = SubwordComplex([3,2,3,2,3], w)
        sage: SC.is_pure()
        True

        sage: W = CoxeterGroup(['A',3])
        sage: w = W.from_reduced_word([2,3,2])
        sage: SC = SubwordComplex([3,2,3,2,3], w)
        sage: SC.is_pure()
        True

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(3)])
        >>> w = W.from_reduced_word([Integer(2),Integer(3),Integer(2)])
        >>> SC = SubwordComplex([Integer(3),Integer(2),Integer(3),Integer(2),Integer(3)], w)
        >>> SC.is_pure()
        True

        >>> W = CoxeterGroup(['A',Integer(3)])
        >>> w = W.from_reduced_word([Integer(2),Integer(3),Integer(2)])
        >>> SC = SubwordComplex([Integer(3),Integer(2),Integer(3),Integer(2),Integer(3)], w)
        >>> SC.is_pure()
        True

  is_root_independent()

    Return `True` if `self` is root-independent.

    This means that the root configuration of any (or equivalently all) facets is linearly independent.

    EXAMPLES:

    Sage

        sage: W = ReflectionGroup(['A',2])                          # optional - gap3
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)                # optional - gap3
        sage: SC.is_root_independent()                              # optional - gap3
        True

        sage: SC = SubwordComplex([1,2,1,2,1,2], W.w0)              # optional - gap3
        sage: SC.is_root_independent()                              # optional - gap3
        False

        sage: W = CoxeterGroup(['A',2])
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)
        sage: SC.is_root_independent()
        True

    Python

        >>> from sage.all import *
        >>> W = ReflectionGroup(['A',Integer(2)])                          # optional - gap3
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)                # optional - gap3
        >>> SC.is_root_independent()                              # optional - gap3
        True

        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1),Integer(2)], W.w0)              # optional - gap3
        >>> SC.is_root_independent()                              # optional - gap3
        False

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)
        >>> SC.is_root_independent()
        True

  is_sphere()

    Return `True` if the subword complex `self` is a sphere.

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',3])
        sage: w = W.from_reduced_word([2,3,2])
        sage: SC = SubwordComplex([3,2,3,2,3], w)
        sage: SC.is_sphere()
        True

        sage: SC = SubwordComplex([3,2,1,3,2,3], w)                 # optional - gap3
        sage: SC.is_sphere()                                        # optional - gap3
        False

        sage: W = CoxeterGroup(['A',3])
        sage: w = W.from_reduced_word([2,3,2])
        sage: SC = SubwordComplex([3,2,3,2,3], w)
        sage: SC.is_sphere()
        True

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(3)])
        >>> w = W.from_reduced_word([Integer(2),Integer(3),Integer(2)])
        >>> SC = SubwordComplex([Integer(3),Integer(2),Integer(3),Integer(2),Integer(3)], w)
        >>> SC.is_sphere()
        True

        >>> SC = SubwordComplex([Integer(3),Integer(2),Integer(1),Integer(3),Integer(2),Integer(3)], w)                 # optional - gap3
        >>> SC.is_sphere()                                        # optional - gap3
        False

        >>> W = CoxeterGroup(['A',Integer(3)])
        >>> w = W.from_reduced_word([Integer(2),Integer(3),Integer(2)])
        >>> SC = SubwordComplex([Integer(3),Integer(2),Integer(3),Integer(2),Integer(3)], w)
        >>> SC.is_sphere()
        True

  kappa_preimages()

    Return a dictionary containing facets of `self` as keys, and list of elements of `self.group()` as values.

    See also

    `kappa_preimage`

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1], w)
        sage: kappa = SC.kappa_preimages()
        sage: for F in SC: print("{} {}".format(F, [w.reduced_word() for w in kappa[F]]))
        (0, 1) [[]]
        (0, 4) [[2], [2, 1]]
        (1, 2) [[1]]
        (2, 3) [[1, 2]]
        (3, 4) [[1, 2, 1]]

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1], w)
        sage: kappa = SC.kappa_preimages()
        sage: for F in SC: print("{} {}".format(F, [w.reduced_word() for w in kappa[F]]))
        (0, 1) [[]]
        (0, 4) [[2], [2, 1]]
        (1, 2) [[1]]
        (2, 3) [[1, 2]]
        (3, 4) [[1, 2, 1]]

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
        >>> kappa = SC.kappa_preimages()
        >>> for F in SC: print("{} {}".format(F, [w.reduced_word() for w in kappa[F]]))
        (0, 1) [[]]
        (0, 4) [[2], [2, 1]]
        (1, 2) [[1]]
        (2, 3) [[1, 2]]
        (3, 4) [[1, 2, 1]]

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
        >>> kappa = SC.kappa_preimages()
        >>> for F in SC: print("{} {}".format(F, [w.reduced_word() for w in kappa[F]]))
        (0, 1) [[]]
        (0, 4) [[2], [2, 1]]
        (1, 2) [[1]]
        (2, 3) [[1, 2]]
        (3, 4) [[1, 2, 1]]

  minkowski_summand(i)

    Return the \(i\) th Minkowski summand of `self`.

    INPUT:

    - `i` – an integer defining a position in the word \(Q\)

    EXAMPLES:

    Sage

        sage: W = ReflectionGroup(['A',2])                          # optional - gap3
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)                # optional - gap3
        sage: SC.minkowski_summand(1)                               # optional - gap3
        A 0-dimensional polyhedron in QQ^2 defined as the convex hull of 1 vertex

        sage: W = CoxeterGroup(['A',2])
        sage: SC = SubwordComplex([1,2,1,2,1], W.w0)
        sage: SC.minkowski_summand(1)
        A 0-dimensional polyhedron in QQ^2 defined as the convex hull of 1 vertex

    Python

        >>> from sage.all import *
        >>> W = ReflectionGroup(['A',Integer(2)])                          # optional - gap3
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)                # optional - gap3
        >>> SC.minkowski_summand(Integer(1))                               # optional - gap3
        A 0-dimensional polyhedron in QQ^2 defined as the convex hull of 1 vertex

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], W.w0)
        >>> SC.minkowski_summand(Integer(1))
        A 0-dimensional polyhedron in QQ^2 defined as the convex hull of 1 vertex

  pi()

    Return the element in the Coxeter group associated to `self`.

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1], w)
        sage: SC.pi().reduced_word()
        [1, 2, 1]

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1], w)
        sage: SC.pi().reduced_word()
        [1, 2, 1]

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
        >>> SC.pi().reduced_word()
        [1, 2, 1]

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
        >>> SC.pi().reduced_word()
        [1, 2, 1]

  word()

    Return the word in the simple generators associated to `self`.

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1], w)
        sage: SC.word()
        (1, 2, 1, 2, 1)

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1], w)
        sage: SC.word()
        (1, 2, 1, 2, 1)

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
        >>> SC.word()
        (1, 2, 1, 2, 1)

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
        >>> SC.word()
        (1, 2, 1, 2, 1)

class sage.combinat.subword_complex.SubwordComplexFacet(parent, positions, facet_test=True)

  Bases: `Simplex`, `Element`

  A facet of a subword complex.

  Facets of the subword complex \(\mathcal{SC}(Q,w)\) are complements of sets of positions in \(Q\) defining a reduced expression for \(w\).

  EXAMPLES:

  Sage

      sage: # optional - gap3
      sage: W = ReflectionGroup(['A',2])
      sage: w = W.from_reduced_word([1,2,1])
      sage: SC = SubwordComplex([1,2,1,2,1], w)
      sage: F = SC[0]; F
      (0, 1)

      sage: W = CoxeterGroup(['A',2])
      sage: w = W.from_reduced_word([1,2,1])
      sage: SC = SubwordComplex([1,2,1,2,1], w)
      sage: F = SC[0]; F
      (0, 1)

  Python

      >>> from sage.all import *
      >>> # optional - gap3
      >>> W = ReflectionGroup(['A',Integer(2)])
      >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
      >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
      >>> F = SC[Integer(0)]; F
      (0, 1)

      >>> W = CoxeterGroup(['A',Integer(2)])
      >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
      >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)], w)
      >>> F = SC[Integer(0)]; F
      (0, 1)

  brick_vector(coefficients=None)

    Return the brick vector of `self`.

    This is the sum of the weight vectors in the extended weight configuration.

    INPUT:

    - `coefficients` – (optional) a list of coefficients used to scale the fundamental weights

    See also

    `extended_weight_configuration()`

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)
        sage: F = SC([1,2]); F
        (1, 2)
        sage: F.extended_weight_configuration()
        [(2/3, 1/3), (1/3, 2/3), (-1/3, 1/3), (1/3, 2/3), (-1/3, 1/3)]
        sage: F.brick_vector()
        (2/3, 7/3)
        sage: F.brick_vector(coefficients=[1,2])
        (4/3, 11/3)

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)
        sage: F = SC([1,2])
        sage: F.brick_vector()
        (4/3, 14/3)
        sage: F.brick_vector(coefficients=[1,2])
        (8/3, 22/3)

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(1),Integer(2)]); F
        (1, 2)
        >>> F.extended_weight_configuration()
        [(2/3, 1/3), (1/3, 2/3), (-1/3, 1/3), (1/3, 2/3), (-1/3, 1/3)]
        >>> F.brick_vector()
        (2/3, 7/3)
        >>> F.brick_vector(coefficients=[Integer(1),Integer(2)])
        (4/3, 11/3)

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(1),Integer(2)])
        >>> F.brick_vector()
        (4/3, 14/3)
        >>> F.brick_vector(coefficients=[Integer(1),Integer(2)])
        (8/3, 22/3)

  extended_root_configuration()

    Return the extended root configuration of `self`.

    Let \(Q = q_1 \dots q_m \in S^*\) and \(w \in W\). The extended root configuration of a facet \(I\) of \(\mathcal{SC}(Q,w)\) is the sequence \(\mathsf{r}(I, 1), \dots, \mathsf{r}(I, m)\) of roots defined by \(\mathsf{r}(I, k) = \Pi Q_{[k-1] \smallsetminus I} (\alpha_{q_k})\), where \(\Pi Q_{[k-1] \smallsetminus I}\) is the product of the simple reflections \(q_i\) for \(i \in [k-1] \smallsetminus I\) in this order.

    The extended root configuration is used to perform flips efficiently.

    See also

    `flip()`

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)
        sage: F = SC([1,2]); F
        (1, 2)
        sage: F.extended_root_configuration()
        [(1, 0), (1, 1), (-1, 0), (1, 1), (0, 1)]

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)
        sage: F = SC([1,2]); F
        (1, 2)
        sage: F.extended_root_configuration()
        [(1, 0), (1, 1), (-1, 0), (1, 1), (0, 1)]

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(1),Integer(2)]); F
        (1, 2)
        >>> F.extended_root_configuration()
        [(1, 0), (1, 1), (-1, 0), (1, 1), (0, 1)]

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(1),Integer(2)]); F
        (1, 2)
        >>> F.extended_root_configuration()
        [(1, 0), (1, 1), (-1, 0), (1, 1), (0, 1)]

  extended_weight_configuration(coefficients=None)

    Return the extended weight configuration of `self`.

    Let \(Q = q_1 \dots q_m \in S^*\) and \(w \in W\). The extended weight configuration of a facet \(I\) of \(\mathcal{SC}(Q,w)\) is the sequence \(\mathsf{w}(I, 1), \dots, \mathsf{w}(I, m)\) of weights defined by \(\mathsf{w}(I, k) = \Pi Q_{[k-1] \smallsetminus I} (\omega_{q_k})\), where \(\Pi Q_{[k-1] \smallsetminus I}\) is the product of the simple reflections \(q_i\) for \(i \in [k-1] \smallsetminus I\) in this order.

    The extended weight configuration is used to compute the brick vector.

    INPUT:

    - `coefficients` – (optional) a list of coefficients used to scale the fundamental weights

    See also

    `brick_vector()`

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)
        sage: F = SC([1,2])
        sage: F.extended_weight_configuration()
        [(2/3, 1/3), (1/3, 2/3), (-1/3, 1/3), (1/3, 2/3), (-1/3, 1/3)]
        sage: F.extended_weight_configuration(coefficients=(1,2))
        [(2/3, 1/3), (2/3, 4/3), (-1/3, 1/3), (2/3, 4/3), (-1/3, 1/3)]

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)
        sage: F = SC([1,2])
        sage: F.extended_weight_configuration()
        [(4/3, 2/3), (2/3, 4/3), (-2/3, 2/3), (2/3, 4/3), (-2/3, 2/3)]
        sage: F.extended_weight_configuration(coefficients=(1,2))
        [(4/3, 2/3), (4/3, 8/3), (-2/3, 2/3), (4/3, 8/3), (-2/3, 2/3)]

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(1),Integer(2)])
        >>> F.extended_weight_configuration()
        [(2/3, 1/3), (1/3, 2/3), (-1/3, 1/3), (1/3, 2/3), (-1/3, 1/3)]
        >>> F.extended_weight_configuration(coefficients=(Integer(1),Integer(2)))
        [(2/3, 1/3), (2/3, 4/3), (-1/3, 1/3), (2/3, 4/3), (-1/3, 1/3)]

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(1),Integer(2)])
        >>> F.extended_weight_configuration()
        [(4/3, 2/3), (2/3, 4/3), (-2/3, 2/3), (2/3, 4/3), (-2/3, 2/3)]
        >>> F.extended_weight_configuration(coefficients=(Integer(1),Integer(2)))
        [(4/3, 2/3), (4/3, 8/3), (-2/3, 2/3), (4/3, 8/3), (-2/3, 2/3)]

  flip(i, return_position=False)

    Return the facet obtained after flipping position `i` in `self`.

    INPUT:

    - `i` – integer; position in the word \(Q\)

    - `return_position` – boolean (default: `False`); tells whether the new position should be returned as well

    OUTPUT:

    - The new subword complex facet.

    - The new position if `return_position` is `True`.

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)
        sage: F = SC([1,2]); F
        (1, 2)
        sage: F.flip(1)
        (2, 3)
        sage: F.flip(1, return_position=True)
        ((2, 3), 3)

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)
        sage: F = SC([1,2]); F
        (1, 2)
        sage: F.flip(1)
        (2, 3)
        sage: F.flip(1, return_position=True)
        ((2, 3), 3)

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(1),Integer(2)]); F
        (1, 2)
        >>> F.flip(Integer(1))
        (2, 3)
        >>> F.flip(Integer(1), return_position=True)
        ((2, 3), 3)

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(1),Integer(2)]); F
        (1, 2)
        >>> F.flip(Integer(1))
        (2, 3)
        >>> F.flip(Integer(1), return_position=True)
        ((2, 3), 3)

  is_vertex()

    Return `True` if `self` is a vertex of the brick polytope of `self.parent`.

    A facet is a vertex of the brick polytope if its root cone is pointed. Note that this property is always satisfied for root-independent subword complexes.

    See also

    `root_cone()`

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',1])
        sage: w = W.from_reduced_word([1])
        sage: SC = SubwordComplex([1,1,1],w)
        sage: F = SC([0,1]); F.is_vertex()
        True
        sage: F = SC([0,2]); F.is_vertex()
        False

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1,2,1],w)
        sage: F = SC([0,1,2,3]); F.is_vertex()
        True
        sage: F = SC([0,1,2,6]); F.is_vertex()
        False

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1,2,1],w)
        sage: F = SC([0,1,2,3]); F.is_vertex()
        True
        sage: F = SC([0,1,2,6]); F.is_vertex()
        False

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(1)])
        >>> w = W.from_reduced_word([Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(1),Integer(1)],w)
        >>> F = SC([Integer(0),Integer(1)]); F.is_vertex()
        True
        >>> F = SC([Integer(0),Integer(2)]); F.is_vertex()
        False

        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(0),Integer(1),Integer(2),Integer(3)]); F.is_vertex()
        True
        >>> F = SC([Integer(0),Integer(1),Integer(2),Integer(6)]); F.is_vertex()
        False

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(0),Integer(1),Integer(2),Integer(3)]); F.is_vertex()
        True
        >>> F = SC([Integer(0),Integer(1),Integer(2),Integer(6)]); F.is_vertex()
        False

  kappa_preimage()

    Return the fiber of `self` under the \(\kappa\) map.

    The \(\kappa\) map sends an element \(w \in W\) to the unique facet of \(I \in \mathcal{SC}(Q,w)\) such that the root configuration of \(I\) is contained in \(w(\Phi^+)\). In other words, \(w\) is in the preimage of `self` under \(\kappa\) if and only if \(w^{-1}\) sends every root in the root configuration to a positive root.

    EXAMPLES:

    Sage

        sage: W = ReflectionGroup(['A',2])                          # optional - gap3
        sage: w = W.from_reduced_word([1,2,1])                      # optional - gap3
        sage: SC = SubwordComplex([1,2,1,2,1],w)                    # optional - gap3

        sage: F = SC([1,2]); F                                      # optional - gap3
        (1, 2)
        sage: F.kappa_preimage()                                    # optional - gap3
        [(1,4)(2,3)(5,6)]

        sage: F = SC([0,4]); F                                      # optional - gap3
        (0, 4)
        sage: F.kappa_preimage()                                    # optional - gap3
        [(1,3)(2,5)(4,6), (1,2,6)(3,4,5)]

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)

        sage: F = SC([1,2]); F
        (1, 2)
        sage: F.kappa_preimage()
        [
        [-1  1]
        [ 0  1]
        ]

        sage: F = SC([0,4]); F
        (0, 4)
        sage: F.kappa_preimage()
        [
        [ 1  0]  [-1  1]
        [ 1 -1], [-1  0]
        ]

    Python

        >>> from sage.all import *
        >>> W = ReflectionGroup(['A',Integer(2)])                          # optional - gap3
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])                      # optional - gap3
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)                    # optional - gap3

        >>> F = SC([Integer(1),Integer(2)]); F                                      # optional - gap3
        (1, 2)
        >>> F.kappa_preimage()                                    # optional - gap3
        [(1,4)(2,3)(5,6)]

        >>> F = SC([Integer(0),Integer(4)]); F                                      # optional - gap3
        (0, 4)
        >>> F.kappa_preimage()                                    # optional - gap3
        [(1,3)(2,5)(4,6), (1,2,6)(3,4,5)]

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)

        >>> F = SC([Integer(1),Integer(2)]); F
        (1, 2)
        >>> F.kappa_preimage()
        [
        [-1  1]
        [ 0  1]
        ]

        >>> F = SC([Integer(0),Integer(4)]); F
        (0, 4)
        >>> F.kappa_preimage()
        [
        [ 1  0]  [-1  1]
        [ 1 -1], [-1  0]
        ]

  plot(list_colors=None, labels=[], thickness=3, fontsize=14, shift=(0, 0), compact=False, roots=True, **args)

    In type \(A\) or \(B\), plot a pseudoline arrangement representing the facet `self`.

    Pseudoline arrangements are graphical representations of facets of types A or B subword complexes.

    INPUT:

    - `list_colors` – list (default: `[]`); to change the colors of the pseudolines

    - `labels` – list (default: `[]`); to change the labels of the pseudolines

    - `thickness` – integer (default: 3); for the thickness of the pseudolines

    - `fontsize` – integer (default: 14); for the size of the font used for labels

    - `shift` – couple of coordinates (default: `(0,0)`) to change the origin

    - `compact` – boolean (default: `False`); to require a more compact representation

    - `roots` – boolean (default: `True`); whether to print the extended root configuration

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)
        sage: F = SC([1,2]); F.plot()                                               # needs sage.plot
        Graphics object consisting of 26 graphics primitives

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)
        sage: F = SC([1,2]); F.plot()                                               # needs sage.plot
        Graphics object consisting of 26 graphics primitives

        sage: # optional - gap3
        sage: W = ReflectionGroup(['B',3])
        sage: c = W.from_reduced_word([1,2,3])
        sage: Q = c.reduced_word()*2 + W.w0.coxeter_sorting_word(c)
        sage: SC = SubwordComplex(Q, W.w0)
        sage: F = SC[15]; F.plot()                                                  # needs sage.plot
        Graphics object consisting of 53 graphics primitives

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(1),Integer(2)]); F.plot()                                               # needs sage.plot
        Graphics object consisting of 26 graphics primitives

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(1),Integer(2)]); F.plot()                                               # needs sage.plot
        Graphics object consisting of 26 graphics primitives

        >>> # optional - gap3
        >>> W = ReflectionGroup(['B',Integer(3)])
        >>> c = W.from_reduced_word([Integer(1),Integer(2),Integer(3)])
        >>> Q = c.reduced_word()*Integer(2) + W.w0.coxeter_sorting_word(c)
        >>> SC = SubwordComplex(Q, W.w0)
        >>> F = SC[Integer(15)]; F.plot()                                                  # needs sage.plot
        Graphics object consisting of 53 graphics primitives

    REFERENCES: [PilStu]

  root_cone()

    Return the polyhedral cone generated by the root configuration of `self`.

    See also

    `root_configuration()`

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',1])
        sage: w = W.from_reduced_word([1])
        sage: SC = SubwordComplex([1,1,1],w)
        sage: F = SC([0,2]); F.root_cone()
        1-d cone in 1-d lattice N

        sage: W = CoxeterGroup(['A',1])
        sage: w = W.from_reduced_word([1])
        sage: SC = SubwordComplex([1,1,1],w)
        sage: F = SC([0,2]); F.root_cone()
        1-d cone in 1-d lattice N

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(1)])
        >>> w = W.from_reduced_word([Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(1),Integer(1)],w)
        >>> F = SC([Integer(0),Integer(2)]); F.root_cone()
        1-d cone in 1-d lattice N

        >>> W = CoxeterGroup(['A',Integer(1)])
        >>> w = W.from_reduced_word([Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(1),Integer(1)],w)
        >>> F = SC([Integer(0),Integer(2)]); F.root_cone()
        1-d cone in 1-d lattice N

  root_configuration()

    Return the root configuration of `self`.

    Let \(Q = q_1 \dots q_m \in S^*\) and \(w \in W\). The root configuration of a facet \(I = [i_1, \dots, i_n]\) of \(\mathcal{SC}(Q,w)\) is the sequence \(\mathsf{r}(I, i_1), \dots, \mathsf{r}(I, i_n)\) of roots defined by \(\mathsf{r}(I, k) = \Pi Q_{[k-1] \smallsetminus I} (\alpha_{q_k})\), where \(\Pi Q_{[k-1] \smallsetminus I}\) is the product of the simple reflections \(q_i\) for \(i \in [k-1] \smallsetminus I\) in this order.

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)
        sage: F = SC([1,2]); F
        (1, 2)
        sage: F.root_configuration()
        [(1, 1), (-1, 0)]

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)
        sage: F = SC([1,2]); F
        (1, 2)
        sage: F.root_configuration()                                # optional - gap3
        [(1, 1), (-1, 0)]

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(1),Integer(2)]); F
        (1, 2)
        >>> F.root_configuration()
        [(1, 1), (-1, 0)]

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(1),Integer(2)]); F
        (1, 2)
        >>> F.root_configuration()                                # optional - gap3
        [(1, 1), (-1, 0)]

  show(*kwds, **args)

    Show the facet `self`.

    See also

    `plot()`

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)
        sage: F = SC([1,2]); F.show()

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(1),Integer(2)]); F.show()
        <BLANKLINE>

  upper_root_configuration()

    Return the positive roots of the root configuration of `self`.

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)
        sage: F = SC([1,2]); F
        (1, 2)
        sage: F.root_configuration()
        [(1, 1), (-1, 0)]
        sage: F.upper_root_configuration()
        [(1, 0)]

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)
        sage: F = SC([1,2]); F
        (1, 2)
        sage: F.upper_root_configuration()
        [(1, 0)]

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(1),Integer(2)]); F
        (1, 2)
        >>> F.root_configuration()
        [(1, 1), (-1, 0)]
        >>> F.upper_root_configuration()
        [(1, 0)]

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(1),Integer(2)]); F
        (1, 2)
        >>> F.upper_root_configuration()
        [(1, 0)]

  weight_cone()

    Return the polyhedral cone generated by the weight configuration of `self`.

    See also

    `weight_configuration()`

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)
        sage: F = SC([1,2]); F
        (1, 2)
        sage: WC = F.weight_cone(); WC
        2-d cone in 2-d lattice N
        sage: WC.rays()
        N( 1, 2),
        N(-1, 1)
        in 2-d lattice N

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)
        sage: F = SC([1,2]); F
        (1, 2)
        sage: WC = F.weight_cone(); WC
        2-d cone in 2-d lattice N

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(1),Integer(2)]); F
        (1, 2)
        >>> WC = F.weight_cone(); WC
        2-d cone in 2-d lattice N
        >>> WC.rays()
        N( 1, 2),
        N(-1, 1)
        in 2-d lattice N

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(1),Integer(2)]); F
        (1, 2)
        >>> WC = F.weight_cone(); WC
        2-d cone in 2-d lattice N

  weight_configuration()

    Return the weight configuration of `self`.

    Let \(Q = q_1 \dots q_m \in S^*\) and \(w \in W\). The weight configuration of a facet \(I = [i_1, \dots, i_n]\) of \(\mathcal{SC}(Q,w)\) is the sequence \(\mathsf{w}(I, i_1), \dots, \mathsf{w}(I, i_n)\) of weights defined by \(\mathsf{w}(I, k) = \Pi Q_{[k-1] \smallsetminus I} (\omega_{q_k})\), where \(\Pi Q_{[k-1] \smallsetminus I}\) is the product of the simple reflections \(q_i\) for \(i \in [k-1] \smallsetminus I\) in this order.

    EXAMPLES:

    Sage

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)
        sage: F = SC([1,2]); F
        (1, 2)
        sage: F.weight_configuration()
        [(1/3, 2/3), (-1/3, 1/3)]

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC = SubwordComplex([1,2,1,2,1],w)
        sage: F = SC([1,2]); F
        (1, 2)
        sage: F.weight_configuration()
        [(2/3, 4/3), (-2/3, 2/3)]

    Python

        >>> from sage.all import *
        >>> # optional - gap3
        >>> W = ReflectionGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(1),Integer(2)]); F
        (1, 2)
        >>> F.weight_configuration()
        [(1/3, 2/3), (-1/3, 1/3)]

        >>> W = CoxeterGroup(['A',Integer(2)])
        >>> w = W.from_reduced_word([Integer(1),Integer(2),Integer(1)])
        >>> SC = SubwordComplex([Integer(1),Integer(2),Integer(1),Integer(2),Integer(1)],w)
        >>> F = SC([Integer(1),Integer(2)]); F
        (1, 2)
        >>> F.weight_configuration()
        [(2/3, 4/3), (-2/3, 2/3)]