Orthogonal_Grassmannian.sage.py

# This file was *autogenerated* from the file Orthogonal_Grassmannian.sage
from sage.all_cmdline import *   # import sage library

_sage_const_5 = Integer(5); _sage_const_1 = Integer(1); _sage_const_2 = Integer(2); _sage_const_0 = Integer(0); _sage_const_3 = Integer(3)
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 _sage_const_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 (ellipsis_range( _sage_const_1  ,Ellipsis, floor(N/_sage_const_2 ) )) ,                ValueError('The integer `k` need to be in the range '+str((ellipsis_range( _sage_const_1  ,Ellipsis, floor(N/_sage_const_2 ) )))+'.')

        from Equivariant_Vector_Bundles_On_Homogeneous_Varieties.Base_Space.Homogeneous_Variety import Irreducible_Cartan_Group
        if N % _sage_const_2  == _sage_const_0  :
            G = Irreducible_Cartan_Group( Cartan_Family='D' , Cartan_Degree=N/_sage_const_2  )
            if k in (ellipsis_range( _sage_const_1  ,Ellipsis, N/_sage_const_2 -_sage_const_2  )) : P = G.Maximal_Parabolic_Subgroup( Excluded_Node=k )
            elif k == N/_sage_const_2 -_sage_const_1         : P = G.Parabolic_Subgroup( Excluded_Nodes={N/_sage_const_2 -_sage_const_1 ,N/_sage_const_2 } )
            elif k == N/_sage_const_2           : P = G.Maximal_Parabolic_Subgroup( Excluded_Node=N/_sage_const_2 -_sage_const_1  )
        else          :
            G = Irreducible_Cartan_Group( Cartan_Family='B' , Cartan_Degree=floor(N/_sage_const_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 =[_sage_const_1 ,_sage_const_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()[_sage_const_0 ] for Summand in Orbit[_sage_const_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 [  _sage_const_1  , '+' ] : return self.calU( fw[n-_sage_const_1 ] )
            elif Parity in [ -_sage_const_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 == _sage_const_1  :
                Starting_Block = [ self.calU( fw[n] ) ]
                Support_Partition = tuple( [ _sage_const_1  ] )
                LC += self.Lefschetz_Collection( Starting_Block=Starting_Block , Support_Pattern=Support_Partition )

            elif k == _sage_const_2  :
                if n == _sage_const_2  :
                    pass

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

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

                if k == _sage_const_3  :
                    if n == _sage_const_3  :
                        Starting_Block = [ self.calU( fw[_sage_const_1 ] ).Extend_Equivariantly_By( self.calO() ) ]
                        Support_Partition = tuple( _sage_const_2 *[ _sage_const_1  ] )
                    else      :
                        Starting_Block = [ self.calU( (n-_sage_const_2 )*fw[_sage_const_1 ]+fw[n] ).Extend_Equivariantly_By( self.calU( (n-_sage_const_3 )*fw[_sage_const_1 ]+fw[n] ) ) ]
                        Support_Partition = tuple( (n-_sage_const_2 )*[ _sage_const_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+_sage_const_1 )+' = 0'
            for i in range( k , -_sage_const_1  , -_sage_const_1  ) :
                Quotient = str( calS * calU.Exterior_Power(i) * Factor )
                yield '0 --> F_'+str(i+_sage_const_1 )+' --> F_'+str(i)+' --> '+str(Quotient)+' --> 0'
            yield 'F_0 = '+str( Factor.Multiply_By( calS.H0() ) )

        elif Cartan_Family == 'D' :
            if   Parity in [  _sage_const_1  , '+' ] : ParityStr = '+' ; ParityInt = _sage_const_1 
            elif Parity in [ -_sage_const_1  , '-' ] : ParityStr = '-' ; ParityInt = -_sage_const_1 
            else                        : raise ValueError('For the Cartan Family D, there need to be a parity in '+str([ _sage_const_1  , '+' ])+' or in '+str([ -_sage_const_1  , '-' ])+'.')
            yield 'F^'+ParityStr+'_'+str(k+_sage_const_1 )+' = 0'
            for i in range( k , -_sage_const_1  , -_sage_const_1  ) :
                Quotient = str( self.calS( ParityInt * (-_sage_const_1 )**i ) * calU.Exterior_Power(i) * Factor )
                yield '0 --> F^'+ParityStr+'_'+str(i+_sage_const_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 =[_sage_const_1 ,_sage_const_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 _sage_const_2  in Parts :
            if k == _sage_const_3  :
                for Partition in IntegerListsLex( length=_sage_const_3  ,                                                   floor=[ n-_sage_const_2  , _sage_const_0  , _sage_const_0  ] , ceiling=[ floor(_sage_const_3 /_sage_const_2 *(n-_sage_const_3 )) , ceil(_sage_const_1 /_sage_const_2 *(n-_sage_const_3 )) , _sage_const_0  ] ,                                                   #max_sum=sum([ (k-i)*(n-k) for i in [ 1 .. k-1 ] ]) ,
                                                  min_slope=-n+_sage_const_3  , max_slope=_sage_const_0                                                  ) :
                    Partition = list(Partition)
                    Universe += [ [ Partition[Counter-_sage_const_1 ]-Partition[Counter] for Counter in range( _sage_const_1  , len(Partition) ) ] ]

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

        Universe.reverse()
        Starting_Block = [ self.calU( sum([ self.Null_Weight() ] + [ Coefficient*fw[Node] for Node , Coefficient in enumerate( Coefficients , start=_sage_const_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 _sage_const_0  < Dimension ,                ValueError('The dimension must be greater than zero.')

        super( Quadric_Space , self ).__init__( k=_sage_const_1  , N=Dimension+_sage_const_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.')