Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Download

Environment to perform calculations of equivariant vector bundles on homogeneous varieties

2641 views
License: GPL3
ubuntu2204
Tweet
Share
Share
Kernel: SageMath 9.8
%run '/home/user/Equivariant_Vector_Bundles_On_Homogeneous_Varieties__0-0-1/src/Initialize.ipynb'

k = 3
n = 4

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 = 0
if 0 < Start_With :
    Output[5] += 3*' '+'Start later than candidate #'+str(Start_With)+'.'+'\n'
Output[5] += '\n'

for d , Line in Output.items() :
    print(Line)

cM1 = X.calU( fw[1]+2*fw[4] )(-1) + X.calU( 2*fw[4] )(-1) + X.calU( fw[n-1] )(-1)
#cM2 = X.Complex({ -2 : cM1 , -1 : X.calU( fw[n] ) * G.rmV( fw[n] ) , 0 : 'Cokernel' }).SemiSimplification(0)
cM2 = cM1*-1
for Smd in ( X.calU( fw[n] ) * G.rmV( fw[n] ) ).Irreducible_Components() :
    cM2 += Smd

# Construct candidate.
Candidate = cM2

# 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 = 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 9-dimensional ambient vector space. (n=4) Dimension: 12 Rank of K0(X) (max. collection length): 32 Fano index (max. orbit length): 5 Consecutive Lefschetz collection. Starting block: 1 VB(0) 2 VB(Lambda[1]) 3 VB(Lambda[2]) 4 VB(Lambda[4]) 5 Equivariant extension of VB(Lambda[1] + Lambda[4]) by VB(Lambda[4]) 6 Equivariant extension of VB(2*Lambda[1] + Lambda[4]) by VB(Lambda[1] + Lambda[4]) Alternating Lefschetz collection. Starting block: 1 VB(0) 2 VB(Lambda[4]) 3 VB(Lambda[1]) 4 VB(Lambda[2]) 5 Equivariant extension of VB(Lambda[1] + Lambda[4]) by VB(Lambda[4]) 6 Equivariant extension of VB(2*Lambda[1] + Lambda[4]) by VB(Lambda[1] + Lambda[4]) Gap. lMax-l = 5 (lMax-l)/wMax = 1 Try to fill the gap. Semi-simplification is VB(Lambda[2] - Lambda[3] + 2*Lambda[4]) + VB(Lambda[2]) + VB(Lambda[1]) + VB(2*Lambda[4]) + VB(Lambda[3]). Can candidate be embedded in the Lefschetz collection LC1? Not after row 0. Not after row 1. Not after row 2. Not after row 3. Yes after row 4 to the columns [0, 1, 2, 3, 4]. Yes after row 5 to the columns [0, 1, 2, 3, 4]. Yes after row 6 to the columns [0, 1, 2, 3, 4]. Can candidate be embedded in the Lefschetz collection LC2? Not after row 0. Not after row 1. Not after row 2. Not after row 3. Yes after row 4 to the columns [0, 1, 2, 3, 4]. Yes after row 5 to the columns [0, 1, 2, 3, 4]. Yes after row 6 to the columns [0, 1, 2, 3, 4]. 
print( cM2.EXT( cM2.Dual()(1) ) )
{2: 2*B4(0,0,0,0) + B4(1,0,0,0), 1: 5*B4(0,0,0,0) + 2*B4(1,0,0,0), 0: 2*B4(0,0,0,0) + B4(1,0,0,0)} 


k = 3
n = 4
N = 2*n+1
X = Orthogonal_Grassmannian(k,N)
print( 'X:' , X )
print( '(n='+str(n)+')' )
print()

G = X.Parent_Group()
fw = X.Basis('fw')

