Grassmannian.sage

from Equivariant_Vector_Bundles_On_Homogeneous_Varieties.Base_Space.Homogeneous_Variety import Irreducible_Homogeneous_Variety



class Grassmannian ( Irreducible_Homogeneous_Variety ) :

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

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

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

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

        from Equivariant_Vector_Bundles_On_Homogeneous_Varieties.Base_Space.Homogeneous_Variety import Irreducible_Cartan_Group
        G = Irreducible_Cartan_Group( Cartan_Family='A' , Cartan_Degree=N-1 )
        P = G.Maximal_Parabolic_Subgroup( Excluded_Node=k )
        super( 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 'Gr('+str(self.k())+';'+str(self.N())+')'
        elif Output_Style == 'Long'  : return 'Grassmannian variety of '+str(self.k())+'-dimensional linear subspaces in a '+str(self.N())+'-dimensional ambient vector space.'
        else                         : raise ValueError('The input for ``Output_Style`` is inappropriate.')


    def Fano_Index ( self ) -> int :
        """Returns the Fano index of ``self``."""
        return self.N()


    def Fonarev_Collection ( self ) -> "Lefschetz_Collection" :
        """
        Returns Fonarev's (conjecturally full) minimal exceptional collection on ``self``.

        OUTPUT:
        - (Conjecturally full) minimal exceptional collection

        REFERENCE:
        - [Fon2012] Fonarev, A.: On minimal Lefschetz decompositions for Grassmannians
        """
        fw = self.Basis('fw')
        LC = self.Lefschetz_Collection( Starting_Block=[] , Support_Pattern='Trivial' )
        for YD , Orbit_Length in Young_Diagram.Minimal_Upper_Triangulars( self.N()-self.k() , self.k() ) :
            New_Object = self.Equivariant_Vector_Bundle( YD )
            LC += self.Lefschetz_Collection( Starting_Block=[New_Object] , Support_Pattern=tuple(Orbit_Length*[1]) )
        return LC


    def Kapranov_Collection ( self ) -> "Lefschetz_Collection" :
        """
        Returns Kapranov's full exceptional collection on ``self``.

        OUTPUT:
        - Full exceptional collection cU^alpha with n-k => alpha_1 => alpha_2 => ... => alpha_k => 0 (lexicographically orderd)

        REFERENCE:
        - [Kap1988] Kapranov, M. M.: On the derived categories of coherent sheaves on some homogeneous spaces. Invent. Math.92(1988), no.3, 479–508.
        """
        k = self.k()
        N = self.N()
        fw = self.Basis('fw')
        Weights = [ list(Weight)+[ 0 ] for Weight in IntegerListsLex( length=k , max_part=N-k , max_slope=0 ) ]
        Weights.reverse()
        Starting_Block = [ self.Irreducible_Equivariant_Vector_Bundle( sum([ self.Null_Weight() ] + [ (Weight[Node-1]-Weight[Node]) * fw[Node] for Node in [ 1 .. k ] ]) )
                           for Weight in Weights
                         ]
        Support_Pattern = 'Trivial'
        return self.Lefschetz_Collection( Starting_Block=Starting_Block , Support_Pattern=Support_Pattern )



class Projective_Space ( Grassmannian ) :

    def __init__( self , Dimension :int ) -> None :
        """
        Initialize the projective 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( Projective_Space , self ).__init__( k=1 , N=Dimension+1 )


    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 'PP^'+str(self.Dimension())
        elif Output_Style == 'Long'  : return 'Projective space of dimension '+str(self.Dimension())+'.'
        else                         : raise ValueError('The input for ``Output_Style`` is inappropriate.')


    def Beilinson_Collection ( self ) -> "Lefschetz_Collection" :
        """
        Returns Beilinson's full exceptional collection on ``self``.

        OUTPUT:
        - Lefschetz collection with starting block ( O_X ) and support partition (self.Dimension()+1)*[ 1 ].

        REFERENCE:
        - [Bei1978] Beilinson, A. A.: Coherent sheaves on Pn and problems in linear algebra. Funktsional. Anal. i Prilozhen.12(1978), no.3, 68–69.
        """
        Starting_Block = [ self.calO() ]
        Support_Pattern = tuple( (self.Dimension()+1)*[ 1 ])
        return self.Lefschetz_Collection( Starting_Block=Starting_Block , Support_Pattern=Support_Pattern )



class Dual_Projective_Space ( Grassmannian ) :

    def __init__( self , Dimension :int ) -> None :
        """
        Initialize the dual projective 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( Dual_Projective_Space , self ).__init__( k=Dimension , N=Dimension+1 )


    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 'PP^('+str(self.Dimension())+',v)'
        elif Output_Style == 'Long'  : return 'Dual projective space of dimension '+str(self.Dimension())+'.'
        else                         : raise ValueError('The input for ``Output_Style`` is inappropriate.')