B06-P03.ipynb

Kernel: SageMath 10.3

%run '/home/user/Equivariant_Vector_Bundles_On_Homogeneous_Varieties__0-0-1/src/Initialize.ipynb'

k = 3
n = 6

N = 2*n+1
X = Orthogonal_Grassmannian(k,N)
G = X.Parent_Group()
fw = X.Basis('fw')

Output = dict({})
Output.update({ 1 : '' })
Output[1] += 'X: '+str(X)+'\n'
Output[1] += '(n='+str(n)+')'+'\n'
d = X.Dimension()
Output[1] += 3*' '+'Dimension: '+str(d)+'\n'
lMax = X.K0().rank()
Output[1] += 3*' '+'Rank of K0(X) (max. collection length): '+str(lMax)+'\n'
wMax = X.Fano_Index()
Output[1] += 3*' '+'Fano index (max. orbit length): '+str(wMax)+'\n'
Output[1] += '\n'

Output.update({ 2 : '' })
Output[2] += 3*' '+'Consecutive Lefschetz collection.'+'\n'
LC1 = X.My_Collection( Modus='Con' )
l1 = len(LC1)
Output[2] += 3*' '+'Starting block:'+'\n'
w1_0 = len( LC1.Starting_Block() )
s = ceil( math.log10( w1_0 ) )
for i , cE in enumerate ( LC1.Starting_Block() , start=1 ) :
    Output[2] += 6*' '+(s-floor(math.log10(i))-1)*' '+str(i)+' '+str(cE)+'\n'
Output[2] += '\n'

Output.update({ 3 : '' })
Output[3] += 3*' '+'Alternating Lefschetz collection.'+'\n'
LC2 = X.My_Collection( Modus='Alt' )
l2 = len(LC2)
Output[3] += 3*' '+'Starting block:'+'\n'
w2_0 = len( LC2.Starting_Block() )
s = ceil( math.log10( w2_0 ) )
for i , cE in enumerate ( LC2.Starting_Block() , start=1 ) :
    Output[3] += 6*' '+(s-floor(math.log10(i))-1)*' '+str(i)+' '+str(cE)+'\n'
Output[3] += '\n'

Output.update({ 4 : '' })
Output[4] += 3*' '+'Gap.'+'\n'
Output[4] += 6*' '+'       lMax-l = '+str(lMax-l1)+'\n'
Output[4] += 6*' '+'(lMax-l)/wMax = '+str( (lMax-l1)/wMax  )+'\n'
Output[4] += '\n'

Output.update({ 5 : '' })
Output[5] += 3*' '+'Try to fill the gap.'+'\n'
Start_With = 1497
if 0 < Start_With :
    Output[5] += 3*' '+'Start later than candidate #'+str(Start_With)+'.'+'\n'
Output[5] += '\n'
Counter = 0
for Node in [ 4 .. n ] :
    Universe = [ E for E in ( X.calU( fw[Node] ) * G.rmV( fw[n] ) ).Irreducible_Components() ]
    for Size in [ 1 .. len(Universe) ] :
        for Indices in Subsets( range(len(Universe)) , Size , submultiset=True ) :
            Counter += 1
            if Start_With < Counter :
                # Present output.
                clear_output(wait=True)
                for Key , Line in Output.items() :
                    print(Line)

                print( 3*' ' , 'Consider '+bcolors.OKBLUE+'X.calU( fw['+str(Node)+'] ) * G.rmV( fw['+str(n)+'] )'+bcolors.ENDC )
                print()

                print( 3*' ' , 'Current counter: '+bcolors.OKBLUE+str(Counter)+bcolors.ENDC )
                print()

                # Construct candidate.
                Candidate = X.Zero_Vector_Bundle()
                for Index in Indices :
                    Candidate += Universe[Index]
                # Check if candidate is admissible.
                Candidate_Is_Admissible = False
                if Candidate.Is_Exceptional( Test_Numerically=True ) :
                    Candidate_Is_Admissible = True
                if Candidate_Is_Admissible :
                    Candidate_Is_Relevant = False
                    Possible_Output = ''
                    Line = 6*' '+'Test for candidate #'+str(Counter)+':'
                    print( Line )
                    Possible_Output += Line+'\n'
                    Line = 9*' '+'Semi-simplification is '+bcolors.OKBLUE+str(Candidate)+bcolors.ENDC+'.'
                    print( Line )
                    Possible_Output += Line+'\n'
                    Line = ''
                    print( Line )
                    Possible_Output += Line+'\n'
                    for i , LC in enumerate([ LC1 , LC2 ] , start=1 ) :
                        Line += 9*' '+'Can candidate be embedded in the Lefschetz collection LC'+str(i)+'?'
                        print( Line )
                        Possible_Output += Line+'\n'
                        for xPos , Admissible_Columns in LC.Test_For_Extension ( New_Object=Candidate , Test_Numerically=True , Test_If_Self_Is_Exceptional=False ) :
                            if 0 < len(Admissible_Columns) :
                                Candidate_Is_Relevant = True
                                Line = 12*' '+bcolors.OKGREEN+'Yes'+bcolors.ENDC+' after row '+str(xPos)+' to the columns '+bcolors.OKBLUE+str(Admissible_Columns)+bcolors.ENDC+'.'
                                print( Line )
                                Possible_Output += Line+'\n'
                            else :
                                Line = 12*' '+bcolors.FAIL+'Not'+bcolors.ENDC+' after row '+str(xPos)+'.'
                                print( Line )
                                Possible_Output += Line+'\n'
                        Line = ''
                        print( Line )
                        Possible_Output += Line+'\n'

                    if Candidate_Is_Relevant :
                        Output[5] += Possible_Output

