示例#1
0
    def elements(self):
        r"""
        Returns the elements of ``self``

        Those are constructed as the elements below the maximal
        elements of ``self`` in Bruhat order.

        OUTPUT: a :class:`RecursivelyEnumeratedSet_generic` object

        EXAMPLES::

            sage: PF = WeylGroup(['A',3]).pieri_factors()
            sage: [w.reduced_word() for w in PF.elements()]
            [[3, 2, 1], [2, 1], [3, 1], [3, 2], [2], [1], [3], []]

        .. SEEALSO:: :meth:`maximal_elements`

        .. TODO::

            Possibly remove this method and instead have this class
            inherit from :class:`RecursivelyEnumeratedSet_generic`.
        """
        return RecursivelyEnumeratedSet(self.maximal_elements(),
                attrcall('bruhat_lower_covers'), structure=None,
                enumeration='naive')
示例#2
0
    def elements(self):
        r"""
        Returns the elements of ``self``

        Those are constructed as the elements below the maximal
        elements of ``self`` in Bruhat order.

        OUTPUT: a :class:`RecursivelyEnumeratedSet_generic` object

        EXAMPLES::

            sage: PF = WeylGroup(['A',3]).pieri_factors()
            sage: [w.reduced_word() for w in PF.elements()]
            [[3, 2, 1], [2, 1], [1], [], [3, 1], [3], [3, 2], [2]]

        .. SEEALSO:: :meth:`maximal_elements`

        .. TODO::

            Possibly remove this method and instead have this class
            inherit from :class:`RecursivelyEnumeratedSet_generic`.
        """
        return RecursivelyEnumeratedSet(self.maximal_elements(),
                                        attrcall('bruhat_lower_covers'),
                                        structure=None,
                                        enumeration='naive')
    def positive_roots(self):
        r"""
        Returns the positive roots of self.

        EXAMPLES::
        
            sage: L = RootSystem(['A',3]).root_lattice()
            sage: sorted(L.positive_roots())
            [alpha[1], alpha[1] + alpha[2], alpha[1] + alpha[2] + alpha[3], alpha[2], alpha[2] + alpha[3], alpha[3]]
            
        Algorithm: generate them from the simple roots by applying
        successive reflections toward the positive chamber.
        """
        assert self.cartan_type().is_finite()
        return TransitiveIdeal(attrcall('pred'), self.simple_roots())
示例#4
0
    def positive_roots(self):
        r"""
        Returns the positive roots of self.

        EXAMPLES::
        
            sage: L = RootSystem(['A',3]).root_lattice()
            sage: sorted(L.positive_roots())
            [alpha[1], alpha[1] + alpha[2], alpha[1] + alpha[2] + alpha[3], alpha[2], alpha[2] + alpha[3], alpha[3]]
            
        Algorithm: generate them from the simple roots by applying
        successive reflections toward the positive chamber.
        """
        assert self.cartan_type().is_finite()
        return TransitiveIdeal(attrcall('pred'), self.simple_roots())
    def negative_roots(self):
        r"""
        Returns the negative roots of self.

        EXAMPLES::
        
            sage: L = RootSystem(['A', 2]).weight_lattice()
            sage: sorted(L.negative_roots())
            [-2*Lambda[1] + Lambda[2], -Lambda[1] - Lambda[2], Lambda[1] - 2*Lambda[2]]

        Algorithm: negate the positive roots

        """
        assert self.cartan_type().is_finite()
        from sage.combinat.combinat import MapCombinatorialClass
        return MapCombinatorialClass(self.positive_roots(), attrcall('__neg__'), "The negative roots of %s"%self)
示例#6
0
    def negative_roots(self):
        r"""
        Returns the negative roots of self.

        EXAMPLES::
        
            sage: L = RootSystem(['A', 2]).weight_lattice()
            sage: sorted(L.negative_roots())
            [-2*Lambda[1] + Lambda[2], -Lambda[1] - Lambda[2], Lambda[1] - 2*Lambda[2]]

        Algorithm: negate the positive roots

        """
        assert self.cartan_type().is_finite()
        from sage.combinat.combinat import MapCombinatorialClass
        return MapCombinatorialClass(self.positive_roots(),
                                     attrcall('__neg__'),
                                     "The negative roots of %s" % self)
