next | previous | forward | backward | up | top | index | toc | Macaulay2 website
TorAlgebra :: torAlgData

torAlgData -- invariants of a local ring and its class (w.r.t. multiplication in homology)

Synopsis

Description

Computes invariants of the local ring obtained by localizing R at the irrelevant maximal ideal and, provided that it has codepth at most 3, classifies it as belonging to one of the (parametrized) classes B, C(c), G(r), H(p,q), S, or T. Rings of higher codepth are classified as C(c) (complete intersection), Gorenstein, Golod, or no class. Gorenstein rings of codepth 4 are further classified as belonging to one of the (parametrized) classes C(4), GS, GT, or GH(p). It is also possible to call the function on the defining ideal of R; see torAlgData(Ideal).

Returns a hash table with the following data of the local ring:

"c": codepth

"e": embedding dimension

"h": Cohen-Macaulay defect

"m": minimal number of generators of defining ideal

"n": type

"Class": class ('B', 'C', 'G', 'GH', 'GS', 'GT', 'H', 'S', 'T', 'Golod', 'Gorenstein' `zero ring', or 'no class')

"p": classification parameter

"q": classification parameter

"r": classification parameter

"isCI": boolean

"isGorenstein": boolean

"isGolod": boolean

"PoincareSeries": Poincar\'e series in closed from (rational function)

"BassSeries": Bass series in closed from (rational function)

i1 : Q = QQ[x,y,z];
i2 : data = torAlgData (Q/ideal(x*y,y*z,x^3,x^2*z,x*z^2-y^3,z^3))

                                        2    3    4
                             2 + 2T - 2T  - T  + T
o2 = HashTable{BassSeries => ----------------------    }
                                       2     3    4
                             1 - T - 5T  - 2T  + T
               c => 3
               Class => G
               e => 3
               h => 0
               isCI => false
               isGolod => false
               isGorenstein => false
               m => 6
               n => 2
               p => 0
                                               2
                                        (1 + T)
               PoincareSeries => ----------------------
                                           2     3    4
                                 1 - T - 5T  - 2T  + T
               q => 1
               r => 3

o2 : HashTable
i3 : data#"PoincareSeries"

                   2
            (1 + T)
o3 = ----------------------
               2     3    4
     1 - T - 5T  - 2T  + T

o3 : Expression of class Divide
i4 : Q = QQ[w,x,y,z];
i5 : torAlgData (Q/ideal(w^2-x*y*z,x^3,y^3,x^2*z,y^2*z,z^3-x*y*w,x*z*w,y*z*w,z^2*w-x^2*y^2))

o5 = HashTable{BassSeries => 1                          }
               c => 4
               Class => GH
               e => 4
               h => 0
               isCI => false
               isGolod => false
               isGorenstein => true
               m => 9
               n => 1
               p => 2
                                                2
                                         (1 + T)
               PoincareSeries => -----------------------
                                            2     4    5
                                 1 - 2T - 6T  + 2T  - T
               q => 3
               r => 9

o5 : HashTable
i6 : Q = QQ[v,w,x,y,z];
i7 : torAlgData (Q/(ideal(v^2-w^3)*ideal(v,w,x,y,z)))

                                        2     3    4    5
                             1 + 4T + 6T  + 4T  + T  - T
o7 = HashTable{BassSeries => ----------------------------    }
                                       2     3     4    5
                             1 - T - 4T  - 6T  - 4T  - T
               c => 5
               Class => Golod
               e => 5
               h => 4
               isCI => false
               isGolod => true
               isGorenstein => false
               m => 5
               n => 1
               p => 0
                                                  4
                                           (1 + T)
               PoincareSeries => ----------------------------
                                           2     3     4    5
                                 1 - T - 4T  - 6T  - 4T  - T
               q => 0
               r => -

o7 : HashTable
i8 : Q = QQ[u,v,w,x,y,z];
i9 : torAlgData (Q/ideal(u^2,v^2,w^2-y^4,x^2,x*y^15))

o9 = HashTable{BassSeries => UNDETERMINED    }
               c => 5
               Class => no class
               e => 6
               h => 1
               isCI => false
               isGolod => false
               isGorenstein => false
               m => 5
               n => 1
               p => UNDETERMINED
               PoincareSeries => UNDETERMINED
               q => UNDETERMINED
               r => -

o9 : HashTable

To extract data from the hash table returned by the function one may use torAlgDataList and torAlgDataPrint.

Caveat

If the embedding dimension of R is large, then the response time may be longer, in particular if R is a quotient of a polynomial algebra over a small field. The reason is that the function attempts to reduce R modulo a generic regular sequence of generators of the irrelevant maximal ideal. The total number of attempts made can be controlled with setAttemptsAtGenericReduction.

If R is a quotient of a polynomial algebra by a homogeneous ideal, then it is graded and the relevant invariants of the local ring obtained by localizing R at the irrelevant maximal ideal can be determined directly from R. If R is a quotient of a polynomial algebra by a non-homogeneous ideal, then the function uses the package LocalRings to compute some of the invariants.

Ways to use torAlgData :

For the programmer

The object torAlgData is a method function.