print( 'Initialise suitable objects:' )
print( 3*' ' , '- Repesentations')
rV = G.rmV(fw[1])
rS = G.rmV(fw[n])
print( 3*' ' , '- Tautological bundles')
cO = X.calO()
cU = X.calU()
cQ = dict({})
for p in [ 0 .. 2*n-2 ] :
    Dict = dict({})
    Dict.update({ -p+i-1 : cU.Symmetric_Power(p-i)*rV.exterior_power(i) for i in [ 0 .. p ] })
    Dict.update({      0 : 'Cokernel' })
    cQ.update({ tuple(p*[1]) : X.Complex(Dict).SemiSimplification(0) })
print( 3*' ' , '- Spinor bundles' )
cS = dict({})
cS.update({ 0 : X.calS() })
cS.update({ y : ( cU.Dual().Symmetric_Power(y)*cS[0] ).Extend_Equivariantly_By( cU.Dual().Symmetric_Power(y-1)*cS[0] ) for y in [ 1 .. n-2 ] })
print()

print('Initialise Lefschetz collection:')
TC = X.Tautological_Collection( Parts=[1,2] )
SC = X.Spinor_Collection()
LC = TC+SC
print( table([ [ x , Obj ] for x , Obj in enumerate( LC.Starting_Block() ) ]) )
print()
X: Orthogonal grassmannian variety of 3-dimensional isotropic linear subspaces in a 9-dimensional ambient vector space. (n=4) Initialise suitable objects: - Repesentations - Tautological bundles - Spinor bundles Initialise Lefschetz collection: 0 VB(0) 1 VB(Lambda[1]) 2 VB(Lambda[2]) 3 VB(Lambda[4]) 4 Equivariant extension of VB(Lambda[1] + Lambda[4]) by VB(Lambda[4]) 5 Equivariant extension of VB(2*Lambda[1] + Lambda[4]) by VB(Lambda[1] + Lambda[4]) 
cR = X.calU( 2*fw[4] )(-1)

cM2 = ( cU.Dual()*cR ).Extend_Equivariantly_By( cR + cO )

print( cM2 )
Equivariant extension of VB(Lambda[1] - Lambda[3] + 2*Lambda[4]) by VB(-Lambda[3] + 2*Lambda[4]) + VB(0) 
print( cM2.Dual()(1).EXT( cM2 ) )
{2: 2*B4(0,0,0,0) + B4(1,0,0,0), 1: B4(0,0,0,0)} 




print( 'On the sequence 0 -> cE -> ... -> cE(4) -> 0 where cE = cU(fw[1]+fw[2])' )
cE = X.calU( fw[1]+fw[2] )
print( 'EXT( cE(4) , cE ) = '+str( cE(4).EXT( cE ) ) )
print()

print( 'Initialise the left side.' )
cA = dict({})
Objects = dict({})
Objects.update({ -4 : cE                                                                                                        ,
                 -3 : ( cU.Symmetric_Power(2)(2) + cU.Exterior_Power(2)(2) ) * ( rV                                           ) ,
                 -2 : ( cU(2)                                              ) * ( rV.symmetric_power(2) + rV.exterior_power(2) ) ,
                 -1 : ( cO(2)                                              ) * ( G.rmV( fw[1]+fw[2] )                         ) ,
                  0 : 'Cokernel'
               })
cA.update({ 1 : X.Complex( Objects ) })

print( 'Initialise the right side.' )
cB = dict({})
Objects = dict({})
Objects.update({ 0 : 'Kernel'                                                                                                            ,
                 1 : ( cQ[(1,)].Dual().Symmetric_Power(2)(4) + cQ[(1,1,)].Dual()(4) ) * ( rV                                           ) ,
                 2 : ( cQ[(1,)].Dual()(4)                                           ) * ( rV.symmetric_power(2) + rV.exterior_power(2) ) ,
                 3 : ( cO(4)                                                        ) * ( G.rmV( fw[1]+fw[2] )                         ) ,
                 4 : cE(4)
               })
cB.update({ -1 : X.Complex( Objects ) })

