Homogeneous_Variety.sage

from typing import Iterator
from Equivariant_Vector_Bundles_On_Homogeneous_Varieties.Foundation.Structure import Structure , Irreducible_Structure , Direct_Sum_Of_Structures
from Equivariant_Vector_Bundles_On_Homogeneous_Varieties.Base_Space.Cartan_Group import Irreducible_Cartan_Group
from Equivariant_Vector_Bundles_On_Homogeneous_Varieties.Base_Space.Parabolic_Subgroup import Parabolic_Subgroup_In_Irreducible_Cartan_Group



class Homogeneous_Variety ( Structure ) :

    BASIS_LABELLING = { 'sr'   : [ 'sr'   , 'simple roots'        , 'alphas'                                                                     , 'A' ] ,
                        'mx'   : [ 'mx'   , 'mixed'               , 'simple roots for included nodes and fundamental weights for excluded nodes' , 'B' ] ,
                        'fw'   : [ 'fw'   , 'fundamental weights' , 'omegas'                                                                     , 'C' ] ,
                        'ambt' : [ 'ambt' , 'ambient'             , 'e_i`s'                                                                      , 'D' ]
                      }



class Irreducible_Homogeneous_Variety ( Irreducible_Structure , Homogeneous_Variety ) :

    def __init__( self , Parabolic_Subgroup:Parabolic_Subgroup_In_Irreducible_Cartan_Group ) -> None :
        """
        Initialize a homogeneous variety X=G/P.

        INPUT:
        - ``Parabolic_Subgroup`` -- Parabolic_Subgroup_In_Irreducible_Cartan_Group ;

        OUTPUT: None.
        """
        assert isinstance( Parabolic_Subgroup , Parabolic_Subgroup_In_Irreducible_Cartan_Group ) , \
               TypeError('The input must be a parabolic subgroup in an irreducible Cartan group.')
        self._Parabolic_Subgroup = Parabolic_Subgroup


    def __repr__ ( self ) -> Parabolic_Subgroup_In_Irreducible_Cartan_Group :
        """Returns all attributes which are necessary to initialize the object."""
        return self.Parent_Group()


    def __str__ ( self , Output_Style='Long' ) -> str :
        """Returns a one-line string as short description."""
        if   Output_Style == 'Short' : return self.Parent_Group().Cartan_String() + '/P(' + str( self.Included_Nodes() ) + ')'
        elif Output_Style == 'Long'  : return 'Smooth projective variety ' + self.__str__( Output_Style='Short' ) + '.'
        else                         : raise ValueError('The input for ``Output_Style`` is inappropriate.')


    def Available_Negative_Roots ( self ) -> "Root" :
        """Returns all available negative roots."""
        for Root in self.Parent_Group().Cartan_Type().root_system().root_lattice().negative_roots() :
            if not Root in self.Parabolic_Subgroup().Negative_Roots() :
                yield Root


    def Available_Positive_Roots ( self ) -> "Root" :
        """Returns all available positive roots."""
        for Root in self.Parent_Group().Cartan_Type().root_system().root_lattice().positive_roots() :
            if not Root in self.Parabolic_Subgroup().Negative_Roots() :
                yield Root


    def Available_Roots ( self ) -> "Root" :
        """Returns all available roots."""
        for Root in self.Parent_Group().Cartan_Type().root_system().root_lattice().roots() :
            if not Root in self.Parabolic_Subgroup().Negative_Roots() :
                yield Root


    def Basis ( self , Label:str='mx' ) -> dict :
        """
        Returns the basis in terms of simple roots and fundamental weights.

        INPUT:
        - ``self`` -- Parabolic_Subgroup; the parabolic subgroup P of a Cartan group G.
        - ``Label`` -- str (default: 'mx');

        OUTPUT:
        - ``Output`` -- Dictionary.

        ALGORITHM:
        - alpha_i : the simple root associated to the i-th node.
        - omega_i : the fundamental weight associated to the i-th node.

        - sr = { alpha_i }
        - mx_{ i : i excluded } = { alpha_i : i included } cup { omega_i : i excluded }.
          Note: mx_{} = sr and mx_{ all i's } = fw
        - fw = { omega_i }
        - ambt = { standard basis e_i }
        """
        if   Label in self.BASIS_LABELLING['sr'] :
            return dict( self.Parent_Group().Cartan_Type().root_system().weight_space().simple_roots() )

        elif Label in self.BASIS_LABELLING['mx'] :
            MixedBasis = {}
            for Node in self.Parent_Group().Cartan_Type().index_set() :
                if Node in self.Parabolic_Subgroup().Included_Nodes() : Element = self.Parent_Group().Cartan_Type().root_system().weight_space().simple_root(Node)
                elif Node in self.Parabolic_Subgroup().Excluded_Nodes() : Element = self.Parent_Group().Cartan_Type().root_system().weight_space().fundamental_weight(Node)
                else : raise ValueError('Plausibility? The set of nodes subdivides into the disjoint union of marked ones and excluded ones.')
                MixedBasis.update( { Node : Element } )
            return MixedBasis

        elif Label in self.BASIS_LABELLING['fw'] :
            return dict( self.Parent_Group().Cartan_Type().root_system().weight_space().fundamental_weights() )

        elif Label in self.BASIS_LABELLING['ambt'] :
            n = self.Parent_Group().Cartan_Degree()
            return { Node : vector( QQ , (Node-1)*[ 0 ] + [ 1 ] + (n-Node)*[ 0 ] ) for Node in [ 1 .. n ] }

        else : raise ValueError('The input of ``Label`` is inappropriate.')


    # Synonym for the method ``Tautological_Subbundle``
    def calO ( self , *Twists:tuple[int] ) -> "Irreducible_Equivariant_Vector_Bundle" :
        """Returns the structure sheaf or a twist of it."""
        return self.Structure_Sheaf( *Twists )


    # Snynoms for different methods depending on the input
    def calU ( self , *Input ) -> "Irreducible_Equivaraint_Vector_Bundle" :
        """Returns the tautological subbundle (if there no input) or the irreequivariant vector bundle associated to a highest weight (if there is some input otherwise)."""
        if len(Input) == 0 : # Synonym for the method ``Tautological_Subbundle``
            return self.Tautological_Subbundle()

        else : # Synonym for the method ``Equivariant_Vector_Bundles``
            return self.Equivariant_Vector_Bundle( *Input )


    # Synonym for the method ``Trivial_Vector_Bundle``
    def calV ( self ) -> "Direct_Sum_Of_Equivariant_Vector_Bundles" :
        """Returns the trivial vector bundle ."""
        return self.Trivial_Vector_Bundle()


    def Cartan_Degree ( self ) -> int :
        """Returns the Cartan degree of the parent Group G."""
        return self.Parent_Group().Cartan_Degree()


    def Cartan_Family ( self ) -> str :
        """Returns the Cartan family of the parent Group G."""
        return self.Parent_Group().Cartan_Family()


    def Cartan_Matrix ( self , From:str='fw' , To:str='mx' ) -> Matrix :
        """
        Returns the base change between the bases sr, mx or fw.

        INPUT:
        - ``self`` -- Parabolic_Subgroup; the parabolic subgroup P of a Cartan group G.

        OUTPUT:
        - ``Output`` -- Matrix.

        ALGORITHM:
        - alpha_i : the simple root associated to the i-th node.
        - omega_i : the fundamental weight associated to the i-th node.

        - sr >> fw : Cartan matrix
        - fw >> sr : Inverse of Cartan matrix (sr >> fw)
        - mx >> fw : For each excluded node i, replace the i-th column by a standard vector e_i.
        - fw >> mx : Inverse of mx >> fw
        - sr >> mx : Composition of sr >> fw >> mx
        - mx >> sr : Inverse of sr >> mx
        """
        if   From in self.BASIS_LABELLING['sr']   : From = 'sr'
        elif From in self.BASIS_LABELLING['mx']   : From = 'mx'
        elif From in self.BASIS_LABELLING['fw']   : From = 'fw'
        elif From in self.BASIS_LABELLING['ambt'] : From = 'ambt'
        else : raise ValueError('The input for ``From`` is inappropriate.')
        if   To   in self.BASIS_LABELLING['sr']   : To = 'sr'
        elif To   in self.BASIS_LABELLING['mx']   : To = 'mx'
        elif To   in self.BASIS_LABELLING['fw']   : To = 'fw'
        elif To   in self.BASIS_LABELLING['ambt'] : To = 'ambt'
        else : raise ValueError('The input for ``To`` is inappropriate.')

        if   From == To : return matrix.identity( self.Parent_Group().Cartan_Degree() )

        elif From == 'sr' :
            if   To == 'mx'  : return self.Cartan_Matrix( From = 'fw' , To = 'mx') * self.Cartan_Matrix( From = 'sr' , To = 'fw')
            elif To == 'fw'  : return self.Parent_Group().Cartan_Type().cartan_matrix()
            elif To == 'ambt' :
                sr   = self.Basis('sr')
                ambt = self.Basis('ambt')
                return matrix( QQ , [ sum([ alpha.to_ambient()[Node-1]*e for Node , e in ambt.items() ]) for Node , alpha in sr.items() ] ).transpose()

        elif From == 'mx' :
            if   To == 'sr'  : return self.Cartan_Matrix( From = 'sr'  , To = 'mx' ).inverse()
            elif To == 'fw'  :
                Matrix = copy( self.Cartan_Matrix( From = 'sr' , To = 'fw' ) )
                for Node in self.Parabolic_Subgroup().Excluded_Nodes() :
                    Matrix[:,Node-1] = vector([ kronecker_delta( I , Node ) for I in [ 1 .. self.Parent_Group().Cartan_Degree() ] ])
                return Matrix
            elif To == 'ambt' : return self.Cartan_Matrix( From = 'fw' , To = 'ambt') * self.Cartan_Matrix( From = 'mx' , To = 'fw')

        elif From == 'fw' :
            if   To == 'sr'   : return self.Cartan_Matrix( From = 'sr'   , To = 'fw' ).inverse()
            elif To == 'mx'   : return self.Cartan_Matrix( From = 'mx'   , To = 'fw' ).inverse()
            elif To == 'ambt' :
                fw   = self.Basis('fw')
                ambt = self.Basis('ambt')
                return matrix( QQ , [ sum([ omega.to_ambient()[Node-1]*e for Node , e in ambt.items() ]) for Node , omega in fw.items() ] ).transpose()

        elif From == 'ambt' :
            if   To == 'sr'   : return self.Cartan_Matrix( From = 'sr'  , To = 'ambt' ).inverse()
            elif To == 'fw'   : return self.Cartan_Matrix( From = 'fw'  , To = 'ambt' ).inverse()
            elif To == 'mx'   : return self.Cartan_Matrix( From = 'mx'  , To = 'ambt' ).inverse()


    def Cartan_String ( self ) -> str :
        """Returns the Cartan string of the parent Group G."""
        return self.Parent_Group().Cartan_String()


    def Cartan_Type ( self ) -> CartanType :
        """Returns the attribute ``Cartan_Type`` of the parent Group G."""
        return self.Parent_Group().Cartan_Type()


    def Compare_Roots ( self , Root1 , Root2 ) -> str or None :
        """Returns None if the two roots are not comparable and a result '<', '==', or '>' otherwise."""

        RL = self.Parent_Group().Cartan_Type().root_system().root_lattice()
        assert Root1 in RL , \
               ValueError('The input for ``Root1`` is not a root.')
        assert Root2 in RL , \
               ValueError('The input for ``Root2`` is not a root.')

        if Root1 == Root2 :
            return '=='

        else :
            Difference_In_srBasis = Root1-Root2
            if        Difference_In_srBasis.is_positive_root() : return '>'
            elif (-1*Difference_In_srBasis).is_positive_root() : return '<'
            else                                               : return None


    def Compare_Weights ( self , Weight1 , Weight2 ) -> str or None :
        """Returns None if the two weights are not comparable and a result '<', '==', or '>' otherwise."""

        WS = self.Parent_Group().Cartan_Type().root_system().weight_space()
        assert Weight1 in WS , \
               ValueError('The input for ``Weight1`` is not a weight.')
        assert Weight2 in WS , \
               ValueError('The input for ``Weight2`` is not a weight.')

        if Weight1 == Weight2 :
            return '=='

        else :
            RL = self.Parent_Group().Cartan_Type().root_system().root_space()
            scr = RL.simple_coroots()
            sr = RL.simple_roots()
            Coefficients_For_fwBasis = [ (Weight1-Weight2).scalar(coroot) for coroot in scr ]
            Coefficients_For_srBasis = vector( QQ , Coefficients_For_fwBasis ) * self.Cartan_Matrix( From='fw' , To='sr' )
            Difference_In_srBasis = sum([ QQ(Coefficient)*sr[Node] for Node , Coefficient in enumerate( list( Coefficients_For_srBasis ) , start = 1 ) ])

            if        Difference_In_srBasis.is_positive_root() : return '>'
            elif (-1*Difference_In_srBasis).is_positive_root() : return '<'
            else                                               : return None


    def Complex ( self , Objects ) -> "Complex_Over_Irreducible_Homogeneous_Variety" :
        """Returns a complex of equivariant vector bundles over ``self``."""
        from Equivariant_Vector_Bundles_On_Homogeneous_Varieties.Overlying_Structure.Complex_Of_Equivariant_Vector_Bundles import Complex_Of_Coherent_Sheaves
        return Complex_Of_Coherent_Sheaves( Base_Space=self , Objects=Objects )


    # ..ToDo: For PP^n, it is only correct up to sign. 
    def Complex_Defining_Exterior_Power_Of_Tautological_Quotient_Bundle ( self , p :int =1 ) -> "Complex_Over_Irreducible_Homogeneous_Variety" :
        """Returns the complex defining the p-th exterior power of the tautological quotient bundle on ``self``."""
        assert isinstance( p , Integer ) , \
               'The input for `p` need to be an integer.'

        G = self.Parent_Group()
        fw = self.Basis('fw')
        Terms = dict({})
        for i in [ 0 .. p+1 ] :
            if i == 0 : Terms.update({ 0    : 'Cokernel' })
            else      : Terms.update({ -1*i : self.Tautological_Subbundle().Symmetric_Power( i-1 ).Multiply_By( G.rmV( fw[1] ).exterior_power( p-i+1 ) ) })
        return self.Complex( Terms )


    def Dimension ( self ) -> int :
        """Returns the dimension dim X = dim G - dim P."""
        return self.Parent_Group().Dimension() - self.Parabolic_Subgroup().Dimension()


    def Equivariant_Vector_Bundle ( self , *Inputs:tuple ) -> "Equivariant_Vector_Bundles" :
        """Returns the direct sum of equivariant vector bundles induced by the given highest weights."""
        Constituent_Parts = list(Inputs)
        from Equivariant_Vector_Bundles_On_Homogeneous_Varieties.Overlying_Structure.Equivariant_Vector_Bundle import Equivariant_Vector_Bundle
        return Equivariant_Vector_Bundle.Constructor( Base_Space=self , Constituent_Parts=Constituent_Parts )


    def Excluded_Nodes ( self ) -> set :
        """Returns the attribute ``Excluded_Nodes`` of the parabolic subgroup P."""
        return self.Parabolic_Subgroup().Excluded_Nodes()


    def Expected_Support_Partition_For_Minimal_Full_Lefschetz_Collection ( self ) -> tuple[ int ] :
        """Returns the expected support partition for a minimal Lefschetz collection on ``self``."""
        assert self.Parabolic_Subgroup().Is_Maximal() , \
               ValueError('The method is only implemented for those homogeneous varieties where the parabolic subgroup is maximal.')

        Collection__Expected_Length = self.K0().rank()
        Node , Fano_Index = next(self.Fano_Index())

        Rectangular_Part__Expected_Height = Fano_Index
        Rectangular_Part__Expected_Width = floor( Collection__Expected_Length / Rectangular_Part__Expected_Height )
        Residual_Part__Expected_Height = Collection__Expected_Length - Rectangular_Part__Expected_Height * Rectangular_Part__Expected_Width
        if Residual_Part__Expected_Height == 0 : Residual_Part__Expected_Width = 0
        else                                   : Residual_Part__Expected_Width = 1

        return tuple(                                    Residual_Part__Expected_Height * [ Rectangular_Part__Expected_Width+1 ] + \
                     (Rectangular_Part__Expected_Height-Residual_Part__Expected_Height) * [ Rectangular_Part__Expected_Width   ]   \
                    )


    def Fano_Index ( self ) -> Iterator[ tuple[ int , int ] ]:
        """
        Returns the Fano index of ``self``.

        INPUT:
        - ``self`` -- Parabolic_Subgroup; the parabolic subgroup P of a Cartan group G.

        OUTPUT:
        - ``Node`` -- Excluded node
        - ``Fano_Index`` -- Index associated to X = G/P(Excluded_Nodes={Node})

        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.Parent_Group().Cartan_Type().root_system().root_lattice()
        Ambient_Space = self.Parent_Group().Cartan_Type().root_system().ambient_space()

        for Node in self.Parabolic_Subgroup().Excluded_Nodes() :
            Beta = Root_Lattice.simple_root(Node).to_ambient() # The simple root associated to ``Node``
            Xi = Ambient_Space.fundamental_weight(Node) # The fundamental weight associated to ``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(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)
            yield Node , Fano_Index


    def Grothendieck_Group ( self ) -> FreeModule :
        """
        Returns the Grothendieck Group of X=G/P.

        INPUT:
        - ``self`` -- Homogeneous Variety.

        OUTPUT:
        - ``Output`` -- Integer; The rank of the Grothendieck group of X=G/P.

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

        It can be computed as the rank of the homology of X=G/P using the Bruhat cell decomposition,
        and is equal to #WG/#WL, where WG (resp. WL) denotes the Weyl group of G (resp. L).
        L is the Levi subgroup inside the maximal parabolic P.

        .. TODO:
        - Check if the rank of the Grothendieck group is always be given by the Euler characteristic.
        - Fix Rank_Of_GrothendieckGroup for Borel subgroups.

        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.
        """
        Cartan_Type_of_Parent_Group = self.Parent_Group().Cartan_Type()
        Weyl_Group_of_Parent_Group = Cartan_Type_of_Parent_Group.root_system().root_lattice().weyl_group()

        if self.Parabolic_Subgroup().Is_Borel() :
            # Question: Because WeylGroup_of_Levi_Part.cardinality() == 1?
            return Integers()^( Weyl_Group_of_Parent_Group.cardinality() )

        else :
            Cartan_Type_of_Levi_Part = self.Parent_Group().Cartan_Type().dynkin_diagram().subtype( self.Parabolic_Subgroup().Included_Nodes() )
            Weyl_Group_of_Levi_Part = Cartan_Type_of_Levi_Part.root_system().root_lattice().weyl_group()
            return Integers()^( Weyl_Group_of_Parent_Group.cardinality() / Weyl_Group_of_Levi_Part.cardinality() )


    def Kostant_Space ( self , i:int , j:int , Restriction:str or None =None ) -> Iterator[ "Weight" ] :
        """
        Returns the K(G,P,i,j) as introduced in [BS2023].

        INPUT:
        - ``self`` -- Homogeneous variety.
        - ``i``    -- integer.
        - ``j``    -- integer.

        OUTPUT:
        - ``Weight`` -- highest weight corresponding to irreducible summand in K(G,P,i,j).


        REFERENCE:
        [BS2023] Belmans, Pieter; Smirnov, Maxim. Hochschild cohomology of generalised Grassmannians.
        """
        G = self.Parent_Group()
        P = self.Parabolic_Subgroup()
        assert P.Is_Maximal() , \
               'The homogeneous variety ``self`` needs to be minimal; or equivalently, its associaed parabolic subgroup needs to be maximal.'
        k = self.k()

        # Weyl Group
        WG = WeylGroup( G.Cartan_Type() )
        sr = WG.simple_reflections()
        fw = self.Basis('fw')
        # Weyl Character Ring
        WCR = G.Weyl_Character_Ring()
        # Sum of fundamental weights
        Rho = sum(list(fw.values()))
        # Fano index
        Fano_Indices = { Node : Value for ( Node , Value ) in (G/P).Fano_Index() }
        assert len(Fano_Indices.keys()) == 1 and k in Fano_Indices.keys() , \
               'For minimal homogeneous variety, the Fano index needs to be a unique value associated to the excluded node k='+str(k)+'.'
        FanoIndex = Fano_Indices[k]
        # Dimension
        Dimension = self.Dimension()

        CM = self.Cartan_Matrix( From='ambt' , To='fw' )

        for WeylElement , ReducedDescription in self.Weyl_Group_Coset_Representatives_Of_Minimal_Length() :
            if len(ReducedDescription) == Dimension-i :
                # See (1.7): Weight = WeylElement \cdot 0 + ( FanoIndex + j ) * fw[k]
                Result = WeylElement.action(Rho.to_ambient()) - Rho.to_ambient() +  (FanoIndex+j)*fw[k].to_ambient()
                ambt_Description = vector( QQ , [ Result.coefficient(i) for i in range(G.Cartan_Degree()) ] )
                fw_Description   = CM*ambt_Description
                Weight = sum([ Coefficient*fw[Node] for Node , Coefficient in enumerate( fw_Description , 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 Kuznetsov_Polishchuk_Collection ( self ) -> Iterator[ tuple[ int , int , int , "weight" , str ] ] :
        """
        Returns the collection of Kuznetsov and Polishchuk on X=G/P.

        INPUT:
        - ``self`` -- Homogeneous variety.

        OUTPUT:
        - ``TotalCounter`` -- Counter running over all objects of the collection.
        - ``BlockCounter`` -- Counter running over all objects of the current block.
        - ``t`` -- Integer; block index.
        - ``Lambda`` -- highest weight of object.
        - ``cE`` -- string description of cE(Lambda).

        .. TODO:
        - Implement collection for exceptional cases.

        REFERENCE:
        [KP2016] Kuznetsov, Alexander; Polishchuk, Alexander Exceptional collections on isotropic Grassmannians.
                 J. Eur. Math. Soc. (JEMS) 18 (2016), no. 3, 507–574.
        """

        G = self.Parent_Group()
        assert G.Is_Irreducible() , \
               'The parent group of ``self`` need to be irreducible.'
        Cartan_Family = G.Cartan_Family()
        n = self.Cartan_Degree()

        P = self.Parabolic_Subgroup()
        assert P.Is_Maximal() , \
               'The parabolic subgroup of ``self`` need to be maximal.'
        k = self.k()

        Blocks = dict({})
        # Conjecture 9.8. on page 49
        if   Cartan_Family in [ 'A' ] :
            l = n+1-k
            # Collect all intersection points between a line segment from (0,0) to (k,l) and a grid { (x,y) : x \in ZZ or y \in ZZ }
            Slope = l/k
            Q = []
            for xRunner1 in [ 0 .. k ] :
                yRunner1 = Slope*xRunner1
                Q += [ ( xRunner1 , yRunner1 ) ]
                if xRunner1 < k: # Notice: 0 < Slope = (n+1)/k - 1 if and only if k < n+1
                    for yRunner2 in [ ceil(yRunner1) .. floor(yRunner1+Slope) ] :
                        xRunner2 = 1/Slope*yRunner2
                        if yRunner1 < yRunner2 and yRunner2 < yRunner1+Slope : Q += [ ( xRunner2 , yRunner2 ) ]
            for t , (x,y) in enumerate(Q) :
                a = floor(x)
                b = floor(y)
                c = k - ceil(x)
                d = l - ceil(y)
                Block = []
                for p1 in IntegerListsLex( length=a , min_part=t , max_part=d+t , max_slope=0 ) :
                    p1 = list(p1)
                    p2 = [ t for Node in [ a+1 .. k ] ]
                    p3 = [ 0 for Node in [ k+1 .. n+1-b ] ]
                    for p4 in IntegerListsLex( length=b , min_part=0 , max_part=c , max_slope=0 ) :
                        p4 = [ Entry-c for Entry in p4 ]
                        Highest_Weight = p1+p2+p3+p4
                        Block += [ Highest_Weight ]
                Block.reverse()
                Blocks.update({ t : Block })

        elif Cartan_Family in [ 'B' , 'D' ] :
            # Equation 56 on page 39
            if   Cartan_Family == 'B' : e = 1/2
            elif Cartan_Family == 'D' : e = 0

            # k <= n-1 if Cartan family is B or k <= n-2 if Cartan family is D
            # Theorem 9.1. on page 42
            if   k in [ 1 .. n+2*e-2 ] :
                for t in [ 0 .. k-1 ] :
                    Block = []
                    for p1 in IntegerListsLex ( length=t , min_part=t , max_part=2*n+2*e-k-2 , max_slope=0 ) :
                        p1 = list(p1)
                        p2 = [ t for Node in [ t+1 .. k ] ]
                        for p3 in IntegerListsLex ( length=n-k , min_part=(2*e-1)*t , max_part=floor((k-t)/2) , max_slope=0 ) :
                            p3 = list(p3)
                            Highest_Weight = p1+p2+p3
                            if Highest_Weight[n-1] >= (2*e-1)*Highest_Weight[n-2] : Block += [ Highest_Weight ]
                    Block.reverse()
                    Blocks.update({ t : Block })
                    Block = []
                    for p1 in IntegerListsLex ( length=t , min_part=t , max_part=2*n+2*e-k-2 , max_slope=0 ) :
                        p1 = [ Entry+1/2 for Entry in p1 ]
                        p2 = [ t+1/2 for Node in [ t+1 .. k ] ]
                        for p3 in IntegerListsLex ( length=n-k , min_part=ceil((2*e-1)*t-1/2) , max_part=floor((k-t)/2-1/2) , max_slope=0 ) :
                            p3 = [ Entry+1/2 for Entry in p3 ]
                            Highest_Weight = p1+p2+p3
                            if Highest_Weight[n-1] >= (2*e-1)*Highest_Weight[n-2] : Block += [ Highest_Weight ]
                    Block.reverse()
                    Blocks.update({ t+1/2 : Block })
                for t in [ k .. 2*n+2*e-k-2 ] :
                    Block = []
                    for p1 in IntegerListsLex ( length=k-1 , min_part=t , max_part=2*n+2*e-k-2 , max_slope=0 ) :
                        p1 = list(p1)
                        p2 = [ t ]
                        p3 = [ 0 for Node in [ k+1 .. n ] ]
                        Highest_Weight = p1+p2+p3
                        Block += [ Highest_Weight ]
                    Block.reverse()
                    Blocks.update({ t : Block })

            # k == n if Cartan family is B or k from { n-1 , n } if Cartan family is D
            # Theorem 9.3. on page 43
            elif k in [ n+2*e-1 .. n ] :
                # D_n/P_n-1 and D_n/P_n are both isomorphic to B_n-1/P_n-1
                if Cartan_Family == 'D' :
                    Cartan_Family = 'B'
                    n = n-1
                    k = n
                for t in [ 0 .. n-1 ] :
                    Block = []
                    for p1 in IntegerListsLex ( length=t , min_part=t , max_part=n-1 , max_slope=0 ) :
                        p1 = list(p1)
                        p2 = [ t for Node in [ t+1 .. n ] ]
                        Highest_Weight = p1+p2
                        Block += [ Highest_Weight ]
                    Block.reverse()
                    Blocks.update({ 2*t   : Block })
                    Blocks.update({ 2*t+1 : [ [ Entry+1/2 for Entry in Highest_Weight ] for Highest_Weight in Blocks[2*t] ] })

        # Theorem 9.2. on page 42
        elif Cartan_Family == 'C' :
            for t in [ 0 .. k-1 ] :
                Block = []
                for p1 in IntegerListsLex ( length=t , min_part=t , max_part=2*n-k , max_slope=0 ) :
                    p1 = list(p1)
                    p2 = [ t for Node in [ t+1 .. k ] ]
                    for p3 in IntegerListsLex ( length=n-k , min_part=0 , max_part=floor((k-t)/2) , max_slope=0 ) :
                        p3 = list(p3)
                        Highest_Weight = p1+p2+p3
                        Block += [ Highest_Weight ]
                Block.reverse()
                Blocks.update({ t : Block })
            for t in [ k .. 2*n-k ] :
                Highest_Weights = []
                for p1 in IntegerListsLex ( length=k-1 , min_part=t , max_part=2*n-k , max_slope=0 ) :
                    p1 = list(p1)
                    p2 = [t]
                    p3 = [ 0 for Node in [ k+1 .. n ] ]
                    Highest_Weight = p1+p2+p3
                    Block += [ Highest_Weight ]
                Block.reverse()
                Blocks.update({ t : Block })

        else :
            raise ValueError('The algorithm is not implement for the exceptional cases E_6, E_7, E_8, F_4, or G_2.')

        fw = self.Basis('fw')
        CM = self.Cartan_Matrix( From='ambt' , To='fw' )
        if Cartan_Family == 'A' :
            CM = block_matrix( QQ , [ [ CM , matrix( QQ , (n-1)*[ [0] ] + [ [-1] ] ) ] ] , subdivide=False )
        TotalCounter = 0
        for t , Block in Blocks.items() :
            Previous_Objects = []
            for BlockCounter , Highest_Weight_in_ambtBasis in enumerate( Block , start=1 ) :
                TotalCounter += 1
                Highest_Weight_in_fwBasis = CM*vector( QQ , Highest_Weight_in_ambtBasis )
                Highest_Weight = sum([ Coefficient*fw[Node] for Node , Coefficient in enumerate( Highest_Weight_in_fwBasis , start=1 ) ])
                cU = str(self.calU(Highest_Weight))
                if   Cartan_Family in [ 'A' ]             :
                    cE = cU
                elif Cartan_Family in [ 'B' , 'C' , 'D' ] :
                    if len(Previous_Objects) == 0 : cE = cU
                    else                          : cE = 'Right mutation of '+cU+' through <'+', '.join(Previous_Objects)+'>'
                yield TotalCounter , BlockCounter , t , Highest_Weight , cE
                Previous_Objects += [ cU ]


    def Included_Nodes ( self ) -> set :
        """Returns the attribute ``Included_Nodes`` of the parabolic subgroup P."""
        return self.Parabolic_Subgroup().Included_Nodes()


    def Irreducible_Equivariant_Vector_Bundle ( self , Highest_Weight:"Weight" ) -> "Irreducible_Equivariant_Vector_Bundle" :
        """Returns the equivariant vector bundle induced by the given highest weight."""
        if Highest_Weight == 0 :
            fw = self.Basis('fw')
            Highest_Weight = 0 * fw[1]
        from Equivariant_Vector_Bundles_On_Homogeneous_Varieties.Overlying_Structure.Equivariant_Vector_Bundle import Irreducible_Equivariant_Vector_Bundle
        return Irreducible_Equivariant_Vector_Bundle( Base_Space=self , Highest_Weight=Highest_Weight )


    # ..ToDo : Improve the testing. Get a cleaner algorithm based immediately on the definition.
    def Is_Adjoint ( self ) -> bool :
        """Tests if ``self`` is adjoint (cf. grassmannian.info)"""
        G = self.Parent_Group()
        Cartan_Family = G.Cartan_Family()
        Cartan_Degree = G.Cartan_Degree()
        P = self.Parabolic_Subgroup()
        assert P.Is_Maximal() , \
               ValueError('This method is only implemented for maximal parabolic subgroups.')
        k = self.k()
        if   Cartan_Family == 'B' : return k == 2
        elif Cartan_Family == 'C' : return k == 1
        elif Cartan_Family == 'D' : return k == 2 and 4 <= Cartan_Degree
        elif Cartan_Family == 'E' : return ( Cartan_Degree == 6 and k == 2 ) or ( Cartan_Degree == 7 and k == 1 ) or ( Cartan_Degree == 8 and k == 8 )
        elif Cartan_Family == 'F' : return ( Cartan_Degree == 4 and k == 1 )
        elif Cartan_Family == 'G' : return ( Cartan_Degree == 2 and k == 2 )
        else                      : return False


    # ..ToDo : Improve the testing. Get a cleaner algorithm based immediately on the definition.
    def Is_Coadjoint ( self ) -> bool :
        """Tests if ``self`` is coadjoint (cf. grassmannian.info)"""
        G = self.Parent_Group()
        Cartan_Family = G.Cartan_Family()
        Cartan_Degree = G.Cartan_Degree()
        P = self.Parabolic_Subgroup()
        assert P.Is_Maximal() , \
               ValueError('This method is only implemented for maximal parabolic subgroups.')
        k = self.k()
        if   Cartan_Family == 'B' : return k == 1
        elif Cartan_Family == 'C' : return k == 2
        elif Cartan_Family == 'D' : return k == 2 and 4 <= Cartan_Degree
        elif Cartan_Family == 'E' : return ( Cartan_Degree == 6 and k == 2 ) or ( Cartan_Degree == 7 and k == 1 ) or ( Cartan_Degree == 8 and k == 8 )
        elif Cartan_Family == 'F' : return ( Cartan_Degree == 4 and k == 4 )
        elif Cartan_Family == 'G' : return ( Cartan_Degree == 2 and k == 1 )
        else                      : return False


    # ..ToDo : Improve the testing. Get a cleaner algorithm based immediately on the definition.
    def Is_Cominuscule ( self ) -> bool :
        """Tests if ``self`` is cominuscule (cf. grassmannian.info)"""
        G = self.Parent_Group()
        Cartan_Family = G.Cartan_Family()
        Cartan_Degree = G.Cartan_Degree()
        P = self.Parabolic_Subgroup()
        assert P.Is_Maximal() , \
               ValueError('This function is only implemented for maximal parabolic subgroups.')
        k = self.k()
        if   Cartan_Family == 'A' : return True
        elif Cartan_Family == 'B' : return k == 1
        elif Cartan_Family == 'C' : return k == Cartan_Degree
        elif Cartan_Family == 'D' : return k in [ 1 , CartenDegree-1 , Cartan_Degree ]
        elif Cartan_Family == 'E' : return ( Cartan_Degree == 6 and k in [ 1 , 6 ] ) or ( Cartan_Degree == 7 and k == 7 )
        else                      : return False


    # ..ToDo : Specify the type for the input ``Weight``!
    def Is_Levi_Dominant ( self , Weight ) -> bool :
        """Tests if a given weight on ``self`` is Levi-dominant (i.e. all coefficients over included nodes are non-negative)."""
        assert Weight in self.Parent_Group().Cartan_Type().root_system().weight_space() , \
               ValueError('The weight must be an element of the weight space: '+str(self.Parent_Group().Cartan_Type().root_system().weight_space()))
        for Node in self.Parabolic_Subgroup().Included_Nodes() :
            if Weight.coefficient(Node) < 0 : return False
        return True


    # ..ToDo : Improve the testing. Get a cleaner algorithm based immediately on the definition.
    def Is_Minuscule ( self ) -> bool :
        """Tests if ``self`` is minuscule (cf. grassmannian.info)"""
        G = self.Parent_Group()
        Cartan_Family = G.Cartan_Family()
        Cartan_Degree = G.Cartan_Degree()
        P = self.Parabolic_Subgroup()
        assert P.Is_Maximal() , \
               ValueError('This function is only implemented for maximal parabolic subgroups.')
        k = self.k()
        if   Cartan_Family == 'A' : return True
        elif Cartan_Family == 'B' : return k == Cartan_Degree
        elif Cartan_Family == 'C' : return k == 1
        elif Cartan_Family == 'D' : return k in [ 1 , CartenDegree-1 , Cartan_Degree ]
        elif Cartan_Family == 'E' : return ( Cartan_Degree == 6 and k in [ 1 , 6 ] ) or ( Cartan_Degree == 7 and k == 7 )
        else                     : return False


    def Is_Regular ( self , Weight:"Weight" ) -> bool :
        """Tests if a given weight on ``self`` is G-regular (i.e. does not ly on a wall of a Weyl chamber)."""
        assert Weight in self.Parent_Group().Cartan_Type().root_system().weight_space() , \
               ValueError('The weight must be an element of the weight space: '+str(self.Parent_Group().Cartan_Type().root_system().weight_space()))
        return not self.Is_Singular( Weight )


    def Is_Singular ( self , Weight:"Weight" ) -> 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.Parent_Group().Cartan_Type().root_system().weight_space() , \
               ValueError('The weight must be an element of the weight space: '+str(self.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.Parent_Group().Cartan_Type().index_set() ]
        return Weight_In_Dominant_Chamber in Reflections


    def k ( self ) -> int :
        """Returns the number ``k`` given in the realisation as Grassmannian."""
        P = self.Parabolic_Subgroup()
        Excluded_Nodes = P.Excluded_Nodes(Output_Type=list)
        if P.Is_Maximal() : return Excluded_Nodes[0]
        else              : return Excluded_Nodes


    # Synonym for the method ``Grothendieck_Group``
    def K0 ( self ) -> FreeModule :
        """Returns the Grothendieck Group of X=G/P."""
        return self.Grothendieck_Group()


    def Lefschetz_Collection ( self , Starting_Block , Twist=None , Support_Pattern='Trivial' ) -> "Lefschetz_Collection" :
        """Returns a Lefschetz collection over ``self``."""
        from Equivariant_Vector_Bundles_On_Homogeneous_Varieties.Overlying_Structure.Lefschetz_Collection import Lefschetz_Collection
        return Lefschetz_Collection( Base_Space=self , Starting_Block=Starting_Block , Twist=Twist , Support_Pattern=Support_Pattern )


    def Mapping ( self , Image:"Irreducible_Homogeneous_Variety" , Dictionary:dict , Output_Type:str='fw' ) -> dict :
        """
        INPUT:
        - ``self`` -- Irreducible homoegenous variety (Source)
        - ``Image`` -- Irreducible homoegenous variety (Image)
        - ``Dictionary`` -- Dictionary (Image); Description of the mapping on the level of simple roots
        - ``Output_Type`` -- str 'fw' (default) or 'sr'; Output on the level of fundamental weights (fw) or simple roots (sr)

        OUTPUT:
        - ``Output`` -- Dictionary; { Simple roots of Source : Root of Image } or { Fundamental weights of source : weight of Image }

        Caution: The mapping of the simple roots described by the input of ``Dictionary`` is a mapping of the form Torus(Image) --> Torus(Source)
           and therefore in the opposite direction as the underlying mapping Source --> Image.
        """
        Source = self
        sr_Source = Source.Basis('sr')
        fw_Source = Source.Basis('fw')

        assert isinstance( Image , Irreducible_Homogeneous_Variety ) , \
               'The input for ``Image`` need Image be an irreducible homogeneous variety.'
        WeightSpace_Image = Image.Parent_Group().Cartan_Type().root_system().weight_space()
        sr_Image = Image.Basis('sr')
        fw_Image = Image.Basis('fw')

        assert isinstance( Dictionary , dict ) , \
               'The input for ``Dictionary`` need Image be a dictionary.'

        srOutput = dict({})
        for Node in sr_Source.keys() :
            From = sr_Source[Node]
            assert From in Dictionary.keys() , \
                   'The '+str(Node)+'-th simple root of ```self``` is not a key in ```Dictionary```.'
            To = Dictionary[From]
            assert To in WeightSpace_Image , \
                   'The values of the dictionary need to be roots of weight space `'+str(WeightSpace_Image)+'`.'
            srOutput.update({ From : To })

        if Output_Type in self.BASIS_LABELLING['sr'] :
            return srOutput
        elif Output_Type in self.BASIS_LABELLING['fw'] :

            fwOutput = { fw_Source[Node] : sum([ Coefficient*srOutput[sr_Source[i]] for i , Coefficient in enumerate( Row , start=1 ) ])
                        for Node , Row in enumerate( Source.Parent_Group().Cartan_Type().cartan_matrix().inverse().transpose() , start=1 )
                       }
            return fwOutput
        else :
            raise ValueError('The input for ``Output_Type`` is inappropriate.')


    def N ( self ) -> int :
        """Returns the number ``N`` given in the realisation as Grassmannian."""
        G = self.Parent_Group()
        assert G.Is_Ordinary() , \
               ValueError('This method is only implemented for ordinary parent groups.')
        Cartan_Family = G.Cartan_Family()
        Cartan_Degree = G.Cartan_Degree()
        if   Cartan_Family == 'A' : return   Cartan_Degree + 1 # Grassmannians Gr(k,N) or Flag varieties FL( k1 , k2 , ... ; N )
        elif Cartan_Family == 'B' : return 2*Cartan_Degree + 1 # Orthogonal Grassmannians OGr(k,N) or orthogonal Flag varieties OFl( k1 , k2 , ... ; N )
        elif Cartan_Family == 'C' : return 2*Cartan_Degree     # Symplectic Grassmannians OGr(k,N) or symplectic Flag varieties SFl( k1 , k2 , ... ; N )
        elif Cartan_Family == 'D' : return 2*Cartan_Degree     # Orthogonal Grassmannians OGr(k,N) or orthogonal Flag varieties OFl( k1 , k2 , ... ; N )


    def Null_Weight ( self ) -> "Weight" :
        """Returns the null weight of ``self``."""
        fw = self.Basis('fw')
        return 0*fw[1]


    def Parent_Group ( self ) -> Irreducible_Cartan_Group :
        """Returns the parent group of ``self``."""
        return self.Parabolic_Subgroup().Parent_Group()


    def Parabolic_Subgroup ( self ) -> Parabolic_Subgroup_In_Irreducible_Cartan_Group :
        """Returns the attribute ``_Parabolic_Subgroup``."""
        return self._Parabolic_Subgroup


    # ..ToDo: Is not correct for Grassmannian!
    #def SemiSimplification_Of_G_Bundle ( self ) :
    #    """Returns the semi-simplification of the tangent bundle on ``self``."""
    #    sr = self.Basis('sr')
    #    calTB = self.Zero_Vector_Bundle()
    #    for Counter1 , Root1 in enumerate( self.Available_Negative_Roots() ) :
    #        Comparison = [ self.Compare_Roots( Root1 , Root2 ) for Root2 in self.Available_Negative_Roots() ]
    #        if not ( '>' in Comparison[ : Counter1 ] or '>' in Comparison[ Counter1+1 : ] ) :
    #            # Write the root as linear combination of weights; as we worked with negative roots, we had the lowest weights and therefore need to mulitply with -1.
    #            Highest_Weight = -1*sum([ Coefficient * sr[Node] for Node , Coefficient in Root1 ])
    #            calTB += self.Equivariant_Vector_Bundle( Highest_Weight )
    #
    #    return calTB


    def Structure_Sheaf ( self , *Twists:tuple[int] ) -> "Irreducible_Equivariant_Vector_Bundle" :
        """Returns the structure sheaf or a twist of it."""
        if len(Twists) == 0 : Twists = tuple( len(self.Excluded_Nodes())*[0] )
        else :
            assert len(Twists) == len(self.Excluded_Nodes()) , \
                   ValueError('The input for ``Twists`` must be of the length ' + str( len(self.Excluded_Nodes()) ) +'(= number of excluded nodes).')
            for Twist_Counter , Twist in enumerate( Twists , start=1 ) :
                assert Twist in Integers() , 'The input data of the ' + str(Twist_Counter) + 'th twist is not an integer.'
        fw = self.Basis('fw')
        return self.Irreducible_Equivariant_Vector_Bundle( sum([ Twists[Counter]*fw[Node] for Counter , Node in enumerate( self.Excluded_Nodes() ) ]) )


    def Tautological_Subbundle ( self ) -> "Irreducible_Equivariant_Vector_Bundle" :
        """Returns the tautological subbundle, i.e. the dual of the equivariant vector bundle induced by the highest weight omega_1."""
        fw = self.Basis('fw')
        return self.Irreducible_Equivariant_Vector_Bundle( fw[1] ).Dual()


    def Trivial_Vector_Bundle ( self ) -> "Direct_Sum_Of_Equivariant_Vector_Bundles" :
        """Returns the trivial vector bundle, i.e. V^{ omega_1 } * calO."""
        fw = self.Basis('fw')
        return self.calO() * self.Parent_Group().rmV( fw[1] )


    # Synonym for the method ``Equivariant_Vector_Bundle``
    def VB ( self , *Input :tuple ) -> "Direct_Sum_Of_Equivariant_Vector_Bundle" :
        """Returns the equivariant vector bundle induced by the given highest weights."""
        return self.Equivariant_Vector_Bundle( *Input )


    def Weyl_Group_Coset_Representatives_Of_Minimal_Length ( self ) : #-> Iterator[ "Weyl group element" ] :
        """Returns the Weyl group coset representatives of minimal length"""
        G = self.Parent_Group()
        WG = WeylGroup( G.Cartan_Type() )
        sr = WG.simple_reflections()
        Identity = sr[1]*(sr[1].inverse())

        Stock = [ [ i+1 for i in w._reduced_word ] for w in WeylGroup( G.Cartan_Type() , implementation='permutation' ).iteration('breadth',True) ]
        Stock = [ ( prod([ Identity ] + [ sr[Node] for Node in ReducedDescription ]) , ReducedDescription ) for ReducedDescription in Stock ]

        for WeylElement0 , ReducedDescription0 in Stock :
            Length0 = len(ReducedDescription0)

            WeylElement0_Is_CosetRepresentaion_Of_Minimal_Length = True
            for Node in self.Parabolic_Subgroup().Included_Nodes(Output_Type=list) :
                WeylElement1 = sr[Node]*WeylElement0

                for WeylElement , ReducedDescription in Stock :
                    if WeylElement1 == WeylElement :
                        ReducedDescription1 = ReducedDescription
                        Length1 = len(ReducedDescription1)
                        break

                if Length1 != Length0+1 :
                    WeylElement0_Is_CosetRepresentaion_Of_Minimal_Length = False
                    break

            if WeylElement0_Is_CosetRepresentaion_Of_Minimal_Length :
                yield WeylElement0 , ReducedDescription0


    def Zero_Vector_Bundle ( self ) -> "Direct_Sum_Of_Equivariant_Vector_Bundle" :
        """Returns the zero vector bundle over ``self``."""
        return self.Equivariant_Vector_Bundle()



class Direct_Sum_Of_Homogeneous_Varieties ( Direct_Sum_Of_Structures , Homogeneous_Variety ) :
    pass