base_space.sage

from typing import Iterator



class irreducible_Cartan_group ( object ) :


    ADMISSIBLE_CARTAN_FAMILIES = { 'A' : ( 1 , +infinity ) ,
                                   'B' : ( 2 , +infinity ) ,
                                   'C' : ( 2 , +infinity ) ,
                                   'D' : ( 3 , +infinity ) ,
                                   'E' : ( 6 , 8 ) ,
                                   'F' : ( 4 , 4 ) ,
                                   'G' : ( 2 , 2 )
                                 }


    def __eq__ ( self , other ) -> bool :
        """Tests if ``self`` coincides with ``other``."""
        assert isinstance( other , irreducible_Cartan_group ) , \
               'The input for ``other`` needs to be an irreducible Cartan group.'
        return self.__repr__() == other.__repr__()



    def __init__ ( self , Cartan_family:str , Cartan_degree:sage.rings.integer.Integer ) -> None :
        """Initialise ``self``."""
        assert Cartan_family in self.ADMISSIBLE_CARTAN_FAMILIES.keys() , \
               ValueError('The input for ``Cartan_family`` needs to be a letter from the alphabet '+str(self.ADMISSIBLE_CARTAN_FAMILIES.keys())+'.')
        self._Cartan_family = Cartan_family

        assert Cartan_degree in ZZ , \
               ValueError('The input for ``Cartan_degree`` needs to be an integer.')
        lower_bound , upper_bound = self.ADMISSIBLE_CARTAN_FAMILIES[Cartan_family]
        assert lower_bound <= Cartan_degree and Cartan_degree <= upper_bound , \
               ValueError('If the Cartan family is '+str(Cartan_family)+', then the input for ``Cartan_degree`` needs to between '+str(lower_bound)+' and '+str(upper_bound)+'.')
        self._Cartan_degree = Cartan_degree


    def __neq__ ( self , other ) -> bool :
        """Tests if ``self`` does NOT coincides with ``other``."""
        return not self == other


    def __repr__ ( self ) -> tuple[ str , sage.rings.integer.Integer ] :
        """Returns a developers adjusted description."""
        return self._Cartan_family , self._Cartan_degree


    def __str__ ( self ) -> str :
        """Returns a human-readable description."""
        return self._Cartan_family+'_'+str(self._Cartan_degree)


    def __truediv__ ( self , other:'maximal_parabolic_subgroup' ) -> 'minimal_irreducible_homogeneous_variety' :
        """Returns the minimal irreducible homogeneous variety X=G/P."""
        assert isinstance( other , maximal_parabolic_subgroup ) , \
               'The input for ``other`` needs to be a minimal parabolic subgroup.'

        assert self == other._parent_group , \
               'The parent group of ``other`` needs to be self.'

        return minimal_irreducible_homogeneous_variety( parabolic_subgroup=other )


    def Cartan_string ( self ) -> str :
        """Returns the Cartan string ``_Cartan_family``+``_Cartan_degree``."""
        return self._Cartan_family+str(self._Cartan_degree)


    def Cartan_type ( self ) ->    'sage.combinat.root_system.type_A.CartanType' \
                                or 'sage.combinat.root_system.type_B.CartanType' \
                                or 'sage.combinat.root_system.type_D.CartanType' \
                                or 'sage.combinat.root_system.type_E.CartanType' \
                                or 'sage.combinat.root_system.type_E.CartanType' \
                                or 'sage.combinat.root_system.type_F.CartanType' \
                                or 'sage.combinat.root_system.type_G.CartanType' :
        """Returns the associated Cartan type."""
        return CartanType( self.Cartan_string() )


    def dimension ( self ) -> sage.rings.integer.Integer :
        """
        Return the dimension of ``self`.

        INPUT:
        - ``self`` -- minimal_irreducible_homogeneous_variety; base space X=G/P.

        OUTPUT:
        - ``Output`` -- Integer; the dimension of X=G/P

        ALGORITHM:
        Thanks to the post by Pieter Belmans concerning the dimension of partial flag varieties
        from Jun 14th, 2017 on his blog (cf. to [Blog_PieterBelmans]_). The link is
        https://pbelmans.ncag.info/blog/2017/06/14/dimensions-of-partial-flag-varieties/
        (Date: Apr 21st, 2021).

        For the Borel group B ⊂ G: dim B = # of positive roots + rank (which accounts for the center)
        For G: dim G = # of roots in the root system + rank (which accounts for the center)
            i.e. # of roots in the root system = # of positive roots + # negative roots
            and # of positive roots = # negative roots
            so # of roots in the root system = 2 * # of positive roots

        REFERENCE:
        [Blog_PieterBelmans] https://pbelmans.ncag.info/blog/
        """
        rank = self.Cartan_type().dynkin_diagram().rank()
        number_of_positive_roots = len( list( self.Cartan_type().root_system().root_lattice().positive_roots() ) )
        return rank + 2*number_of_positive_roots


    def parabolic_subgroup ( self , excluded_node:sage.rings.integer.Integer ) -> 'maximal_parabolic_subgroup' :
        """Returns a maximal parabolic subgroup associated to a given excluded node."""
        return maximal_parabolic_subgroup( parent_group=self , excluded_node=excluded_node )


    def Weyl_character_ring( self ) -> 'sage.combinat.root_system.weyl_characters.WeylCharacterRing_with_category' :
        """Returns the associated Weyl character ring."""
        return WeylCharacterRing( self.Cartan_type() , style='coroots' )


    def Weyl_group( self ) -> 'sage.combinat.root_system.weyl_group.WeylGroup_gens_with_category' :
        """Returns the associated Weyl group."""
        return WeylGroup( self.Cartan_type() )