for BCounter , BCplx in cB.items() :
    for ACounter , ACplx in cA.items() :
        print('Compute EXTs from B['+str(BCounter)+'][*] to A['+str(ACounter)+'][*]:')

        print( 'Objects:' )
        for Label , Cplx in [ ( 'B' , BCplx ) , ( 'A' , ACplx ) ] :
            if   Label == 'A' : Counter = ACounter
            elif Label == 'B' : Counter = BCounter
            print( table([ [ Label+'['+str(Counter)+']['+str(Degree)+']' , '=' , Component ] for Degree , Component in Cplx ]) )
            print()

        Header = [ [ '' ] + [ 'A['+str(ACounter)+']['+str(ADegree)+']' for ADegree , AComponent in ACplx ] ]
        Body = []
        for BDegree , BComponent in BCplx :
            Row = [ 'B['+str(BCounter)+']['+str(BDegree)+']' ]
            for ADegree , AComponent in ACplx :
                if isinstance( BComponent , str ) or isinstance( AComponent , str ) : Result = '...'
                else                                                                :
                    if BComponent.Euler_Sum(AComponent) == G.rmV(0) : Result = '{}'
                    else                                            : Result = BComponent.EXT(AComponent)
                Row += [ Result ]
            Body += [ Row ]
        show( table( Header + Body , header_column=True , header_row=True ) )
        print()
On the sequence 0 -> cE -> ... -> cE(4) -> 0 where cE = cU(fw[1]+fw[2]) EXT( cE(4) , cE ) = {9: B4(0,0,0,0)} Initialise the left side. Initialise the right side. Compute EXTs from B[-1][*] to A[1][*]: Objects: B[-1][0] = Kernel B[-1][1] = B4(1,0,0,0) * VB(2*Lambda[2] + 2*Lambda[3]) + 2*B4(1,0,0,0) * VB(Lambda[2] + 2*Lambda[3] + 2*Lambda[4]) + B4(1,0,0,0) * VB(2*Lambda[3] + 4*Lambda[4]) + B4(1,0,0,0) * VB(4*Lambda[3]) + B4(1,0,0,0) * VB(Lambda[1] + 3*Lambda[3]) + B4(1,0,0,0) * VB(3*Lambda[3] + 2*Lambda[4]) B[-1][2] = ( B4(0,0,0,0) + B4(0,1,0,0) + B4(2,0,0,0) ) * VB(Lambda[2] + 3*Lambda[3]) + ( B4(0,0,0,0) + B4(0,1,0,0) + B4(2,0,0,0) ) * VB(3*Lambda[3] + 2*Lambda[4]) B[-1][3] = B4(1,1,0,0) * VB(4*Lambda[3]) B[-1][4] = VB(Lambda[1] + Lambda[2] + 4*Lambda[3]) A[1][-4] = VB(Lambda[1] + Lambda[2]) A[1][-3] = B4(1,0,0,0) * VB(2*Lambda[2]) + B4(1,0,0,0) * VB(Lambda[1] + Lambda[3]) A[1][-2] = ( B4(0,0,0,0) + B4(0,1,0,0) + B4(2,0,0,0) ) * VB(Lambda[2] + Lambda[3]) A[1][-1] = B4(1,1,0,0) * VB(2*Lambda[3]) A[1][0] = Cokernel 










print( 'On the sequence 0 -> cS_y -> ... -> cS_y(l_y) -> 0 whenever cS_y is from the starting block of the spinor collection' )
print()

