# sage_setup: distribution = sagemath-combinat
# sage.doctest: needs sage.combinat sage.graphs sage.modules
r"""
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 :class:`ReflectionGroup`, it works as well
with :class:`CoxeterGroup`, but many methods fail for :class:`WeylGroup`.

EXAMPLES::

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

Testing that the implementation also works with CoxeterGroup::

    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

The root configuration works::

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

And the weight configuration also works::

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

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

    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

AUTHORS:

- Christian Stump: initial version
- Vincent Pilaud: greedy flip algorithm, minor improvements, documentation

REFERENCES:

.. [KnuMil] Knutson and Miller. *Subword complexes in Coxeter groups*. Adv. Math., 184(1):161-176, 2004.
.. [PilStu] Pilaud and Stump. *Brick polytopes of spherical subword complexes and generalized associahedra*. Adv. Math. 276:1-61, 2015.
"""
# ****************************************************************************
#       Copyright (C) 2015      Christian Stump <christian.stump@gmail.com>
#
#  Distributed under the terms of the GNU General Public License (GPL)
#  The full text of the GPL is available at:
#
#                  https://www.gnu.org/licenses/
# ****************************************************************************
from itertools import repeat
from copy import copy
from sage.misc.cachefunc import cached_method
from sage.misc.lazy_import import lazy_import
from sage.structure.element import Element
from sage.structure.unique_representation import UniqueRepresentation
from sage.topology.simplicial_complex import SimplicialComplex, Simplex
from sage.categories.simplicial_complexes import SimplicialComplexes
from sage.combinat.subword_complex_c import _flip_c, _construct_facets_c

lazy_import('sage.geometry.polyhedron.constructor', 'Polyhedron')
lazy_import('sage.geometry.cone', 'Cone')


