Ticket #15272: trac_15272_parabolic_bruhat_posets.patch

sage/combinat/root_system/weyl_group.py

@@ -518 +518 @@
         for x in g:
             d[x] = [y for y in g if x.length() < y.length() and ref.has_key(x*y.inverse())]
         return DiGraph(d)
+    
+    def parabolic_bruhat_graph(self, index_set = None, side="right"):
+        """
+        Returns the Hasse graph of the poset ``self.bruhat_poset(index_set,side)`` with edges labeled by the cover relation.
+        """
+        elements = minimal_representatives(index_set, side)
+        covers =[(x,y)  for y in elements for x in y.bruhat_lower_covers() if x in elements]
+        res = DiGraph()
+        for u,v in covers:
+            res.add_edge(u,v,v.inverse()*u)
+        return res
+
+    
+    def minimal_representatives(self, index_set = None, side="right"):
+        """
+        Returns the set of minimal coset representatives of ``self`` by a parabolic subgroup. 
+
+        INPUT:
+
+        - ``index_set`` - a subset (or iterable) of the nodes of the dynkin diagram, empty by default
+        - ``side`` - 'left' or 'right' (default)
+
+        See documentation of ``self.bruhat_poset`` for more details.
+
+        The output is equivalent to ``set(w.coset_representative(index_set,side))``
+            
+        but this routine is much faster. For explanation of the algorithm see e.g. Cap, Slovak: 
+        Parabolic geometries, p. 332
+
+        EXAMPLES::
+            
+            sage: G = WeylGroup(CartanType("A4"),prefix="s")
+            sage: index_set = [1,3,4]
+            sage: side = "left"
+            sage: a = set(w for w in G.minimal_representatives(index_set,side))
+            sage: b = set(w.coset_representative(index_set,side) for w in G)
+            sage: print a.difference(b)
+            set([])
+        """
+        from sage.combinat.root_system.root_system import RootSystem
+        from copy import copy
+        
+        if side != 'right' and side != 'left':
+            raise ValueError, "%s is neither 'right' nor 'left'"%(side)
+        
+        weight_space = RootSystem(self.cartan_type()).weight_space()
+        if index_set == None:
+            crossed_nodes = set(self.index_set())
+        else:
+            crossed_nodes = set(self.index_set()).difference(index_set)
+        # the characteristic vector
+        rhop = sum([weight_space.fundamental_weight(i) for i in  crossed_nodes]) 
+        '''
+        
+        The varibale "todo" serves for traversing the orbit of rhop, while the directory "known" serves as a memory to keep the visited elements. Its keys 
+are elements in the orbit of rhop while known[vec] are paths of simple reflections from rhop to vec.
+        
+        '''
+        todo = [rhop]
+        known = dict()
+        known[rhop] = []
+        if rhop == 0:
+            return set( [self.one()] )
+        else:
+            while len(todo) > 0:
+                vec = todo.pop()
+                nonzero_coeffs = [i for i in self.index_set() if vec.coefficient(i) > 0]
+                for i in nonzero_coeffs:
+                    new_vec = vec.simple_reflection(i)
+                    new_reflections = copy(known[vec])
+                    new_reflections.append(i)
+                    todo.append(new_vec)
+                    known[new_vec] = new_reflections
+            if side =='left':
+                return set(self.from_reduced_word(w) for w in known.values())
+            else:
+                #here we could just take the inverses of w but reversing the list of simple reflections is slightly more efficient
+                return set(self.from_reduced_word(w[::-1]) for w in known.values()) 
+   
+    def bruhat_poset(self, index_set = None, side="right", facade = False):
+        """
+        Returns the Bruhat poset of minimal coset representatives of ``self`` by a parabolic 
+        subgroup.
+        
+        INPUT:
+        
+        - ``index_set`` - a subset (or iterable) of the nodes of the dynkin diagram, empty by default
+        - ``side`` - 'left' or 'right' (default)
+        
+        Let W_S be the subgroup of W (``self`` ) that is generated by the simple reflections 
+        corresponding to the set S (``index_set``). Then the cosets W / W_S have representatives of 
+        minimal length which are ordered by the Bruhat order of W. 
+        
+        The ``index_set`` is the set of simple roots that generates the subgroup W_S of self. 
+        If the ``index_set`` is empty (which is the default), then we get the whole Weyl group.
+        
+        The parameter ``side`` (which defaults to "right") determines whether the result is the 
+        set of right coset representatives of W_S \ W or the set of left coset 
+        representatives W / W_S.
+        
+        
+        EXAMPLES::
+
+            sage: W = WeylGroup(["A", 2])
+            sage: P = W.bruhat_poset()
+            sage: P
+            Finite poset containing 6 elements
+            sage: P.show()
+
+        Here are some typical operations on this poset::
+
+            sage: W = WeylGroup(["A", 3])
+            sage: P = W.bruhat_poset()
+            sage: u = W.from_reduced_word([3,1])
+            sage: v = W.from_reduced_word([3,2,1,2,3])
+            sage: P(u) <= P(v)
+            True
+            sage: len(P.interval(P(u), P(v)))
+            10
+            sage: P.is_join_semilattice()
+            False
+
+        By default, the elements of `P` are aware that they belong
+        to `P`::
+
+            sage: P.an_element().parent()
+            Finite poset containing 24 elements
+
+        If instead one wants the elements to be plain elements of
+        the Coxeter group, one can use the ``facade`` option::
+
+            sage: P = W.bruhat_poset(facade = True)
+            sage: P.an_element().parent()
+            Weyl Group of type ['A', 3] (as a matrix group acting on the ambient space)
+
+        .. see also:: :func:`Poset` for more on posets and facade posets.
+
+        TESTS::
+
+            sage: [len(WeylGroup(["A", n]).bruhat_poset().cover_relations()) for n in [1,2,3]]
+            [1, 8, 58]
+
+        .. todo::
+
+            - Use the symmetric group in the examples (for nicer
+                output), and print the edges for a stronger test.
+            - The constructed poset should be lazy, in order to
+                handle large / infinite Coxeter groups.
+        """
+        from sage.combinat.posets.posets import Poset
+        elements = self.minimal_representatives(index_set, side)
+        # Since our Weyl elements should be already reduced (?), we could 
+        # optimize this step by constructing the cover relations directly (see Cap, Slovak: Parabolic geometries, p. 332), 
+        # thus reducing quadratic complexity of the next step to linear. On the other hand, we would have to introduce saturated subsets.
+        covers = tuple([x,y] for y in elements for x in  y.bruhat_lower_covers() 
+                        if x in elements)
+        return Poset((self, covers), cover_relations = True, facade=facade)
 
 
 class ClassicalWeylSubgroup(WeylGroup_gens):