Trac #32669: Adding upper and lower Bruhat cones of M. Dyer to sage/combinat/root_system/reflection_group_real.py

To a pair of elements x,y in a Coxeter group W one can associate two
polyhedral cones. The 'upper bruhat cone' generated by all roots beta
such that s_beta * x covers x and s_beta * x <= y and similarly the
'lower bruhat cone' generated by all beta sucht that y covers s_beta * y
and x <= s_beta * y .

These cones were used in https://eudml.org/doc/174610 and
https://arxiv.org/abs/2103.03715

URL: https://trac.sagemath.org/32669
Reported by: gh-DennisJahn
Ticket author(s): Dennis Jahn
Reviewer(s): Frédéric Chapoton, Travis Scrimshaw

Author: Release Manager

src/doc/en/reference/references/index.rst

@@ -2150,6 +2150,9 @@ REFERENCES:
 .. [Dy1993] \M. J. Dyer. *Hecke algebras and shellings of Bruhat
             intervals*. Compositio Mathematica, 1993, 89(1): 91-115.
 
+.. [Dy1994] \M. J. Dyer. *Bruhat intervals, polyhedral cones and 
+            Kazhdan-Lusztig-Stanley polynomials*. Math.Z., 215(2):223-236, 1994.
+
 .. _ref-E:
 
 **E**
@@ -3340,6 +3343,10 @@ REFERENCES:
             J. Algebra. **324** (2010). 2512-2542.
             :doi:`10.1016/j.bbr.2011.03.031`, :arxiv:`0909.2442`.
 
+.. [JS2021] \D. Jahn, C. Stump.
+            *Bruhat intervals, subword complexes and brick polyhedra for 
+            finite Coxeter groups*, 2021, :arxiv:`2103.03715`.
+
 .. [JV2000] \J. Justin, L. Vuillon, *Return words in Sturmian and
             episturmian words*, Theor. Inform. Appl. 34 (2000)
             343--356.

src/sage/categories/coxeter_groups.py

@@ -2176,12 +2176,25 @@ def bruhat_lower_covers_reflections(self):
                 sage: w.bruhat_lower_covers_reflections()
                 [(s1*s2*s1, s1*s2*s3*s2*s1), (s3*s2*s1, s2), (s3*s1*s2, s1)]
 
+            TESTS:
+
+            Check bug discovered in :trac:`32669` is fixed::
+
+                sage: W = CoxeterGroup(['A',3], implementation='permutation')
+                sage: W.w0.bruhat_lower_covers_reflections()
+                [((1,3,7,9)(2,11,6,10)(4,8,5,12), (2,5)(3,9)(4,6)(8,11)(10,12)),
+                 ((1,11)(3,10)(4,9)(5,7)(6,12), (1,4)(2,8)(3,5)(7,10)(9,11)),
+                 ((1,9,7,3)(2,10,6,11)(4,12,5,8), (1,7)(2,4)(5,6)(8,10)(11,12))]
             """
-            i = self.first_descent()
+            i = self.first_descent(side='right')
             if i is None:
                 return []
-            wi = self.apply_simple_reflection(i)
-            return [(u.apply_simple_reflection(i), r.apply_conjugation_by_simple_reflection(i)) for u, r in wi.bruhat_lower_covers_reflections() if not u.has_descent(i)] + [(wi, self.parent().simple_reflection(i))]
+            wi = self.apply_simple_reflection(i, side='right')
+            return [(u.apply_simple_reflection(i, side='right'),
+                     r.apply_conjugation_by_simple_reflection(i))
+                    for u,r in wi.bruhat_lower_covers_reflections()
+                    if not u.has_descent(i, side='right')] + [
+                (wi, self.parent().simple_reflection(i))]
 
         def lower_cover_reflections(self, side='right'):
             r"""

src/sage/combinat/root_system/reflection_group_real.py

@@ -706,6 +706,88 @@ 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:
+
+        - [Dy1994]_
+        - [JS2021]_
+        """
+        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):