class SubwordComplexFacet(Simplex, Element):
    r"""
    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: # 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)

    TESTS::

        sage: type(F)                                                   # optional - gap3
        <class 'sage.combinat.subword_complex.SubwordComplex_with_category.element_class'>
    """

    # standard functions

    def __init__(self, parent, positions, facet_test=True):
        r"""
        Initialize a facet of the subword complex ``parent``.

        EXAMPLES::

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

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

        TESTS::

            sage: W = ReflectionGroup(['A',2])                          # optional - gap3
            sage: SC = SubwordComplex([1,2,1,2,1], W.w0)                # optional - gap3
            sage: SC([1,3])                                             # optional - gap3
            Traceback (most recent call last):
            ...
            ValueError: the given iterable [1, 3] is not a facet of the Subword complex of type ['A', 2] for Q = (1, 2, 1, 2, 1) and pi = [1, 2, 1]

            sage: W = ReflectionGroup(['A',2])                          # optional - gap3
            sage: SC = SubwordComplex([1,2,1,2,1], W.w0)                # optional - gap3
            sage: TestSuite(SC).run()                                   # optional - gap3
        """
        if facet_test and positions not in parent:
            raise ValueError("the given iterable %s is not a facet of the %s" % (positions, parent))
        Simplex.__init__(self, sorted(positions))
        Element.__init__(self, parent)
        self._extended_root_conf_indices = None
        self._extended_weight_conf = None

    # roots

    def _extended_root_configuration_indices(self):
        r"""
        Return the indices of the roots in ``self.group().roots()`` of
        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.

        .. SEEALSO::

            :meth:`extended_root_configuration`

        EXAMPLES::

            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_indices()
            [0, 2, 3, 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: F = SC([1,2]); F
            (1, 2)
            sage: F._extended_root_configuration_indices()
            [0, 1, 3, 1, 2]
        """
        if self._extended_root_conf_indices is None:
            self._extended_root_conf_indices = _extended_root_configuration_indices(self.parent().group(), self.parent().word(), self)
        return self._extended_root_conf_indices

    def _root_configuration_indices(self):
        r"""
        Return the indices of the roots in ``self.group().roots()`` of
        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.

        .. SEEALSO::

            :meth:`root_configuration`

        EXAMPLES::

            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_indices()
            [2, 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._root_configuration_indices()                       # optional - gap3
            [1, 3]
        """
        indices = self._extended_root_configuration_indices()
        return [indices[i] for i in self]

    def extended_root_configuration(self):
        r"""
        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.

        .. SEEALSO::

            :meth:`flip`

        EXAMPLES::

            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)]
        """
        Phi = self.parent().group().roots()
        return [Phi[i] for i in self._extended_root_configuration_indices()]

    def root_configuration(self):
        r"""
        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: # 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)]
        """
        Phi = self.parent().group().roots()
        return [Phi[i] for i in self._root_configuration_indices()]

    def kappa_preimage(self):
        r"""
        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: 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]
            ]
        """
        W = self.parent().group()
        N = len(W.long_element(as_word=True))
        root_conf = self._root_configuration_indices()
        return [~w for w in W
                if all(w.action_on_root_indices(i, side='left') < N
                       for i in root_conf)]

    def is_vertex(self):
        r"""
        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.

        .. SEEALSO::

            :meth:`root_cone`

        EXAMPLES::

            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
        """
        S = self.parent()
        if S.is_root_independent():
            return True
        return self.root_cone().is_strictly_convex()

    @cached_method
    def root_cone(self):
        r"""
        Return the polyhedral cone generated by the root configuration
        of ``self``.

        .. SEEALSO::

            :meth:`root_configuration`

        EXAMPLES::

            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
        """
        return Cone(self.root_configuration())

    def upper_root_configuration(self):
        r"""
        Return the positive roots of the root configuration of ``self``.

        EXAMPLES::

            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)]
        """
        conf = self._root_configuration_indices()
        W = self.parent().group()
        Phi = W.roots()
        N = len(Phi) // 2
        return [Phi[i - N] for i in conf if i >= N]

    # weights

    def extended_weight_configuration(self, coefficients=None):
        r"""
        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

        .. SEEALSO::

            :meth:`brick_vector`

        EXAMPLES::

            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)]
        """
        if coefficients is not None or self._extended_weight_conf is None:
            W = self.parent().group()
            I = W.index_set()
            Lambda = W.fundamental_weights()
            if coefficients is not None:
                coeff = {I[i]: coefficients[i]
                         for i in range(len(coefficients))}
                Lambda = {li: coeff[li] * Lambda[li] for li in Lambda.keys()}
            Q = self.parent().word()
            V_weights = []
            pi = W.one()
            for i, wi in enumerate(Q):
                fund_weight = Lambda[wi]
                V_weights.append(pi * fund_weight)
                if i not in self:
                    pi = pi.apply_simple_reflection_right(wi)
            if self._extended_weight_conf is None:
                self._extended_weight_conf = V_weights
            return V_weights
        else:
            return self._extended_weight_conf

    def weight_configuration(self):
        r"""
        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: # 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)]
        """
        extended_configuration = self.extended_weight_configuration()
        return [extended_configuration[i] for i in self]

    @cached_method
    def weight_cone(self):
        r"""
        Return the polyhedral cone generated by the weight
        configuration of ``self``.

        .. SEEALSO::

            :meth:`weight_configuration`

        EXAMPLES::

            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
        """
        return Cone(self.weight_configuration())

    def brick_vector(self, coefficients=None):
        r"""
        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

        .. SEEALSO::

            :meth:`extended_weight_configuration`

        EXAMPLES::

            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)
        """
        return sum(self.extended_weight_configuration(coefficients=coefficients))

    # flip

    def flip(self, i, return_position=False):
        r"""
        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: # 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)
        """
        S = self.parent()
        F = set(self)
        R = list(self._extended_root_configuration_indices())
        j = _flip_c(self.parent().group(), F, R, i)  # F and R are changed here
        new_facet = S.element_class(self.parent(), F)
        new_facet._extended_root_conf_indices = tuple(R)
        if return_position:
            return new_facet, j
        else:
            return new_facet

    # plot and show

    def plot(self, list_colors=None, labels=[], thickness=3, fontsize=14,
             shift=(0, 0), compact=False, roots=True, **args):
        r"""
        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: # 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

        TESTS::

            sage: # optional - gap3
            sage: W = ReflectionGroup(['D',4])
            sage: c = W.from_reduced_word([1,2,3,4])
            sage: Q = c.reduced_word() + W.w0.coxeter_sorting_word(c)
            sage: SC = SubwordComplex(Q, W.w0)
            sage: F = SC[1]; F.plot()                                                   # needs sage.plot
            Traceback (most recent call last):
            ...
            ValueError: plotting is currently only implemented for irreducibles types A, B, and C.

            sage: W = CoxeterGroup(CoxeterMatrix((['A',2],['A',2])))
            sage: c = W.from_reduced_word([1,2,3,4])
            sage: Q = c.reduced_word() + W.w0.coxeter_sorting_word(c)
            sage: SC = SubwordComplex(Q, W.w0)
            sage: F = SC[1]; F.plot()                                                   # needs sage.plot
            Traceback (most recent call last):
            ...
            ValueError: plotting is currently only implemented for irreducibles types A, B, and C.

        REFERENCES: [PilStu]_
        """
        # check that the type is A or B
        # TODO in a better way
        S = self.parent()
        Q = S.word()
        W = S.group()
        n = W.rank()

        error_msg = "plotting is currently only implemented for irreducibles types A, B, and C."
        if S._cartan_type is not None:
            cartan_type = S._cartan_type
            type = cartan_type.type()
            G = cartan_type.coxeter_matrix().coxeter_graph()
        else:
            type = None

        if type not in ['A', 'B', 'C'] or not G.is_connected():
            raise ValueError(error_msg)

        # organization of the indexing
        # TODO: this might be better done in CoxeterType directly.
        index_set = None
        for a in G.vertex_iterator():
            if G.degree(a) == 1:
                b = G.neighbors(a)[0]
                if type == "A" or G.edge_label(a, b) == 4:
                    index_set = [a, b]
                    break
        assert index_set is not None, "Bug in the plot method"
        while G.degree(b) == 2:
            for c in G.neighbors(b):
                # picking the other neighbors of b
                if c != a:
                    index_set.append(c)
                    a = b
                    b = c
                    break

        # import plot facilities
        from sage.plot.line import line
        from sage.plot.text import text
        from sage.plot.colors import colors
        from sage.combinat.permutation import Permutation

        # get properties
        if type == 'A':
            last = n
        else:
            last = n - 1
        permutation = Permutation(range(1, last + 2))
        x_max = .5

        # list the pseudolines to be drawn
        pseudolines = [[(shift[0], shift[1] + i), .5] for i in range(last + 1)]
        pseudolines_type_B = [[] for _ in repeat(None, last + 1)]
        contact_points = []
        root_labels = []
        pseudoline_labels = []
        if labels is not False:
            pseudoline_labels += [(pseudoline,
                                   (shift[0] - .1, shift[1] + pseudoline),
                                   "center") for pseudoline in range(last + 1)]
        if roots:
            extended_root_conf = self.extended_root_configuration()
        for position in range(len(Q)):
            y = index_set.index(Q[position])
            if type in ['B', 'C'] and y == 0:
                pseudoline = permutation(1) - 1
                x = pseudolines[pseudoline].pop()
                if compact:
                    x_max = max(x + 1, x_max)
                else:
                    x = x_max
                    x_max += 1
                if position in self:
                    pseudolines[pseudoline] += [(shift[0] + x + 1,
                                                 shift[1]), x + 1]
                    contact_points += [[(shift[0] + x + .5, shift[1] - .2),
                                        (shift[0] + x + .5, shift[1])]]
                else:
                    pseudolines_type_B[pseudoline] = pseudolines[pseudoline] + [(shift[0] + x + .5, shift[1]), (shift[0] + x + .5, shift[1] - .2)]
                    pseudolines[pseudoline] = [(shift[0] + x + .6, shift[1] - .2), (shift[0] + x + .6, shift[1]), .5]
                if roots:
                    root_labels.append((extended_root_conf[position],
                                        (shift[0] + x + .25, shift[1] - .2)))
            else:
                if type in ['B', 'C']:
                    y -= 1
                pseudoline1 = permutation(y + 1) - 1
                pseudoline2 = permutation(y + 2) - 1
                x = max(pseudolines[pseudoline1].pop(),
                        pseudolines[pseudoline2].pop())
                if compact:
                    x_max = max(x + 1, x_max)
                else:
                    x = x_max
                    x_max += 1
                if position in self:
                    pseudolines[pseudoline1] += [(shift[0] + x + 1,
                                                  shift[1] + y), x + 1]
                    pseudolines[pseudoline2] += [(shift[0] + x + 1,
                                                  shift[1] + y + 1), x + 1]
                    contact_points += [[(shift[0] + x + .5, shift[1] + y),
                                        (shift[0] + x + .5, shift[1] + y + 1)]]
                else:
                    pseudolines[pseudoline1] += [(shift[0] + x + .6,
                                                  shift[1] + y),
                                                 (shift[0] + x + .6,
                                                  shift[1] + y + 1), x + 1]
                    pseudolines[pseudoline2] += [(shift[0] + x + .5,
                                                  shift[1] + y + 1),
                                                 (shift[0] + x + .5,
                                                  shift[1] + y), x + 1]
                    permutation = permutation._left_to_right_multiply_on_left(Permutation((y + 1, y + 2)))
                if roots:
                    root_labels.append((extended_root_conf[position],
                                        (shift[0] + x + .35,
                                         shift[1] + y + .5)))
                if labels is not False:
                    pseudoline_labels += [(pseudoline1, (shift[0] + x + .35,
                                                         shift[1] + y + .05),
                                           "bottom"),
                                          (pseudoline2, (shift[0] + x + .35,
                                                         shift[1] + y + .95),
                                           "top")]

        # transform list to real lines
        if list_colors is None:
            list_colors = []
        list_colors += ['red', 'blue', 'green', 'orange', 'yellow', 'purple']
        list_colors += list(colors)
        thickness = max(thickness, 2)
        L = line([(1, 1)])
        for contact_point in contact_points:
            L += line(contact_point, rgbcolor=[0, 0, 0],
                      thickness=thickness - 1)
        for pseudoline in range(last + 1):
            pseudolines[pseudoline].pop()
            pseudolines[pseudoline].append((shift[0] + x_max,
                                            shift[1] + permutation.inverse()(pseudoline + 1) - 1))
            L += line(pseudolines[pseudoline], color=list_colors[pseudoline],
                      thickness=thickness)
            if type in ['B', 'C']:
                L += line(pseudolines_type_B[pseudoline],
                          color=list_colors[pseudoline],
                          thickness=thickness, linestyle='--')
        for root_label in root_labels:
            L += text(root_label[0], root_label[1], rgbcolor=[0, 0, 0],
                      fontsize=fontsize, vertical_alignment='center',
                      horizontal_alignment='right')
        if len(labels) < last + 1:
            labels = list(range(1, last + 2))
        for pseudoline_label in pseudoline_labels:
            L += text(labels[pseudoline_label[0]], pseudoline_label[1],
                      color=list_colors[pseudoline_label[0]],
                      fontsize=fontsize,
                      vertical_alignment=pseudoline_label[2],
                      horizontal_alignment='right')
        if labels is not False:
            for pseudoline in range(last):
                L += text(labels[pseudoline],
                          (shift[0] + x_max + .1,
                           shift[1] + permutation.inverse()(pseudoline + 1) - 1),
                          color=list_colors[pseudoline], fontsize=fontsize,
                          vertical_alignment='center',
                          horizontal_alignment='left')
        L.axes(False)
        return L

    def show(self, *kwds, **args):
        """
        Show the facet ``self``.

        .. SEEALSO::

            :meth:`plot`

        EXAMPLES::

            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()
            <BLANKLINE>
        """
        return self.plot().show(*kwds, **args)