示例#7
0
    def smaller(self):
        r"""
        Returns the elements in the orbit of self which are
        smaller than self in the weak order.

        EXAMPLES::
        
            sage: L = RootSystem(['A',3]).ambient_lattice()
            sage: e = L.basis()
            sage: e[2].smaller()
            [(0, 0, 1, 0), (0, 1, 0, 0), (1, 0, 0, 0)]
            sage: len(L.rho().smaller())
            1
            sage: len((-L.rho()).smaller())
            24
            sage: sorted([len(x.smaller()) for x in L.rho().orbit()])
            [1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 6, 8, 8, 8, 8, 12, 12, 12, 24]
        """
        return [x for x in TransitiveIdeal(attrcall('pred'), [self])]
    def smaller(self):
        r"""
        Returns the elements in the orbit of self which are
        smaller than self in the weak order.

        EXAMPLES::
        
            sage: L = RootSystem(['A',3]).ambient_lattice()
            sage: e = L.basis()
            sage: e[2].smaller()
            [(0, 0, 1, 0), (0, 1, 0, 0), (1, 0, 0, 0)]
            sage: len(L.rho().smaller())
            1
            sage: len((-L.rho()).smaller())
            24
            sage: sorted([len(x.smaller()) for x in L.rho().orbit()])
            [1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 6, 8, 8, 8, 8, 12, 12, 12, 24]
        """
        return [x for x in TransitiveIdeal(attrcall('pred'), [self])]
    def orbit(self):
        r"""
        The orbit of self under the action of the Weyl group

        EXAMPLES::
        
        `\rho` is a regular element whose orbit is in bijection with the Weyl group.
        In particular, it as 6 elements for the symmetric group `S_3`::
        
            sage: L = RootSystem(["A", 2]).ambient_lattice()
            sage: sorted(L.rho().orbit())               # the output order is not specified
            [(1, 2, 0), (1, 0, 2), (2, 1, 0), (2, 0, 1), (0, 1, 2), (0, 2, 1)]

            sage: L = RootSystem(["A", 3]).weight_lattice()
            sage: len(L.rho().orbit())
            24
            sage: len(L.fundamental_weights()[1].orbit())
            4
            sage: len(L.fundamental_weights()[2].orbit())
            6
        """
        return [x for x in TransitiveIdeal(attrcall('simple_reflections'), [self])]
示例#10
0
    def elements(self):
        r"""
        Returns the elements of ``self``

        Those are constructed as the elements below the maximal
        elements of ``self`` in Bruhat order.

        OUTPUT: a :class:`TransitiveIdeal` object

        EXAMPLES::

            sage: PF = WeylGroup(['A',3]).pieri_factors()
            sage: [w.reduced_word() for w in PF.elements()]
            [[3, 2, 1], [2, 1], [1], [], [3, 1], [3], [3, 2], [2]]

        .. SEEALSO:: :meth:`maximal_elements`

        .. TODO::

            Possibly remove this method and instead have this class
            inherit from :class:`TransitiveIdeal`.
        """
        return TransitiveIdeal(attrcall('bruhat_lower_covers'), self.maximal_elements())
示例#11
0
    def orbit(self):
        r"""
        The orbit of self under the action of the Weyl group

        EXAMPLES::
        
        `\rho` is a regular element whose orbit is in bijection with the Weyl group.
        In particular, it as 6 elements for the symmetric group `S_3`::
        
            sage: L = RootSystem(["A", 2]).ambient_lattice()
            sage: sorted(L.rho().orbit())               # the output order is not specified
            [(1, 2, 0), (1, 0, 2), (2, 1, 0), (2, 0, 1), (0, 1, 2), (0, 2, 1)]

            sage: L = RootSystem(["A", 3]).weight_lattice()
            sage: len(L.rho().orbit())
            24
            sage: len(L.fundamental_weights()[1].orbit())
            4
            sage: len(L.fundamental_weights()[2].orbit())
            6
        """
        return [
            x for x in TransitiveIdeal(attrcall('simple_reflections'), [self])
        ]