class maximal_parabolic_subgroup ( object ) :


    def __eq__ ( self , other ) -> bool :
        """Tests if ``self`` coincides with ``other``."""
        assert isinstance( other , maximal_parabolic_subgroup ) , \
               'The input for ``other`` needs to be an irreducible Cartan group.'
        return self.__repr__() == other.__repr__()


    def __init__ ( self , parent_group:irreducible_Cartan_group , excluded_node:sage.rings.integer.Integer ) :
        """Initialise ``self``."""
        assert isinstance( parent_group , irreducible_Cartan_group ) , \
               ValueError('The input for ``parent_group`` needs to be an irreducible Cartan group.')
        self._parent_group = parent_group

        assert excluded_node in ZZ , \
               ValueError('The input for ``excluded_node`` needs to be an integer.')
        assert excluded_node in [ 1 .. self._parent_group._Cartan_degree ] , \
               ValueError('The input for ``excluded_node`` needs to be in the range from 1 to '+str(self._Cartan_degree)+'.')
        self._excluded_node = excluded_node


    def __neq__ ( self , other ) -> bool :
        """Tests if ``self`` does NOT coincides with ``other``."""
        return not self == other


    def __repr__ ( self ) -> tuple[ irreducible_Cartan_group , sage.rings.integer.Integer ] :
        """Returns a developers adjusted description."""
        return self._parent_group , self._excluded_node


    def __str__ ( self ) -> str :
        """Returns a human-readable description."""
        return 'P_'+str(self._excluded_node)


    def dimension ( self ) -> sage.rings.integer.Integer :
        """
        Return the dimension of ``self`.

        INPUT:
        - ``self`` -- minimal_irreducible_homogeneous_variety; base space X=G/P.

        OUTPUT:
        - ``Output`` -- Integer; the dimension of X=G/P

        ALGORITHM:
        Thanks to the post by Pieter Belmans concerning the dimension of partial flag varieties
        from Jun 14th, 2017 on his blog (cf. to [Blog_PieterBelmans]_). The link is
        https://pbelmans.ncag.info/blog/2017/06/14/dimensions-of-partial-flag-varieties/
        (Date: Apr 21st, 2021).

        For the Borel group B ⊂ G: dim B = # of positive roots + rank (which accounts for the center)
        For P: dim P = dim B + # of negative roots which are added to construct P

        REFERENCE:
        [Blog_PieterBelmans] https://pbelmans.ncag.info/blog/
        """
        rank = self._parent_group.Cartan_type().dynkin_diagram().rank()
        number_of_positive_roots = len( list( self._parent_group.Cartan_type().root_system().root_lattice().positive_roots() ) )
        negative_roots = [ negative_root for negative_root in list( self._parent_group.Cartan_type().root_system().root_lattice().negative_roots() )
                           if not False in [ node != self._excluded_node for node , coefficient in negative_root ]
                         ]
        number_of_available_negative_roots = len( negative_roots )
        return rank + number_of_positive_roots + number_of_available_negative_roots


    def included_nodes ( self ) -> list[ sage.rings.integer.Integer ] :
        """Returns list of included nodes."""
        return [ node for node in [ 1 .. self._parent_group._Cartan_degree ] if node != self._excluded_node ]



