Orthogonal_Grassmannian.sage

from typing import Iterator
from Equivariant_Vector_Bundles_On_Homogeneous_Varieties.Base_Space.Homogeneous_Variety import Irreducible_Homogeneous_Variety



class Orthogonal_Grassmannian ( Irreducible_Homogeneous_Variety ) :

    def __init__( self , k :int , N :int ) -> None :
        """
        Initialize the Grassmannian OGr(k,N).

        INPUT:
        - ``k`` -- Integer ;
        - ``N`` -- Integer ;

        OUTPUT: None.
        """
        assert isinstance( N , Integer ) , \
               TypeError('The input for `N` must be an integer.')
        assert 5 <= N , \
               ValueError('The integer `N` must be equal to or greater than 5.')

        assert isinstance( k , Integer ) , \
               TypeError('The input for `k` must be an integer.')
        assert k in [ 1 .. floor(N/2) ] , \
               ValueError('The integer `k` need to be in the range '+str([ 1 .. floor(N/2) ])+'.')

        from Equivariant_Vector_Bundles_On_Homogeneous_Varieties.Base_Space.Homogeneous_Variety import Irreducible_Cartan_Group
        if N % 2 == 0 :
            G = Irreducible_Cartan_Group( Cartan_Family='D' , Cartan_Degree=N/2 )
            if k in [ 1 .. N/2-2 ] : P = G.Maximal_Parabolic_Subgroup( Excluded_Node=k )
            elif k == N/2-1        : P = G.Parabolic_Subgroup( Excluded_Nodes={N/2-1,N/2} )
            elif k == N/2          : P = G.Maximal_Parabolic_Subgroup( Excluded_Node=N/2-1 )
        else          :
            G = Irreducible_Cartan_Group( Cartan_Family='B' , Cartan_Degree=floor(N/2) )
            P = G.Maximal_Parabolic_Subgroup( Excluded_Node=k )

        super( Orthogonal_Grassmannian , self ).__init__( P )


    def __repr__ ( self ) -> tuple[ int ] :
        """Returns all attributes which are necessary to initialize the object."""
        return self.k() , self.N()


    def __str__ ( self , Output_Style='Long' ) -> str :
        """Returns a one-line string as short description."""
        if   Output_Style == 'Short' : return 'OGr('+str(self.k())+';'+str(self.N())+')'
        elif Output_Style == 'Long'  : return 'Orthogonal grassmannian variety of '+str(self.k())+'-dimensional isotropic linear subspaces' + \
                                              ' in a '+str(self.N())+'-dimensional ambient vector space.'
        else                         : raise ValueError('The input for ``Output_Style`` is inappropriate.')


    # Synonym for the method ``Spinor_Bundle``
    def calS ( self ) -> "Irreducible_Equivariant_Vector_Bundle" :
        """Returns the spinor bundle ."""
        return self.Spinor_Bundle()


    def Fano_Index ( self ) -> int :
        """Returns the Fano index of ``self``."""
        for Node , Fano_Index in super( Orthogonal_Grassmannian , self ).Fano_Index() :
            if Node == self.k() : return Fano_Index
        raise ValueError('PROBLEM! We could not compute the Fano index.')


    def My_Collection ( self , Modus :str ='Consecutive' , Parts :list =[1,2] ) -> "Lefschetz_Collection" :
        assert isinstance( Modus , str ) , \
               'The input for `Modus` need to be a string.'

        if Modus in [ 'Consecutive' , 'Con' ] :
            ConLC  = self.Lefschetz_Collection( Starting_Block=[] )
            ConLC += self.Tautological_Collection( Parts=Parts )
            ConLC += self.Spinor_Collection()
            return ConLC

        elif Modus in [ 'Alternating' , 'Alt' ] :
            ConLC = self.My_Collection( Modus='Consecutive' , Parts=Parts )
            Stock = dict({})
            for ColumnCounter in range(ConLC.Width()) :
                Orbit = ConLC.Subcollection( Columns=[ColumnCounter] )
                d = max([ Summand.Highest_Weight().to_ambient()[0] for Summand in Orbit[0].Irreducible_Components() ])
                if not d in Stock.keys() : Stock.update({ d : self.Lefschetz_Collection( Starting_Block=[] ) })
                Stock[d] += Orbit
            AltLC = self.Lefschetz_Collection( Starting_Block=[] )
            for d , Part in sorted(Stock.items()) :
                AltLC += Part
            return AltLC

        else :
            raise ValueError( 'The input for `Modus` is unknown.' )


    def Spinor_Bundle ( self , Parity : int or str or None =None ) -> "Irreducible_Equivariant_Vector_Bundle" :
        """Returns the spinor bundle."""
        Cartan_Family = self.Cartan_Family()
        n = self.Cartan_Degree()
        fw = self.Basis('fw')
        if   Cartan_Family == 'B' :
            return self.calU( fw[n] )

        elif Cartan_Family == 'D' :
            if   Parity in [  1 , '+' ] : return self.calU( fw[n-1] )
            elif Parity in [ -1 , '-' ] : return self.calU( fw[n] )
            else               : raise ValueError('For the Cartan Family D, there need to be a parity `+` or `-`.')

        else :
            raise ValueError('Conflict! There are only spinor bundles for Cartan families B_n and D_n respectively.')


    def Spinor_Collection ( self ) -> "Lefschetz_Collection" :
        Cartan_Family = self.Parent_Group().Cartan_Family()
        n = self.Parent_Group().Cartan_Degree()
        k = self.k()
        fw = self.Basis('fw')
        LC = self.Lefschetz_Collection( Starting_Block=[] , Support_Pattern='Trivial' )
        if   Cartan_Family == 'B' :
            Starting_Block = []
            if k == 1 :
                Starting_Block = [ self.calU( fw[n] ) ]
                Support_Partition = tuple( [ 1 ] )
                LC += self.Lefschetz_Collection( Starting_Block=Starting_Block , Support_Pattern=Support_Partition )

            elif k == 2 :
                if n == 2 :
                    pass

                else :
                    Starting_Block = [ self.calU( fw[n] ) ]
                    Support_Partition = tuple( (2*n-2)*[ 1 ] )
                    LC += self.Lefschetz_Collection( Starting_Block=Starting_Block , Support_Pattern=Support_Partition )

            elif 3 <= k :
                if k < n : Starting_Block += [ self.calU(fw[n]) ]
                Starting_Block += [ self.calU( Degree*fw[1]+fw[n] ).Extend_Equivariantly_By( self.calU( (Degree-1)*fw[1]+fw[n] ) )
                                    for Degree in range(1,n-k+1)
                                  ]
                Support_Partition = tuple( self.Fano_Index()*[ len(Starting_Block) ] )
                LC += self.Lefschetz_Collection( Starting_Block=Starting_Block , Support_Pattern=Support_Partition )

                if k == 3 :
                    if n == 3 :
                        Starting_Block = [ self.calU( fw[1] ).Extend_Equivariantly_By( self.calO() ) ]
                        Support_Partition = tuple( 2*[ 1 ] )
                    else      :
                        Starting_Block = [ self.calU( (n-2)*fw[1]+fw[n] ).Extend_Equivariantly_By( self.calU( (n-3)*fw[1]+fw[n] ) ) ]
                        Support_Partition = tuple( (n-2)*[ 1 ] )
                    LC += self.Lefschetz_Collection( Starting_Block=Starting_Block , Support_Pattern=Support_Partition )

        elif Cartan_Family == 'D' :
            pass

        return LC


    def Spinor_Filtration ( self , Parity :str or None =None , Factor :"Equivariant_Vector_Bundle" or None =None ) -> Iterator[ str ] :
        """
        Returns the filtration on the spinor bundle.

        REFERENCE:
        - [Kuz08a] Kuznetsov, Alexander: Exceptional collections for Grassmannians of isotropic lines.
        """
        if Factor == None : Factor = self.calO()
        assert isinstance( Factor , Equivariant_Vector_Bundle ) , \
               'The input for `Factor` need to be an equivariant vector bundle.'
        Cartan_Family = self.Cartan_Family()
        n = self.Cartan_Degree()
        k = self.k()
        fw = self.Basis('fw')
        if   Cartan_Family == 'B' :
            calS = self.calS()
            calU = self.calU()
            yield 'F_'+str(k+1)+' = 0'
            for i in range( k , -1 , -1 ) :
                Quotient = str( calS * calU.Exterior_Power(i) * Factor )
                yield '0 --> F_'+str(i+1)+' --> F_'+str(i)+' --> '+str(Quotient)+' --> 0'
            yield 'F_0 = '+str( Factor.Multiply_By( calS.H0() ) )

        elif Cartan_Family == 'D' :
            if   Parity in [  1 , '+' ] : ParityStr = '+' ; ParityInt = 1
            elif Parity in [ -1 , '-' ] : ParityStr = '-' ; ParityInt = -1
            else                        : raise ValueError('For the Cartan Family D, there need to be a parity in '+str([ 1 , '+' ])+' or in '+str([ -1 , '-' ])+'.')
            yield 'F^'+ParityStr+'_'+str(k+1)+' = 0'
            for i in range( k , -1 , -1 ) :
                Quotient = str( self.calS( ParityInt * (-1)^i ) * calU.Exterior_Power(i) * Factor )
                yield '0 --> F^'+ParityStr+'_'+str(i+1)+' --> F^'+ParityStr+'_'+str(i)+' --> '+str(Quotient)+' --> 0'
            yield 'F_0 = '+str( Factor.Multiply_By( self.calS(Parity).H0() ) )

        else :
            raise ValueError('Conflict! There are only spinor bundles for Cartan families B_n and D_n respectively.')


    def Tautological_Collection ( self , Parts :list =[1,2] ) -> "Lefschetz_Collection" :
        n = self.Parent_Group().Cartan_Degree()
        k = self.k()
        fw = self.Basis('fw')

        assert isinstance( Parts , list ) , \
               'The input for ``Parts`` need to be a list.'

        Universe = []
        # Initialise part 2 (if desired)
        if 2 in Parts :
            if k == 3 :
                for Partition in IntegerListsLex( length=3 , \
                                                  floor=[ n-2 , 0 , 0 ] , ceiling=[ floor(3/2*(n-3)) , ceil(1/2*(n-3)) , 0 ] , \
                                                  #max_sum=sum([ (k-i)*(n-k) for i in [ 1 .. k-1 ] ]) ,
                                                  min_slope=-n+3 , max_slope=0 \
                                                ) :
                    Partition = list(Partition)
                    Universe += [ [ Partition[Counter-1]-Partition[Counter] for Counter in range( 1 , len(Partition) ) ] ]

        # Initialise part 1 (if desired)
        if 1 in Parts :
            for Partition in IntegerListsLex( length=k , ceiling=(k-1)*[n-k]+[0] , max_slope=0 ) :
                Partition = list(Partition)
                Universe += [ [ Partition[Counter-1]-Partition[Counter] for Counter in range( 1 , len(Partition) ) ] ]

        Universe.reverse()
        Starting_Block = [ self.calU( sum([ self.Null_Weight() ] + [ Coefficient*fw[Node] for Node , Coefficient in enumerate( Coefficients , start=1 ) ]) )
                           for Coefficients in Universe
                         ]
        Support_Partition = self.Fano_Index() * [ len(Starting_Block) ]
        return self.Lefschetz_Collection( Starting_Block=Starting_Block , Support_Pattern=Support_Partition )



class Quadric_Space ( Orthogonal_Grassmannian ) :

    def __init__( self , Dimension :int ) -> None :
        """
        Initialize the quadratic space of a given dimension.

        INPUT:
        - ``Dimension`` -- Integer ;

        OUTPUT: None.
        """
        assert isinstance( Dimension , Integer ) , \
               TypeError('The input for `Dimension` must be an integer.')
        assert 0 < Dimension , \
               ValueError('The dimension must be greater than zero.')

        super( Quadric_Space , self ).__init__( k=1 , N=Dimension+2 )


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


    def __str__ ( self , Output_Style='Long' ) -> str :
        """Returns a one-line string as short description."""
        if   Output_Style == 'Short' : return 'Q^'+str(self.Dimension())
        elif Output_Style == 'Long'  : return 'Quadric space of dimension '+str(self.Dimension())+'.'
        else                         : raise ValueError('The input for ``Output_Style`` is inappropriate.')