for t , cE in enumerate( SC.Starting_Block() , start=0 ) :
    print( 150*'-' )
    l = len(cE.Maximal_Exceptional_Orbit(Test_Numerically=True))
    print( 'cS_y = '+str(cE)+' with l_y = '+str(l) )
    print( '(y='+str(t)+')' )
    print()

    print( 'Initialise the left side.' )
    cA = dict({})
    Objects = dict({})
    Objects.update({ -1*t-1 : cE })
    Objects.update({ -1*i-1 : X.calU( i*fw[1]+(t-1-i)*fw[2] )(1)*rS for i in [ 0 .. t-1 ] })
    Objects.update({ 0 : cE.Dual()(t+1) })
    cA.update({ 1 : X.Complex( Objects ) })

    print( 'Initialise the right side.' )
    Objects = dict({})
    if t == 0 : Objects.update({ 0 : 'Kernel' , 1 : cO(l)*rS , 2 : cE(l) })
    else      : Objects.update({ 0 : 'Kernel' , 1 : cS[t-1](l)*(G.rmV(1)+rV) , 2 : cE(l) })
    cB.update({ -1 : X.Complex( Objects ) })
    ## Counter = -2
    #cB = dict({})
    #Objects = dict({})
    ## Characterisation 1
    #Objects.update({ 0 : 'Kernel' })
    #Objects.update({ i : cU.Symmetric_Power(-i+3)(4)*rV.exterior_power(i+2) for i in [ 0 .. 4-t ] })
    #Objects.update({ 4 : UPerp(5) })
    ## Characterisation 2
    ##Objects.update({ i : cU.Symmetric_Power(-i+2)(4)*rV.exterior_power(i+3) for i in [-3,-2,-1] })
    ##Objects.update({ 0 : 'Cokernel' })
    #cB.update({ -2 : X.Complex( Objects ) })
    ## Counter = -1
    #Objects = dict({})
    #Objects.update({ 0 : 'Kernel' , 1 : O(5)*V , 2 : UDual(5) })
    #cB.update({ -1 : X.Complex( Objects ) })

    print()

    for Label , Stack in [ ( 'A' , cA ) , ( 'B' , cB ) ] :
        print( 'Construction of '+Label+'´s:' )
        for Counter , Complex in Stack.items() :
            print( 'Counter='+str(Counter)+':' )
            print( 'Complex:')
            print( Complex )
            print( 'Is complex numerically exact?' , Complex.Is_Numerically_Exact() )
            print()

    for BCounter , BCplx in cB.items() :
        for ACounter , ACplx in cA.items() :

            print('Compute EXTs from B['+str(BCounter)+'][*] to A['+str(ACounter)+'][*]:')

            print( 'Objects:' )
            for Label , Cplx in [ ( 'B' , BCplx ) , ( 'A' , ACplx ) ] :
                if   Label == 'A' : Counter = ACounter
                elif Label == 'B' : Counter = BCounter
                print( table([ [ Label+'['+str(Counter)+']['+str(Degree)+']' , '=' , Component ] for Degree , Component in Cplx ]) )
                print()

            Header = [ [ '' ] + [ 'A['+str(ACounter)+']['+str(ADegree)+']' for ADegree , AComponent in ACplx ] ]
            Body = []
            for BDegree , BComponent in BCplx :
                Row = [ 'B['+str(BCounter)+']['+str(BDegree)+']' ]
                for ADegree , AComponent in ACplx :
                    if isinstance( BComponent , str ) or isinstance( AComponent , str ) : Result = '...'
                    else                                                                : Result = BComponent.EXT(AComponent)
                    Row += [ Result ]
                Body += [ Row ]
            print( table( Header + Body , header_column=True , header_row=True ) )
            print()