X: Orthogonal grassmannian variety of 3-dimensional isotropic linear subspaces in a 13-dimensional ambient vector space.
(n=6)
   Dimension: 24
   Rank of K0(X) (max. collection length): 160
   Fano index (max. orbit length): 9


   Consecutive Lefschetz collection.
   Starting block:
       1 VB(0)
       2 VB(Lambda[1])
       3 VB(Lambda[2])
       4 VB(2*Lambda[1])
       5 VB(Lambda[1] + Lambda[2])
       6 VB(2*Lambda[2])
       7 VB(3*Lambda[1])
       8 VB(2*Lambda[1] + Lambda[2])
       9 VB(Lambda[1] + 2*Lambda[2])
      10 VB(3*Lambda[2])
      11 VB(3*Lambda[1] + Lambda[2])
      12 VB(2*Lambda[1] + 2*Lambda[2])
      13 VB(Lambda[6])
      14 Equivariant extension of VB(Lambda[1] + Lambda[6]) by VB(Lambda[6])
      15 Equivariant extension of VB(2*Lambda[1] + Lambda[6]) by VB(Lambda[1] + Lambda[6])
      16 Equivariant extension of VB(3*Lambda[1] + Lambda[6]) by VB(2*Lambda[1] + Lambda[6])
      17 Equivariant extension of VB(4*Lambda[1] + Lambda[6]) by VB(3*Lambda[1] + Lambda[6])


   Alternating Lefschetz collection.
   Starting block:
       1 VB(0)
       2 VB(Lambda[6])
       3 VB(Lambda[1])
       4 VB(Lambda[2])
       5 Equivariant extension of VB(Lambda[1] + Lambda[6]) by VB(Lambda[6])
       6 VB(2*Lambda[1])
       7 VB(Lambda[1] + Lambda[2])
       8 VB(2*Lambda[2])
       9 Equivariant extension of VB(2*Lambda[1] + Lambda[6]) by VB(Lambda[1] + Lambda[6])
      10 VB(3*Lambda[1])
      11 VB(2*Lambda[1] + Lambda[2])
      12 VB(Lambda[1] + 2*Lambda[2])
      13 VB(3*Lambda[2])
      14 Equivariant extension of VB(3*Lambda[1] + Lambda[6]) by VB(2*Lambda[1] + Lambda[6])
      15 VB(3*Lambda[1] + Lambda[2])
      16 VB(2*Lambda[1] + 2*Lambda[2])
      17 Equivariant extension of VB(4*Lambda[1] + Lambda[6]) by VB(3*Lambda[1] + Lambda[6])


   Gap.
             lMax-l = 12
      (lMax-l)/wMax = 4/3


   Try to fill the gap.
   Start later than candidate #1497.


    Consider X.calU( fw[5] ) * G.rmV( fw[6] )

    Current counter: 2060