class minimal_irreducible_homogeneous_variety ( object ) :

    def __eq__ ( self , other ) -> bool :
        """Tests if ``self`` coincides with ``other``."""
        assert isinstance( other , minimal_irreducible_homogeneous_variety ) , \
               'The input for ``other`` needs to be an irreducible Cartan group.'
        return self.__repr__() == other.__repr__()


    def __init__ ( self , parabolic_subgroup:maximal_parabolic_subgroup ) -> None :
        """Initialise ``self``."""
        assert isinstance( parabolic_subgroup , maximal_parabolic_subgroup ) , \
               ValueError('The input for ``parabolic_subgroup`` needs to be a maximal parabolic subgroup.')
        self._parabolic_subgroup = parabolic_subgroup


    def __neq__ ( self , other ) -> bool :
        """Tests if ``self`` does NOT coincides with ``other``."""
        return not self == other


    def __repr__ ( self ) -> maximal_parabolic_subgroup :
        """Returns a developers adjusted description."""
        return self._parabolic_subgroup


    def __str__ ( self ) -> str :
        """Returns a human-readable description."""
        return str(self._parabolic_subgroup._parent_group)+'/'+str(self._parabolic_subgroup)


    def dimension ( self ) -> sage.rings.integer.Integer :
        """
        Return the dimension of ``self`.

        INPUT:
        - ``self`` -- minimal_irreducible_homogeneous_variety; base space X=G/P.

        OUTPUT:
        - ``Output`` -- Integer; the dimension of X=G/P

        ALGORITHM:
        For X=G/P, dim X = dim G - dim P
        """
        return self._parabolic_subgroup._parent_group.dimension() - self._parabolic_subgroup.dimension()


    def Fano_index ( self ) -> sage.rings.integer.Integer :
        """
        Returns the Fano index of ``self``.

        INPUT:
        - ``self`` -- minimal_irreducible_homogeneous_variety; base space X=G/P.

        OUTPUT:
        - ``Fano_index`` -- integer; index associated to X = G/P.

        ALGORITHM:
        Thanks to the post by Pieter Belmans concerning the index of partial flag varieties
        from Aug 23rd, 2018 on his blog (cf. to [Blog_PieterBelmans]_). The link is
        https://pbelmans.ncag.info/blog/2018/08/23/index-partial-flag-varieties/
        (Date: Apr 26th, 2021).

        The index, i.e. for X=G/P (P maximal), we have Pic(X) ≅ ZZ⋅O_X(1) and therefore define the index as the integer i
        such that ω∨_X ≅ O_X(1) ⊗ i.

        To compute it, we use lemma 2.19 and remark 2.20 of [KP2016]. Combined they say the following:
        Let β be the simple root corresponding to the chosen maximal parabolic subgroup P, and ξ the associated
        fundamental weight. Let ¯β be the maximal root of the same length as β such that the coefficient of β
        in the expression of ¯β is 1.
        Then the index of G/P equals i_G/P = (ρ,β+¯β)/(ξ,β).

        REFERENCE:
        [Blog_PieterBelmans] https://pbelmans.ncag.info/blog/
        [KP2016] Kuznetsov, Alexander; Polishchuk, Alexander Exceptional collections on isotropic Grassmannians.
                 J. Eur. Math. Soc. (JEMS) 18 (2016), no. 3, 507–574.
        """
        root_lattice = self._parabolic_subgroup._parent_group.Cartan_type().root_system().root_lattice()
        ambient_space = self._parabolic_subgroup._parent_group.Cartan_type().root_system().ambient_space()
        beta = root_lattice.simple_root(self._parabolic_subgroup._excluded_node).to_ambient() # The simple root associated to ``excluded_node``
        xi = ambient_space.fundamental_weight(self._parabolic_subgroup._excluded_node) # The fundamental weight associated to ``excluded_node``
        rho = ambient_space.rho() # Sum of fundamental weights
        length = beta.dot_product(beta)
        beta_bar = [ alpha for alpha in root_lattice.roots()
                     if alpha.coefficient(self._parabolic_subgroup._excluded_node) == 1 and alpha.to_ambient().dot_product(alpha.to_ambient()) == length
                   ][-1].to_ambient()
                   # The maximal root of the same length as ``beta`` such that the coefficient of ``beta`` in the expression of ``beta_bar`` is 1.
        Fano_index = rho.dot_product(beta + beta_bar) / xi.dot_product(beta)
        return Fano_index


    def Kostant_space ( self , i:sage.rings.integer.Integer , j:sage.rings.integer.Integer , restriction:str or None =None ) -> Iterator[ 'sage.combinat.root_system.weight_space.WeightSpace_with_category.element_class' ] :
        """
        Returns the K(G,P,i,j) as introduced in [BS2023].

        INPUT:
        - ``self``           -- minimal_irreducible_homogeneous_variety, base space X=G/P.
        - ``i``              -- integer.
        - ``j``              -- integer.
        - ``restriction``    -- string.

        OUTPUT:
        - ``Weight`` -- sage.combinat.root_system.weight_space.WeightSpace_with_category.element_class; highest weight corresponding to irreducible summand in K(G,P,i,j).


        REFERENCE:
        [BS2023] Belmans, Pieter; Smirnov, Maxim. Hochschild cohomology of generalised Grassmannians.
        """
        # basis
        fw          = dict( self._parabolic_subgroup._parent_group.Cartan_type().root_system().weight_space().fundamental_weights() )
        rho         = sum(list(fw.values())) # sum of fundamental weights
        ambt        = { node : vector( QQ , (node-1)*[ 0 ] + [ 1 ] + (self._parabolic_subgroup._parent_group._Cartan_degree-node)*[ 0 ] )
                        for node in [ 1 .. self._parabolic_subgroup._parent_group._Cartan_degree ]
                      }
        base_change = matrix( QQ , [ sum([ omega.to_ambient()[node-1]*e for node , e in ambt.items() ])
                                     for omega in fw.values()
                                   ]
                            ).transpose().inverse() # Cartan matrix describing base change from ambt to fw
        # Weyl group
        WG   = self._parabolic_subgroup._parent_group.Weyl_group()
        sr   = WG.simple_reflections()
        # Weyl character ring
        WCR = self._parabolic_subgroup._parent_group.Weyl_character_ring()

        # integer invariants
        dimension = self.dimension()   # dimension
        Fano_index = self.Fano_index() # Fano index

        for Weyl_element , reduced_description in self.Weyl_group_coset_representatives_of_minimal_length() :
            if len(reduced_description) == dimension-i :
                # See (1.7): Weight = WeylElement \cdot 0 + ( FanoIndex + j ) * fw[k]
                result = Weyl_element.action(rho.to_ambient()) - rho.to_ambient() +  (Fano_index+j)*fw[self._parabolic_subgroup._excluded_node].to_ambient()
                vector_with_respect_to_ambt_basis = vector( QQ , [ result.coefficient(node) for node in range(self._parabolic_subgroup._parent_group._Cartan_degree) ] )
                vector_with_respect_to_fw_basis   = base_change*vector_with_respect_to_ambt_basis
                weight = sum([ coefficient*fw[node] for node , coefficient in enumerate( vector_with_respect_to_fw_basis , start=1 ) ])

                if   restriction in [ None , 'None' , 'none' , '' ] :
                    yield weight
                elif restriction in [ 'Regular' , 'regular' , 'Reg' , 'reg' , 'Non-Singular' , 'non-singular' , 'Non-Sing' , 'non-sing' ] :
                    if self.is_regular( weight+rho ) : yield weight
                else :
                    raise ValueError('The input for ``restriction`` is anppropriate.')


    def is_adjoint ( self ) -> bool :
        """Tests if ``self`` is adjoint (cf. grassmannian.info)"""
        if   self._parabolic_subgroup._parent_group._Cartan_family == 'B' : return   self._parabolic_subgroup._excluded_node == 2
        elif self._parabolic_subgroup._parent_group._Cartan_family == 'C' : return   self._parabolic_subgroup._excluded_node == 1
        elif self._parabolic_subgroup._parent_group._Cartan_family == 'D' : return   self._parabolic_subgroup._excluded_node == 2 and 4 <= self._parabolic_subgroup._parent_group._Cartan_degree
        elif self._parabolic_subgroup._parent_group._Cartan_family == 'E' : return ( self._parabolic_subgroup._excluded_node == 2 and self._parabolic_subgroup._parent_group._Cartan_degree == 6 ) or \
                                                                                   ( self._parabolic_subgroup._excluded_node == 1 and self._parabolic_subgroup._parent_group._Cartan_degree == 7 ) or \
                                                                                   ( self._parabolic_subgroup._excluded_node == 8 and self._parabolic_subgroup._parent_group._Cartan_degree == 8 )
        elif self._parabolic_subgroup._parent_group._Cartan_family == 'F' : return   self._parabolic_subgroup._excluded_node == 1 and self._parabolic_subgroup._parent_group._Cartan_degree == 4
        elif self._parabolic_subgroup._parent_group._Cartan_family == 'G' : return   self._parabolic_subgroup._excluded_node == 2 and self._parabolic_subgroup._parent_group._Cartan_degree == 2
        else                                                              : return False


    def is_exceptional ( self ) -> bool :
        """Test if the Cartan family of ``self`` is out of [ E , F , G ]."""
        return self._parabolic_subgroup._parent_group.ADMISSIBLE_CARTAN_FAMILIES[self._parabolic_subgroup._parent_group._Cartan_family][1] < +infinity


    def is_ordinary ( self ) -> bool :
        """Test if the Cartan family of ``self`` is out of [ A , B , C , D ]."""
        return not self.is_exceptional()


    def is_regular ( self , weight:'sage.combinat.root_system.weight_space.WeightSpace_with_category.element_class' ) -> bool :
        """Tests if a given weight on ``self`` is G-regular (i.e. does not ly on a wall of a Weyl chamber)."""
        return not self.is_singular( weight )


    def is_singular ( self , weight:'sage.combinat.root_system.weight_space.WeightSpace_with_category.element_class' ) -> bool :
        """Tests if a given weight on ``self`` is G-singular (i.e. lies on a wall of a Weyl chamber)."""
        assert weight in self._parabolic_subgroup._parent_group.Cartan_type().root_system().weight_space() , \
               ValueError('The weight must be an element of the weight space: '+str(self._parabolic_subgroup._parent_group.Cartan_type().root_system().weight_space()))
        # Move ``Weight`` to dominant chamber
        weight_in_dominant_chamber = weight.to_dominant_chamber()
        # Consider list of reflections of ``weight`` and check whether ``weight`` is invariant under some reflection
        reflections = [ weight_in_dominant_chamber.simple_reflection( index ) for index in self._parabolic_subgroup._parent_group.Cartan_type().index_set() ]
        return weight_in_dominant_chamber in reflections


    def Weyl_group_coset_representatives_of_minimal_length ( self ) -> Iterator[ tuple[ 'sage.combinat.root_system.weyl_group.WeylGroup_gens_with_category.element_class' , list ] ] :
        """Returns the Weyl group coset representatives of minimal length"""
        WG = self._parabolic_subgroup._parent_group.Weyl_group()
        sr = WG.simple_reflections()
        identity = sr[1]*(sr[1].inverse())

        stock = [ [ i+1 for i in w._reduced_word ] for w in WeylGroup( self._parabolic_subgroup._parent_group.Cartan_type() , implementation='permutation' ).iteration('breadth',True) ]
        stock = [ ( prod([ identity ] + [ sr[node] for node in reduced_description ]) , reduced_description ) for reduced_description in stock ]

        for Weyl_element_0 , reduced_description_0 in stock :
            length_0 = len(reduced_description_0)

            Weyl_element_0_is_coset_representaion_of_minimal_length = True
            for node in self._parabolic_subgroup.included_nodes() :
                Weyl_element_1 = sr[node]*Weyl_element_0

                for Weyl_element , reduced_description in stock :
                    if Weyl_element_1 == Weyl_element :
                        reduced_description_1 = reduced_description
                        length_1 = len(reduced_description_1)
                        break

                if length_1 != length_0+1 :
                    Weyl_element_0_is_coset_representaion_of_minimal_length = False
                    break

            if Weyl_element_0_is_coset_representaion_of_minimal_length :
                yield Weyl_element_0 , reduced_description_0