On the sequence 0 -> cS_y -> ... -> cS_y(l_y) -> 0 whenever cS_y is from the starting block of the spinor collection ------------------------------------------------------------------------------------------------------------------------------------------------------ cS_y = VB(Lambda[4]) with l_y = 5 (y=0) Initialise the left side. Initialise the right side. Construction of A´s: Counter=1: Complex: ... --d_-3--> 0 --d_-2--> VB(Lambda[4]) --d_-1--> VB(Lambda[4]) --d_0--> 0 --d_1--> ... Is complex numerically exact? True Construction of B´s: Counter=-1: Complex: ... --d_-2--> 0 --d_-1--> Kernel --d_0--> B4(0,0,0,1) * VB(5*Lambda[3]) --d_1--> VB(5*Lambda[3] + Lambda[4]) --d_2--> 0 --d_3--> ... Is complex numerically exact? True Compute EXTs from B[-1][*] to A[1][*]: Objects: B[-1][0] = Kernel B[-1][1] = B4(0,0,0,1) * VB(5*Lambda[3]) B[-1][2] = VB(5*Lambda[3] + Lambda[4]) A[1][-1] = VB(Lambda[4]) A[1][0] = VB(Lambda[4]) | A[1][-1] A[1][0] +----------+-------------------+-------------------+ B[-1][0] | ... ... B[-1][1] | {} {} B[-1][2] | {12: B4(0,0,0,0)} {12: B4(0,0,0,0)} ------------------------------------------------------------------------------------------------------------------------------------------------------ cS_y = Equivariant extension of VB(Lambda[1] + Lambda[4]) by VB(Lambda[4]) with l_y = 5 (y=1) Initialise the left side. Initialise the right side. Construction of A´s: Counter=1: Complex: ... --d_-4--> 0 --d_-3--> Equivariant extension of VB(Lambda[1] + Lambda[4]) by VB(Lambda[4]) --d_-2--> B4(0,0,0,1) * VB(Lambda[3]) --d_-1--> Equivariant extension of VB(Lambda[3] + Lambda[4]) by VB(Lambda[2] + Lambda[4]) --d_0--> 0 --d_1--> ... Is complex numerically exact? True Construction of B´s: Counter=-1: Complex: ... --d_-2--> 0 --d_-1--> Kernel --d_0--> ( B4(0,0,0,0) + B4(1,0,0,0) ) * VB(5*Lambda[3] + Lambda[4]) --d_1--> Equivariant extension of VB(Lambda[1] + 5*Lambda[3] + Lambda[4]) by VB(5*Lambda[3] + Lambda[4]) --d_2--> 0 --d_3--> ... Is complex numerically exact? True Compute EXTs from B[-1][*] to A[1][*]: Objects: B[-1][0] = Kernel B[-1][1] = ( B4(0,0,0,0) + B4(1,0,0,0) ) * VB(5*Lambda[3] + Lambda[4]) B[-1][2] = Equivariant extension of VB(Lambda[1] + 5*Lambda[3] + Lambda[4]) by VB(5*Lambda[3] + Lambda[4]) A[1][-2] = Equivariant extension of VB(Lambda[1] + Lambda[4]) by VB(Lambda[4]) A[1][-1] = B4(0,0,0,1) * VB(Lambda[3]) A[1][0] = Equivariant extension of VB(Lambda[3] + Lambda[4]) by VB(Lambda[2] + Lambda[4]) | A[1][-2] A[1][-1] A[1][0] +----------+------------------------------------------------------------------+----------+-------------------+ B[-1][0] | ... ... ... B[-1][1] | {11: B4(0,0,0,0) + B4(1,0,0,0), 12: B4(0,0,0,0) + B4(1,0,0,0)} {} {} B[-1][2] | {11: B4(0,0,0,0) + B4(1,0,0,0), 12: 2*B4(0,0,0,0) + B4(1,0,0,0)} {} {11: B4(0,0,0,0)} ------------------------------------------------------------------------------------------------------------------------------------------------------ cS_y = Equivariant extension of VB(2*Lambda[1] + Lambda[4]) by VB(Lambda[1] + Lambda[4]) with l_y = 2 (y=2) Initialise the left side. Initialise the right side. Construction of A´s: Counter=1: Complex: ... --d_-5--> 0 --d_-4--> Equivariant extension of VB(2*Lambda[1] + Lambda[4]) by VB(Lambda[1] + Lambda[4]) --d_-3--> B4(0,0,0,1) * VB(Lambda[1] + Lambda[3]) --d_-2--> B4(0,0,0,1) * VB(Lambda[2] + Lambda[3]) --d_-1--> Equivariant extension of VB(Lambda[2] + Lambda[3] + Lambda[4]) by VB(2*Lambda[2] + Lambda[4]) --d_0--> 0 --d_1--> ... Is complex numerically exact? True Construction of B´s: Counter=-1: Complex: ... --d_-2--> 0 --d_-1--> Kernel --d_0--> Equivariant extension of ( B4(0,0,0,0) + B4(1,0,0,0) ) * VB(Lambda[1] + 2*Lambda[3] + Lambda[4]) by ( B4(0,0,0,0) + B4(1,0,0,0) ) * VB(2*Lambda[3] + Lambda[4]) --d_1--> Equivariant extension of VB(2*Lambda[1] + 2*Lambda[3] + Lambda[4]) by VB(Lambda[1] + 2*Lambda[3] + Lambda[4]) --d_2--> 0 --d_3--> ... Is complex numerically exact? True Compute EXTs from B[-1][*] to A[1][*]: Objects: B[-1][0] = Kernel B[-1][1] = Equivariant extension of ( B4(0,0,0,0) + B4(1,0,0,0) ) * VB(Lambda[1] + 2*Lambda[3] + Lambda[4]) by ( B4(0,0,0,0) + B4(1,0,0,0) ) * VB(2*Lambda[3] + Lambda[4]) B[-1][2] = Equivariant extension of VB(2*Lambda[1] + 2*Lambda[3] + Lambda[4]) by VB(Lambda[1] + 2*Lambda[3] + Lambda[4]) A[1][-3] = Equivariant extension of VB(2*Lambda[1] + Lambda[4]) by VB(Lambda[1] + Lambda[4]) A[1][-2] = B4(0,0,0,1) * VB(Lambda[1] + Lambda[3]) A[1][-1] = B4(0,0,0,1) * VB(Lambda[2] + Lambda[3]) A[1][0] = Equivariant extension of VB(Lambda[2] + Lambda[3] + Lambda[4]) by VB(2*Lambda[2] + Lambda[4]) | A[1][-3] A[1][-2] A[1][-1] A[1][0] +----------+------------------+----------+----------+------------------------------------------------------------------------------------------------+ B[-1][0] | ... ... ... ... B[-1][1] | {} {} {} {2: 2*B4(0,0,0,0) + 2*B4(1,0,0,0), 3: B4(0,0,0,0) + B4(1,0,0,0), 1: B4(0,0,0,0) + B4(1,0,0,0)} B[-1][2] | {5: B4(0,0,0,0)} {} {} {3: 2*B4(0,0,0,0), 2: B4(0,0,0,0)}
VB(2*Lambda[1] + Lambda[3] + 2*Lambda[4]) + VB(Lambda[1] + 4*Lambda[4]) + VB(Lambda[2] + Lambda[3] + 2*Lambda[4]) + VB(Lambda[1] + Lambda[3] + 2*Lambda[4]) + VB(Lambda[1] + Lambda[2] + 2*Lambda[3]) + VB(4*Lambda[4])
--------------------------------------------------------------------------- KeyError Traceback (most recent call last) Cell In [27], line 2 1 print( cA[Integer(1)].SemiSimplification(Integer(0)) ) ----> 2 print( cB[-Integer(1)].SemiSimplification(Integer(0)) ) KeyError: -1 