k = 3
n = 6
X = Orthogonal_Grassmannian( k , 2*n+1 )
fw = X.Basis('fw')
print( 'Base space:' , X.__str__( Output_Style='Short' ) )
print( 'rk K0(X):' , X.K0().rank() )
print( 'Fano index:' , X.Fano_Index() )
print()

h = X.Fano_Index()

# Kuznetsov's spinor bundle filtration
calS = X.calS()
F3 = ( X.calU().Exterior_Power(3) * calS )
F2 = ( X.calU().Exterior_Power(2) * calS ).Extend_Equivariantly_By( F3 )
F1 = ( X.calU().Exterior_Power(1) * calS ).Extend_Equivariantly_By( F2 )
F0 = ( X.calU().Exterior_Power(0) * calS ).Extend_Equivariantly_By( F1 )

LC  = X.Lefschetz_Collection( Starting_Block=[] , Support_Pattern='Trivial' )

# Tautological collection
LC += X.Tautological_Collection()
# ... extension of the tautological collection ...
# Degree = 4
E = X.calU( 3*fw[1]+fw[2] )
LC += X.Lefschetz_Collection( Starting_Block=[E] , Support_Pattern=h*[1] )
E = X.calU( 2*fw[1]+2*fw[2] )
LC += X.Lefschetz_Collection( Starting_Block=[E] , Support_Pattern=h*[1] )

# Mysterious collection
# 1
LC += X.Lefschetz_Collection( Starting_Block=[X.calU( 3*fw[1]+fw[n-1] )(-1).Extend_Equivariantly_By( X.calU( 2*fw[1]+fw[n-2] )(-1) ).Extend_Equivariantly_By( X.calU( fw[n-1] )(-1) )] , Support_Pattern=3*[1] )
# 2
E = X.calU( fw[n] )
LC += X.Lefschetz_Collection( Starting_Block=[X.calU( fw[1]+2*fw[n] )(-1).Extend_Equivariantly_By( X.calU( 2*fw[n] )(-1) + X.calU( fw[n-1] )(-1) )] , Support_Pattern=h*[1] )
# Note: We extend by X.calU( 2*fw[n] )(-1) + X.calU( fw[n-1] )(-1).
#       However, F3 * X.calU( fw[n] ) = X.calU( 2*fw[n] )(-1) + X.calU( fw[n-1] )(-1) + ... + X.calU( fw[k+1] )(-1) + X.calO()

# Spinor collection
# Degree = 1/2
E = X.calU( fw[n] )
LC += X.Lefschetz_Collection( Starting_Block=[E] , Support_Pattern=h*[1] )
# Degree = 3/2
E = X.calO()(1)
LC += X.Lefschetz_Collection( Starting_Block=[X.calU( fw[1]+fw[n] ).Extend_Equivariantly_By( F3 * E )] , Support_Pattern=h*[1] )
# Degree = 5/2
E = X.calU( fw[1] )(1)
LC += X.Lefschetz_Collection( Starting_Block=[X.calU( 2*fw[1]+fw[n] ).Extend_Equivariantly_By( F3 * E )] , Support_Pattern=h*[1] )
# Degree = 7/2
E = X.calU( 2*fw[1] )(1)
LC += X.Lefschetz_Collection( Starting_Block=[X.calU( 3*fw[1]+fw[n] ).Extend_Equivariantly_By( F3 * E )] , Support_Pattern=h*[1] )
# Degree = 9/2
E = X.calU( 3*fw[1] )(1)
LC += X.Lefschetz_Collection( Starting_Block=[X.calU( 4*fw[1]+fw[n] ).Extend_Equivariantly_By( F3 * E )] , Support_Pattern=4*[1] )

print( 'Objects of starting block:' )
Body = [ [ str(Counter)+':' , str(Object) , str(sum([ 1 for Row in LC.Support_Pattern().values() if Row[Counter-1] == True ])) ]
         for Counter , Object in enumerate( LC.Starting_Block() , start=1 )
       ]
show( table(Body) )
print()

print( 'Number of objects:' , len(LC) )
print( 'LC has maximal expected length?' , LC.Has_Maximal_Expected_Length() )
print()

#print( 'Grid of LC:' )
#show( LC.Grid() )
#print()