class SubwordComplex(UniqueRepresentation, SimplicialComplex):
    r"""
    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: # 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)]

    REFERENCES: [KnuMil]_, [PilStu]_

    TESTS::

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

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: SC1 = SubwordComplex([1,2,1,2,1], w)
        sage: SC2 = SubwordComplex([1,2,1,2,1], w)
        sage: SC1 == SC2
        True
    """

    # standard functions

    @staticmethod
    def __classcall__(cls, Q, w, algorithm='inductive'):
        r"""
        Making the input hashable.

        TESTS::

            sage: # optional - gap3
            sage: W = ReflectionGroup(['B',2])
            sage: S = SubwordComplex((1,2)*3,W.w0)
            sage: T = SubwordComplex([1,2]*3,W.w0)
            sage: S is T
            True

            sage: W = CoxeterGroup(['B',2])
            sage: S = SubwordComplex((1,2)*3,W.w0)
            sage: T = SubwordComplex([1,2]*3,W.w0)
            sage: S is T
            True
        """
        Q = tuple(Q)
        return super().__classcall__(cls, Q, w, algorithm=algorithm)

    def __init__(self, Q, w, algorithm='inductive'):
        r"""
        Initialize the subword complex `\mathcal{SC}(Q,w)`.

        INPUT:

        - ``Q`` -- word on the simple generators of the Coxeter group
        - ``w`` -- element of the Coxeter group
        - ``algorithm`` -- (default: ``'inductive'``) choice of the
          algorithm to generate the subword complex. Options are
          ``'inductive'`` or ``'greedy'``. The second option is
          recommended when `|Q|` is closed to `\ell(w) + \mathrm{rank}(W)`.

        EXAMPLES::

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

            sage: W = CoxeterGroup(['A',3])
            sage: w = W.from_reduced_word([1,2,3,1,2,1])
            sage: SC = SubwordComplex([1,2,3,1,2,3,1,2,1], w); SC
            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: len(SC)
            14

        TESTS:

        Check for methods from the enumerated sets category::

            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: list(SC)
            [(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: list(SC)
            [(0, 1), (0, 4), (1, 2), (2, 3), (3, 4)]

            sage: W = CoxeterGroup(['A',2])
            sage: w = W.from_reduced_word([1,1,1])
            sage: SC = SubwordComplex([1,2,2,2,1], w)
            sage: len(SC)
            2
        """
        W = w.parent()
        I = W.index_set()
        if not all(i in I for i in Q):
            raise ValueError("all elements in Q = %s must be contained in the index set %s" % (Q, I))
        self._Q = Q
        self._pi = w
        if algorithm == "inductive":
            Fs = _construct_facets_c(Q, w)
        elif algorithm == "greedy":
            Fs, Rs = _greedy_flip_algorithm(Q, w)
        else:
            raise ValueError("the optional argument algorithm can be "
                             "either inductive or greedy")
        if not Fs:
            raise ValueError("the word %s does not contain a reduced expression for %s" % (Q, w.reduced_word()))
        cat = SimplicialComplexes().Finite().Enumerated()
        SimplicialComplex.__init__(self, maximal_faces=Fs,
                                   maximality_check=False,
                                   category=cat)
        self._W = W
        try:
            T = W.coxeter_matrix().coxeter_type()
            self._cartan_type = T.cartan_type()
        except AttributeError:
            self._cartan_type = None
        self._facets_dict = None
        if algorithm == "greedy":
            _facets_dict = {}
            for i in range(len(Fs)):
                X = self(Fs[i], facet_test=False)
                X._extended_root_conf_indices = Rs[i]
                _facets_dict[tuple(sorted(Fs[i]))] = X
            self._facets_dict = _facets_dict
        else:
            self._facets_dict = {}

    def _repr_(self):
        r"""
        Return a string representation of ``self``.

        EXAMPLES::

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

            sage: W = CoxeterGroup(['A',2])
            sage: w = W.from_reduced_word([1,2,1])
            sage: SubwordComplex([1,2,1,2,1], w)
            Subword complex of type ['A', 2] for Q = (1, 2, 1, 2, 1) and pi = [1, 2, 1]
        """
        if self._cartan_type is None:
            return "Subword complex of unknown type for Q = {} and pi = {}".format(self._Q, self._pi.reduced_word())
        else:
            return 'Subword complex of type {} for Q = {} and pi = {}'.format(self.cartan_type(), self._Q, self._pi.reduced_word())

    def __call__(self, F, facet_test=True):
        r"""
        Create a facet of ``self``.

        INPUT:

        - ``F`` -- an iterable of positions
        - ``facet_test`` -- boolean (default: ``True``); whether or
          not the facet ``F`` should be tested before creation

        OUTPUT: the facet of ``self`` at positions given by ``F``

        EXAMPLES::

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

            sage: W = CoxeterGroup(['A',2])
            sage: SC = SubwordComplex([1,2,1,2,1], W.w0)
            sage: F = SC([1,2]); F
            (1, 2)
        """
        if hasattr(F, "parent") and F.parent() is self:
            return F
        return self.element_class(self, F, facet_test=facet_test)

    Element = SubwordComplexFacet

    def __contains__(self, F):
        r"""
        Test if ``self`` contains a given iterable ``F``.

        EXAMPLES::

            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: [0,1] in SC
            True
            sage: [0,2] in SC
            False
            sage: [0,1,5] in SC
            False
            sage: [0] in SC
            False
            sage: ['a','b'] in SC
            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.facets()
            [(0, 1), (0, 4), (1, 2), (2, 3), (3, 4)]
            sage: [0,1] in SC
            True
            sage: [0,2] in SC
            False
            sage: [0,1,5] in SC
            False
            sage: [0] in SC
            False
            sage: ['a','b'] in SC
            False
        """
        W = self.group()
        Q = self.word()
        r = range(len(Q))
        if not all(i in r for i in F):
            return False
        return W.from_reduced_word(Qi for i, Qi in enumerate(Q) if i not in F) == self.pi()

    # getting the stored properties

    def group(self):
        r"""
        Return the group associated to ``self``.

        EXAMPLES::

            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]
        """
        return self._W

    def cartan_type(self):
        r"""
        Return the Cartan type of ``self``.

        EXAMPLES::

            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]
        """
        if self._cartan_type is None:
            raise ValueError("no Cartan type defined for {}".format(self._W))
        else:
            return self._cartan_type

    def word(self):
        r"""
        Return the word in the simple generators associated to ``self``.

        EXAMPLES::

            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)
        """
        return copy(self._Q)

    def pi(self):
        r"""
        Return the element in the Coxeter group associated to ``self``.

        EXAMPLES::

            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]
        """
        return self._pi

    def facets(self):
        r"""
        Return all facets of ``self``.

        EXAMPLES::

            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)]
        """
        if self._facets_dict:
            return [self._facets_dict[tuple(F)] for F in self._facets]
        else:
            return [self(F, facet_test=False) for F in self._facets]

    def __iter__(self):
        r"""
        Return an iterator on the facets of ``self``.

        EXAMPLES::

            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: for I in SC: print(I)
            (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: for I in SC: print(I)
            (0, 1)
            (0, 4)
            (1, 2)
            (2, 3)
            (3, 4)
        """
        return iter(self.facets())

    def greedy_facet(self, side='positive'):
        r"""
        Return the negative (or positive) greedy facet of ``self``.

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

        EXAMPLES::

            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)
        """
        return self.element_class(self, _greedy_facet(self.word(),
                                                      self.pi(), side=side))

    # topological properties

    def is_sphere(self):
        r"""
        Return ``True`` if the subword complex ``self`` is a sphere.

        EXAMPLES::

            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
        """
        W = self._pi.parent()
        w = W.demazure_product(self._Q)
        return w == self._pi

    def is_ball(self):
        r"""
        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: # 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
        """
        return not self.is_sphere()

    def is_pure(self):
        r"""
        Return ``True`` since all subword complexes are pure.

        EXAMPLES::

            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
        """
        return True

    def dimension(self):
        r"""
        Return the dimension of ``self``.

        EXAMPLES::

            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
        """
        return self._facets[0].dimension()

    # root and weight

    @cached_method
    def is_root_independent(self):
        r"""
        Return ``True`` if ``self`` is root-independent.

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

        EXAMPLES::

            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
        """
        from sage.matrix.constructor import matrix
        M = matrix(self.greedy_facet(side='negative').root_configuration())
        return M.rank() == max(M.ncols(), M.nrows())

    @cached_method
    def is_double_root_free(self):
        r"""
        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: # 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
        """
        if not self.is_root_independent():
            size = self.dimension() + 1
            for F in self:
                conf = F._root_configuration_indices()
                if len(set(conf)) < size:
                    return False
        return True

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

        .. SEEALSO::

            :meth:`kappa_preimage <sage.combinat.subword_complex.SubwordComplexFacet.kappa_preimage>`

        EXAMPLES::

            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]]
        """
        return {F: F.kappa_preimage() for F in self}

    def brick_fan(self):
        r"""
        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``.

        .. SEEALSO::

            :func:`weight_cone <sage.combinat.subword_complex.SubwordComplexFacet.weight_cone>`

        EXAMPLES::

            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
        """
        from sage.geometry.fan import Fan
        return Fan([F.weight_cone() for F in self])

    # brick polytope

    def brick_vectors(self, coefficients=None):
        r"""
        Return the list of all brick vectors of facets of ``self``.

        INPUT:

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

        .. SEEALSO::

            :func:`brick_vector <sage.combinat.subword_complex.SubwordComplexFacet.brick_vector>`

        EXAMPLES::

            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)]
        """
        return [F.brick_vector(coefficients=coefficients) for F in self]

    def minkowski_summand(self, i):
        r"""
        Return the `i` th Minkowski summand of ``self``.

        INPUT:

        - ``i`` -- an integer defining a position in the word `Q`

        EXAMPLES::

            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
        """
        G = self.group()
        from sage.rings.rational_field import QQ
        if G.coxeter_matrix().is_crystallographic():
            min_sum = [[QQ(v) for v in F.extended_weight_configuration()[i]] for F in self]
        else:
            from sage.rings.cc import CC
            from warnings import warn
            warn("the polytope is built with rational vertices", RuntimeWarning)
            min_sum = [[QQ(CC(v)) for v in F.extended_weight_configuration()[i]] for F in self]
        return Polyhedron(min_sum)

    def brick_polytope(self, coefficients=None):
        r"""
        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

        .. SEEALSO::

            :meth:`brick_vectors`

        EXAMPLES::

            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
        """
        BV = self.brick_vectors(coefficients=coefficients)
        G = self.group()
        from sage.rings.rational_field import QQ
        if G.coxeter_matrix().is_crystallographic():
            BV = [[QQ(v) for v in V] for V in BV]
        else:
            from sage.rings.cc import CC
            from warnings import warn
            warn("the polytope is built with rational vertices", RuntimeWarning)
            BV = [[QQ(CC(v).real()) for v in V] for V in BV]
        return Polyhedron(BV)

    def barycenter(self):
        """
        Return the barycenter of the brick polytope of ``self``.

        .. SEEALSO::

            :meth:`brick_polytope`

        EXAMPLES::

            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)
        """
        facets = self.facets()
        if not self.is_root_independent():
            facets = [F for F in facets if F.is_vertex()]
        return sum(F.brick_vector() for F in facets) / len(facets)

    # cambrian constructions

    def cover_relations(self, 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: 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))]
        """
        N = len(self.group().long_element(as_word=True))
        F = self.greedy_facet(side='positive')
        Fs = {F}
        seen = {F}
        covers = []
        while Fs:
            F = Fs.pop()
            seen.add(F)
            conf = F._extended_root_configuration_indices()
            for i in F:
                if conf[i] < N:
                    G = F.flip(i)
                    if label:
                        covers.append((F, G, i))
                    else:
                        covers.append((F, G))
                    if G not in seen:
                        Fs.add(G)
        return covers

    def increasing_flip_graph(self, label=True):
        """
        Return the increasing flip graph of the subword complex.

        OUTPUT: a directed graph

        EXAMPLES::

            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
        """
        from sage.graphs.digraph import DiGraph
        return DiGraph(self.cover_relations(label=label))

    def interval(self, I, J) -> set:
        """
        Return the interval [I,J] in the increasing flip graph subword complex.

        INPUT:

        - I, J -- two facets

        OUTPUT: a set of facets

        EXAMPLES::

            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)}
        """
        G = self.increasing_flip_graph()
        paths = G.all_paths(I, J)
        return {K for path in paths for K in path}

    def increasing_flip_poset(self):
        """
        Return the increasing flip poset of the subword complex.

        OUTPUT: a poset

        EXAMPLES::

            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
        """
        from sage.combinat.posets.posets import Poset
        cov = self.cover_relations()
        if not self.is_root_independent():
            Fs = [F for F in self if F.is_vertex()]
            cov = [(a, b) for a, b in cov if a in Fs and b in Fs]
        return Poset(((), cov), facade=True)