P = Wedge2Q.Extend_Equivariantly_By(O)
print( 'On the sequence 0 -> P -> ... -> P('+str(len(P.Maximal_Numerically_Exceptional_Orbit()))+') -> 0' )
print()



K = dict({})

Objects = dict({})
Objects.update({ -2 : P , -1 : S0(1)*rS , 0 : 'Cokernel' })
K.update({ 1 : X.Complex( Objects ) })



print()



L = dict({})

Objects = dict({})
Objects.update({ 0 : 'Kernel' , 1 : P(5) })
L.update({ -1 : X.Complex( Objects ) })



for Label , Stack in [ ( 'K' , K ) , ( 'L' , L ) ] :
    print( 'Construction of '+Label+'´s:' )
    for Counter , Complex in Stack.items() :
        print( 'Counter='+str(Counter)+':' )
        print( 'Complex:')
        print( Complex )
        print( 'Is complex numerically exact?' , Complex.Is_Numerically_Exact() )
        print()



print()



for LCounter , LCplx in L.items() :
    for KCounter , KCplx in K.items() :

        print('Compute EXTs from L['+str(LCounter)+'][*] to L['+str(KCounter)+'][*]:')

        print( 'Objects:' )
        for Label , Cplx in [ ( 'L' , LCplx ) , ( 'K' , KCplx ) ] :
            print( table([ [ Label+'['+str(LCounter)+']['+str(Degree)+']' , '=' , Component ] for Degree , Component in Cplx ]) )
            print()

        Header = [ [ '' ] + [ 'K['+str(KCounter)+']['+str(KDegree)+']' for KDegree , KComponent in KCplx ] ]
        Body = []
        for LDegree , LComponent in LCplx :
            Row = [ 'L['+str(LCounter)+']['+str(LDegree)+']' ]
            for KDegree , KComponent in KCplx :
                if isinstance( LComponent , str ) or isinstance( KComponent , str ) : Result = '...'
                else                                                                : Result = LComponent.EXT(KComponent)
                Row += [ Result ]
            Body += [ Row ]
        print( table( Header + Body , header_column=True , header_row=True ) )
        print()