#LC_Is_Numercially_Exceptional = LC.Is_Numerically_Exceptional()
#print( 'Is LC numerially exceptional?' , LC_Is_Numercially_Exceptional )
#print()

Base space: OGr(3;13)
rk K0(X): 160
Fano index: 9

Objects of starting block:

Number of objects: 178
LC has maximal expected length? False

G = Irreducible_Cartan_Group( 'B' , 6 )
P = G.Maximal_Parabolic_Subgroup(3)
X = G/P
fw = X.Basis('fw')
print( 'Base space:' , X )
print( 'Rank of Grothendieck group rk( K_0(X) ) = '+str( X.K0().rank() ) )
print()


Version = 1
print( 'Consider version '+str(Version)+'.' )
print()

def A( x:int , y:int=1 ) -> Irreducible_Equivariant_Vector_Bundle :
    assert x in ZZ and 0 <= x , \
           ValueError('The input for ``x`` must be non-negative integer.')
    assert y in ZZ and 0 <= x , \
           ValueError('The input for ``y`` must be non-negative integer.')
    return X.calU( x*fw[1]+y*fw[X.Cartan_Degree()] )(1-y)

# --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
# Version 1
if   Version == 1 :

    E =  [ X.calO()                   ,
           X.calU(   fw[1]          ) ,
           X.calU(            fw[2] ) ,
           X.calU( 2*fw[1]          ) ,
           X.calU(   fw[1] +  fw[2] ) ,
           X.calU(          2*fw[2] ) ,
           X.calU( 3*fw[1]          ) ,
           X.calU( 2*fw[1] +  fw[2] ) ,
           X.calU(   fw[1] +2*fw[2] ) ,
           X.calU(          3*fw[2] )
         ]
    E += [ X.calU( 3*fw[1] +  fw[2] ) ,
           X.calU( 2*fw[1] +2*fw[2] )
           #X.calU( 3*fw[1] +2*fw[2] )
           #X.calU( 3*fw[1] +3*fw[2] )
         ]

    VB1 = X.calU(   fw[1]           +2*fw[6] )(-1)
    VB2 = X.calU(                   +2*fw[6] )(-1)
    VB3 = X.calU(         +   fw[5]          )(-1)
    F  = [ VB1.Extend_Equivariantly_By( VB2 ).Extend_Equivariantly_By( VB3 ) ]

    S = [ A(0)                                 ,
          A(1).Extend_Equivariantly_By( A(0) ) ,
          A(2).Extend_Equivariantly_By( A(1) ) ,
          A(3).Extend_Equivariantly_By( A(2) ) ,
          A(4).Extend_Equivariantly_By( A(3) )
        ]
    Starting_Block = []
    Labelling = []
    for Key , List in { 'E' : E , 'F' : F , 'S' : S }.items() :
        Starting_Block += List
        Labelling      += [ Key+str(Counter) for Counter in [ 1 .. len(List) ] ]
    Support_Pattern = tuple([ 18 , 18 , 18 , 18 , 17 , 17 , 17 , 17 , 17  ])