def _greedy_facet(Q, w, side='negative', n=None, pos=0, l=None, elems=[]):
    r"""
    Return the (positive or negative) *greedy facet* of the subword
    complex `SC(Q, w)`.

    INPUT:

    - ``Q`` -- a word
    - ``w`` -- an element in the Coxeter group
    - ``side`` -- string; either ``'negative'`` (default) or ``'positive'``
    - ``n`` -- integer (default: the length of `Q`)
    - ``pos`` -- integer (default: 0)
    - ``l`` -- integer (default: the length of `w`)
    - ``elems`` -- list (optional)

    OUTPUT: a set

    EXAMPLES::

        sage: from sage.combinat.subword_complex import _greedy_facet

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: Q = [1,2,1,2,1]
        sage: w = W.from_reduced_word([1, 2, 1])
        sage: _greedy_facet(Q, w)
        {3, 4}

        sage: W = CoxeterGroup(['A',2])
        sage: Q = [1,2,1,2,1]
        sage: w = W.from_reduced_word([1, 2, 1])
        sage: _greedy_facet(Q, w)
        {3, 4}
    """
    if side == "negative":
        pass
    elif side == "positive":
        Q = Q[::-1]
        w = w.inverse()
    else:
        raise ValueError("the optional argument side is not positive "
                         "or negative")

    if n is None:
        n = len(Q)
    if l is None:
        l = w.length()

    if l == 0:
        return elems + list(range(pos, n))
    elif n < l:
        return []

    s = Q[pos]

    if w.has_left_descent(s):
        X = _greedy_facet(Q, w.apply_simple_reflection_left(s),
                          n=n, pos=pos + 1, l=l - 1, elems=elems)
    else:
        X = []

    if not X:
        X = _greedy_facet(Q, w, n=n, pos=pos + 1, l=l, elems=elems + [pos])

    if side == "positive":
        X = [n - 1 - i for i in X]

    return set(X)