On the sequence 0 -> P -> ... -> P(5) -> 0 Construction of K´s: Counter=1: Complex: ... --d_-4--> 0 --d_-3--> Equivariant extension of VB(Lambda[2]) + VB(Lambda[1] - Lambda[3] + 2*Lambda[4]) + VB(-Lambda[3] + 2*Lambda[4]) by VB(0) --d_-2--> B4(0,0,0,1) * VB(Lambda[3] + Lambda[4]) --d_-1--> Cokernel --d_0--> 0 --d_1--> ... Is complex numerically exact? False Construction of L´s: Counter=-1: Complex: ... --d_-2--> 0 --d_-1--> Kernel --d_0--> Equivariant extension of VB(Lambda[2] + 5*Lambda[3]) + VB(Lambda[1] + 4*Lambda[3] + 2*Lambda[4]) + VB(4*Lambda[3] + 2*Lambda[4]) by VB(5*Lambda[3]) --d_1--> 0 --d_2--> ... Is complex numerically exact? True Compute EXTs from L[-1][*] to L[1][*]: Objects: L[-1][0] = Kernel L[-1][1] = Equivariant extension of VB(Lambda[2] + 5*Lambda[3]) + VB(Lambda[1] + 4*Lambda[3] + 2*Lambda[4]) + VB(4*Lambda[3] + 2*Lambda[4]) by VB(5*Lambda[3]) K[-1][-2] = Equivariant extension of VB(Lambda[2]) + VB(Lambda[1] - Lambda[3] + 2*Lambda[4]) + VB(-Lambda[3] + 2*Lambda[4]) by VB(0) K[-1][-1] = B4(0,0,0,1) * VB(Lambda[3] + Lambda[4]) K[-1][0] = Cokernel | K[1][-2] K[1][-1] K[1][0] +----------+------------------------------------------------------------------------------------------------+----------+---------+ L[-1][0] | ... ... ... L[-1][1] | {12: 4*B4(0,0,0,0) + B4(1,0,0,0) + B4(0,1,0,0), 11: 3*B4(0,0,0,0) + B4(1,0,0,0) + B4(0,1,0,0)} {} ...