added the method bruhat_cone including references

src/sage/combinat/root_system/reflection_group_real.py

@@ -27,6 +27,11 @@
 
 - Christian Stump (initial version 2011--2015)
 
+REFERENCES:
+
+.. [Dye] Dyer. *Bruhat intervals, polyhedral cones and Kazhdan-Lusztig-Stanley polynomials*. Math.Z., 215(2):223-236, 1994.
+.. [JahStu] Jahn and Stump. *Bruhat intervals, subword complexes and brick polyhedra for finite Coxeter groups*. Preprint, available at :arxiv:`2103.03715`, 2021.
+
 .. WARNING::
 
     Uses the GAP3 package *Chevie* which is available as an
@@ -706,6 +711,90 @@ def simple_root_index(self, i):
             [0, 1, 2]
         """
         return self._index_set_inverse[i]
+
+    def bruhat_cone(self, x, y, side='upper', backend='cdd'):
+        r"""
+        Return the (upper or lower) Bruhat cone associated to the interval ``[x,y]``.
+
+        To a cover relation `v \prec w` in strong Bruhat order you can assign a positive
+        root `\beta` given by the unique reflection `s_\beta` such that `s_\beta v = w`.
+
+        The upper Bruhat cone of the interval `[x,y]` is the non-empty, polyhedral cone generated
+        by the roots corresponding to `x \prec a` for all atoms `a` in the interval.
+        The lower Bruhat cone of the interval `[x,y]` is the non-empty, polyhedral cone generated
+        by the roots corresponding to `c \prec y` for all coatoms `c` in the interval.
+
+        INPUT:
+
+        - ``x`` - an element in the group `W`
+
+        - ``y`` - an element in the group `W`
+
+        - ``side`` (default: ``'upper'``) -- must be one of the following:
+
+          * ``'upper'`` - return the upper Bruhat cone of the interval [``x``, ``y``]
+          * ``'lower'`` - return the lower Bruhat cone of the interval [``x``, ``y``]
+
+        - ``backend`` -- string (default: ``'cdd'``); the backend to use to create the polyhedron
+
+        EXAMPLES::
+
+            sage: W = ReflectionGroup(['A',2])                          # optional - gap3
+            sage: x = W.from_reduced_word([1])                          # optional - gap3
+            sage: y = W.w0                                              # optional - gap3
+            sage: W.bruhat_cone(x, y)                                   # optional - gap3
+            A 2-dimensional polyhedron in QQ^2 defined as the convex hull of 1 vertex and 2 rays
+
+            sage: W = ReflectionGroup(['E',6])                          # optional - gap3
+            sage: x = W.one()                                           # optional - gap3
+            sage: y = W.w0                                              # optional - gap3
+            sage: W.bruhat_cone(x, y, side='lower')                     # optional - gap3
+            A 6-dimensional polyhedron in QQ^6 defined as the convex hull of 1 vertex and 6 rays
+
+        TESTS::
+
+            sage: W = ReflectionGroup(['A',2])                          # optional - gap3
+            sage: x = W.one()                                           # optional - gap3
+            sage: y = W.w0                                              # optional - gap3
+            sage: W.bruhat_cone(x, y, side='nonsense')                  # optional - gap3
+            Traceback (most recent call last):
+            ...
+            ValueError: side must be either 'upper' or 'lower'
+
+        REFERENCES:
+
+        - [Dye]_
+        - [JahStu]_
+        """
+        if side == 'upper':
+            roots = [self.reflection_to_positive_root(x * r * x.inverse())
+                     for z, r in x.bruhat_upper_covers_reflections()
+                     if z.bruhat_le(y)]
+        elif side == 'lower':
+            roots = [self.reflection_to_positive_root(y * r * y.inverse())
+                     for z, r in y.bruhat_lower_covers_reflections()
+                     if x.bruhat_le(z)]
+        else:
+            raise ValueError("side must be either 'upper' or 'lower'")
+
+        from sage.geometry.polyhedron.constructor import Polyhedron
+        if self.is_crystallographic():
+            return Polyhedron(vertices=[[0] * self.rank()],
+                              rays=roots,
+                              ambient_dim=self.rank(),
+                              backend=backend)
+        if backend == 'cdd':
+            from warnings import warn
+            warn("Using floating point numbers for roots of unity. This might cause numerical errors!")
+            from sage.rings.real_double import RDF as base_ring
+        else:
+            from sage.rings.qqbar import AA as base_ring
+
+        return Polyhedron(vertices=[[0] * self.rank()],
+                          rays=roots,
+                          ambient_dim=self.rank(),
+                          base_ring=base_ring,
+                          backend=backend)
 
     class Element(RealReflectionGroupElement, ComplexReflectionGroup.Element):