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.
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.
The object torAlgData is a method function.