def _extended_root_configuration_indices(W, Q, F):
    """
    Return the extended root configuration indices of the facet `F`.

    INPUT:

    - ``W`` -- a Coxeter group
    - ``Q`` -- a word representing an element of `W`
    - ``F`` -- a facet of the subword complex

    OUTPUT: list of root indices

    EXAMPLES::

        sage: from sage.combinat.subword_complex import _extended_root_configuration_indices

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

        sage: W = CoxeterGroup(['A',2])
        sage: w = W.from_reduced_word([1,2,1])
        sage: Q = [1,2,1,2,1]
        sage: SC = SubwordComplex(Q, w)
        sage: F = SC([1,2])
        sage: _extended_root_configuration_indices(W, Q, F)
        [0, 1, 3, 1, 2]
    """
    V_roots = []
    pi = W.one()
    for i, wi in enumerate(Q):
        V_roots.append(pi.action_on_root_indices(W.simple_root_index(wi),
                                                 side='left'))
        if i not in F:
            pi = pi.apply_simple_reflection_right(wi)
    return V_roots


def _greedy_flip_algorithm(Q, w):
    """
    INPUT:

    - ``Q`` -- a word in a Coxeter group `W`
    - ``w`` -- an element of `W`

    OUTPUT: a pair: the list of facets and the list of extended root conf. indices

    EXAMPLES::

        sage: from sage.combinat.subword_complex import _greedy_flip_algorithm

        sage: # optional - gap3
        sage: W = ReflectionGroup(['A',2])
        sage: Q = [1,2,1,2,1]
        sage: w = W.from_reduced_word([1,2,1])
        sage: _greedy_flip_algorithm(Q, w)
        ([{0, 1}, [1, 2], [2, 3], [3, 4], [0, 4]],
         [[0, 1, 0, 2, 1],
          [0, 2, 3, 2, 1],
          [0, 2, 1, 5, 1],
          [0, 2, 1, 3, 4],
          [0, 1, 2, 0, 4]])

        sage: W = CoxeterGroup(['A',2])
        sage: Q = [1,2,1,2,1]
        sage: w = W.from_reduced_word([1,2,1])
        sage: _greedy_flip_algorithm(Q, w)
        ([{0, 1}, [1, 2], [2, 3], [3, 4], [0, 4]],
         [[0, 2, 0, 1, 2],
          [0, 1, 3, 1, 2],
          [0, 1, 2, 4, 2],
          [0, 1, 2, 3, 5],
          [0, 2, 1, 0, 5]])
    """
    W = w.parent()
    F = _greedy_facet(Q, w, side='positive')
    R = _extended_root_configuration_indices(W, Q, F)
    facet_list = [F]
    extended_root_conf_indices_list = [R]
    flip_to_ancestors = [-1]
    next_index = 0
    while flip_to_ancestors:
        has_new_child = False
        for i in sorted(F):
            if (not has_new_child) and (i >= next_index):
                j = _flip_c(W, F, R, i, side='positive')
                if j != i:
                    flip_to_ancestors.append(j)
                    next_index = i + 1
                    has_new_child = True
                    facet_list.append(list(F))
                    extended_root_conf_indices_list.append(list(R))
        if not has_new_child:
            i = flip_to_ancestors.pop()
            if i != -1:
                j = _flip_c(W, F, R, i, side='negative')
                next_index = j + 1
    return facet_list, extended_root_conf_indices_list
