next | previous | forward | backward | up | top | index | toc | home

deRhamAll(RingElement) -- deRham complex for the complement of a hypersurface

Synopsis

Description

The routine deRhamAll can be used to compute cup product structures as in the paper 'The cup product structure for complements of affine varieties' by Walther(2000).

For a more basic functionality see deRham.

i1 : R = QQ[x,y]

o1 = R

o1 : PolynomialRing
i2 : f = x^2-y^3 

        3    2
o2 = - y  + x

o2 : R
i3 : deRhamAll f

                                        2      1
o3 = HashTable{BFunction => (s - 1)(s - -)(s - -)                           
                                        3      3
                                                    1
               CohomologyGroups => HashTable{0 => QQ }
                                                    1
                                             1 => QQ
                                             2 => 0
               LocalizeMap => | -x_2^3+x_1^2 |
                                                                            
               OmegaRes => (QQ [x , x , D , D , WeylAlgebra => {x  => D , x 
                                 1   2   1   2                   1     1   2
                                                                            
                           0                                                
               PreCycles => HashTable{0 => | 0 |}
                                           | 1 |
                                      1 => | 0 |
                                           | 1 |
                                           | 0 |
                                      2 => 0
               TransferCycles => HashTable{0 => | 3x_2^3-3x_1^2 |}
                                           1 => | 2x_1   |
                                                | 3x_2^2 |
                                           2 => 0
                                                                            
               VResolution => (QQ [x , x , D , D , WeylAlgebra => {x  => D ,
                                    1   2   1   2                   1     1 
                                                                            
                              0                                             
     ------------------------------------------------------------------------
                                                                       







             1                                                         
     => D }])  <-- (QQ [x , x , D , D , WeylAlgebra => {x  => D , x  =>
         2               1   2   1   2                   1     1   2   
                                                                       
                   1                                                   










                1                                                      
     x  => D }])  <-- (QQ [x , x , D , D , WeylAlgebra => {x  => D , x 
      2     2               1   2   1   2                   1     1   2
                                                                       
                      1                                                
     ------------------------------------------------------------------------
                                                                    







          2                                                         
     D }])  <-- (QQ [x , x , D , D , WeylAlgebra => {x  => D , x  =>
      2               1   2   1   2                   1     1   2   
                                                                    
                2










             3                                                      
     => D }])  <-- (QQ [x , x , D , D , WeylAlgebra => {x  => D , x 
         2               1   2   1   2                   1     1   2
                                                                    
                   2
     ------------------------------------------------------------------------
                    }







          1
     D }])  <-- 0
      2          
                3











             2
     => D }])  <-- 0
         2          
                   3

o3 : HashTable

See also