# --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
# Version 2
elif Version == 2 :

    F1 = X.calU( fw[1] )
    F2 = X.calU( fw[4] )(-1)
    calQ        = F1.Extend_Equivariantly_By( F2 )

    F1 = X.calU( fw[2] )
    F2 = X.calU( fw[1]+fw[4] )(-1)
    F3 = X.calU( fw[5] )(-1)
    calQ_Wedge2 = F1.Extend_Equivariantly_By( F2 ).Extend_Equivariantly_By( F3 ) # Wedge^2 calQ

    F1 = X.calO(1)
    F2 = X.calU( fw[2]+fw[4] )(-1)
    F3 = X.calU( fw[1]+fw[5] )(-1)
    F4 = X.calU( 2*fw[6] )(-1)
    calQ_Wedge3 = F1.Extend_Equivariantly_By( F2.Extend_Equivariantly_By( F3.Extend_Equivariantly_By( F4 ) ) )

    F1 = X.calU( fw[4] )
    F2 = X.calU( fw[2]+fw[5] )(-1)
    F3 = X.calU( fw[1]+2*fw[6] )(-1)
    F4 = X.calU( 2*fw[6] )(-1)
    calQ_Wedge4 = F1.Extend_Equivariantly_By( F2.Extend_Equivariantly_By( F3.Extend_Equivariantly_By( F4 ) ) )

    F1 = X.calU( fw[5] )
    F2 = X.calU( fw[2]+2*fw[6] )(-1)
    calQ_Wedge5 = F1.Extend_Equivariantly_By( F2.Extend_Equivariantly_By( F2.Dual()(1).Extend_Equivariantly_By( F1.Dual()(1) ) ) )

    Starting_Block = [ X.calO()                                                                               ,
                       calQ                                                                                   ,
                       X.calU().Dual()                                                                        ,
                       calQ_Wedge2.Extend_Equivariantly_By( X.calO() )                                        ,
                       X.calU().Dual().Symmetric_Power(2)                                                     ,
                       calQ_Wedge3.Extend_Equivariantly_By( calQ )                                            ,
                       X.calU().Dual().Symmetric_Power(3)                                                     ,
                       calQ_Wedge4.Extend_Equivariantly_By( calQ_Wedge2.Extend_Equivariantly_By( X.calO() ) ) ,
                       A(0)                                                                                   ,
                       A(1).Extend_Equivariantly_By( A(0) )                                                   ,
                       A(2).Extend_Equivariantly_By( A(1) )                                                   ,
                       A(3).Extend_Equivariantly_By( A(2) )                                                   ,
                       A(4).Extend_Equivariantly_By( A(3) )
                     ]
    Labelling = [ 'cO' , 'cQ' , 'cUVee' , '[Wedge2-cQ,cO]' , '(Sym2-cUVee)' , '[Wedge3-cQ,cQ]' , '(Sym3-cUVee)' , '[Wedge4-cQ,[Wedge2-cQ,cO]]' , 'cS1' , 'cS2' , 'cS3' , 'cS4' , 'cS5' ]
    Support_Pattern = tuple([ 13 , 13 , 13 , 13 , 12 , 12 , 12 , 12 , 12  ])



# --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
# Initialize the Lefschetz collection

LC = Lefschetz_Collection( Base_Space=X , Starting_Block=Starting_Block , Support_Pattern=Support_Pattern )

print( 'Objects of starting block:' )
for Counter , F in enumerate( LC.Starting_Block() , start=1 ) :
    print( str(Counter)+':' , F )
print()

print( 'Grid of LC:' )
show( LC.Grid( Labelling ) )
print()

print( 'Number of objects:' , len(LC) )
print( 'LC has maximal expected length?' , LC.Has_Maximal_Expected_Length() )
print()

print( 'Is LC numerially exceptional?' , LC.Is_Numerically_Exceptional() )

Base space: Smooth projective variety B6/P({1, 2, 4, 5, 6}).
Rank of Grothendieck group rk( K_0(X) ) = 160

Consider version 1.

Objects of starting block:
1: VB(0)
2: VB(Lambda[1])
3: VB(Lambda[2])
4: VB(2*Lambda[1])
5: VB(Lambda[1] + Lambda[2])
6: VB(2*Lambda[2])
7: VB(3*Lambda[1])
8: VB(2*Lambda[1] + Lambda[2])
9: VB(Lambda[1] + 2*Lambda[2])
10: VB(3*Lambda[2])
11: VB(3*Lambda[1] + Lambda[2])
12: VB(2*Lambda[1] + 2*Lambda[2])
13: Equivariant extension of [ VB(Lambda[1] - Lambda[3] + 2*Lambda[6]) , VB(-Lambda[3] + 2*Lambda[6]) ] by VB(-Lambda[3] + Lambda[5])
14: VB(Lambda[6])
15: Equivariant extension of VB(Lambda[1] + Lambda[6]) by VB(Lambda[6])
16: Equivariant extension of VB(2*Lambda[1] + Lambda[6]) by VB(Lambda[1] + Lambda[6])
17: Equivariant extension of VB(3*Lambda[1] + Lambda[6]) by VB(2*Lambda[1] + Lambda[6])
18: Equivariant extension of VB(4*Lambda[1] + Lambda[6]) by VB(3*Lambda[1] + Lambda[6])

Grid of LC:

Number of objects: 157
LC has maximal expected length? False

Is LC numerially exceptional? True