# hsop algorithms -- an overview of the algorithms used in primaryInvariants

This page contains a discussion on the two algorithms that are used in the function primaryInvariants, which computes a homogenous system of parameters (hsop) for the invariant ring R:=K[x1,...,xn]G of a finite group G. Which algorithm is used depends on the Boolean value the optional argument Dade takes. In the case where it is set to false it uses what shall be referred to as the 'default' algorithm. If it is set to true then it uses what shall be called the 'Dade' algorithm.

The default algorithm is an implementation of the 'optimal' algorithm given in [K]. It is optimal in the sense that it finds a hsop f1,...,fn such that the number of secondary invariants required to make R into a free K[f1,...,fn]-module is minimal. The first step in the default algorithm is to cycle through the List s={d1,...,dn} of possible degrees for the hsop. It tests the degrees against two restrictions that are known to hold for any hsop of R: firstly, the order of G must divide the product d1*...*dn and secondly, the polynomial H(R,T)*(1-Td1)*...*(1-Tdn) must lie in ZZ[T], where H(R,T) is the Molien (Hilbert) series of R [DK, p83]. Once a List of suitable degrees is found, the algorithm uses a Krull-dimension based test that holds for algebras over infinite fields to determine the existence of a hsop with the candidate degrees; see [K, Theorem 2]. It then finds such a hsop if one exists, or tries a new List of degrees if such a hsop does not exist. Note: if one knows a priori that a hsop exists for some List of degrees, this can be assigned to the optional argument DegreeVector and the default algorithm will compute a hsop with degrees corresponding to this List. Finally, users should be aware that the default algorithm currently only works in the case where R is defined over a field of characteristic zero.

The Dade algorithm is simpler than the default algorithm. It first constructs a Dade basis v1,...,vn for the dual space V* spanned by x1,...,xn. Then for each i, it computes the polynomial fi defined as the product over the G-orbit of vi. The resulting collection f1,...,fn is a hsop for R; see [DK, pp80,81]. In the implemented Dade algorithm, a Dade basis is constructed iteratively by choosing random linear forms such that vi is not contained in any of the vector subspaces spanK{w1,...,wi-1}, where wj is in the G-orbit of vj. The Dade algorithm can work with the case of finite fields, provided that the field is large enough to ensure Kn cannot be filled by the union of the subspaces mentioned in the construction of the Dade basis. A sufficient, though not necessarily optimal, requirement is that |K|>|G|n-1. Because of the random generation involved in the construction of a Dade basis, the Dade algorithm will generally output n primary invariants of degrees equalling the order of G that have ugly coefficients.

The example below provides a good comparison of the two different algorithms and their relative merits.

 i1 : A=matrix{{0,-1,0},{1,0,0},{0,0,-1}} o1 = | 0 -1 0 | | 1 0 0 | | 0 0 -1 | 3 3 o1 : Matrix ZZ <--- ZZ i2 : B=matrix{{0,-1,0},{1,0,0},{0,0,1}} o2 = | 0 -1 0 | | 1 0 0 | | 0 0 1 | 3 3 o2 : Matrix ZZ <--- ZZ i3 : C4xC2=finiteAction({A,B},QQ[x,y,z]) o3 = QQ[x..z] <- {| 0 -1 0 |, | 0 -1 0 |} | 1 0 0 | | 1 0 0 | | 0 0 -1 | | 0 0 1 | o3 : FiniteGroupAction

The two algorithms used in primaryInvariants are timed. One sees that the Dade algorithm is faster, however the primary invariants output are all of degree 8 and have ugly coefficients.

 i4 : time P1=primaryInvariants C4xC2 -- used 2.74608 seconds 2 2 2 4 4 o4 = {x + y , z , x + y } o4 : List i5 : time P2=primaryInvariants(C4xC2,Dade=>true) -- used 0.699121 seconds 8 7 6 2 5 3 4 4 3 5 o5 = {4096x + 24576x y + 38912x y - 18432x y - 65280x y + 18432x y + ------------------------------------------------------------------------ 2 6 7 8 6 2 5 2 4 2 2 38912x y - 24576x*y + 4096y - 23040x z - 69120x y*z - 28800x y z - ------------------------------------------------------------------------ 2 4 2 5 2 6 2 4 4 3 4 28800x y z + 69120x*y z - 23040y z + 42768x z + 31104x y*z + ------------------------------------------------------------------------ 2 2 4 3 4 4 4 2 6 2 6 8 67392x y z - 31104x*y z + 42768y z - 29160x z - 29160y z + 6561z , ------------------------------------------------------------------------ 8 7 6 2 5 3 4 4 104976x - 629856x y + 997272x y + 472392x y - 1673055x y - ------------------------------------------------------------------------ 3 5 2 6 7 8 6 2 472392x y + 997272x y + 629856x*y + 104976y - 1428840x z + ------------------------------------------------------------------------ 5 2 4 2 2 2 4 2 5 2 4286520x y*z - 1786050x y z - 1786050x y z - 4286520x*y z - ------------------------------------------------------------------------ 6 2 4 4 3 4 2 2 4 1428840y z + 6417873x z - 4667544x y*z + 10113012x y z + ------------------------------------------------------------------------ 3 4 4 4 2 6 2 6 8 4667544x*y z + 6417873y z - 10588410x z - 10588410y z + 5764801z , ------------------------------------------------------------------------ 8 7 6 2 5 3 1679616x - 59719680x y + 789543936x y - 4539432960x y + ------------------------------------------------------------------------ 4 4 3 5 2 6 7 8903312896x y + 4539432960x y + 789543936x y + 59719680x*y + ------------------------------------------------------------------------ 8 6 2 5 2 4 2 2 1679616y - 68864256x z + 1224253440x y*z - 5372262144x y z - ------------------------------------------------------------------------ 2 4 2 5 2 6 2 4 4 5372262144x y z - 1224253440x*y z - 68864256y z + 722864736x z - ------------------------------------------------------------------------ 3 4 2 2 4 3 4 4 4 302330880x y*z + 2721397824x y z + 302330880x*y z + 722864736y z - ------------------------------------------------------------------------ 2 6 2 6 8 348625296x z - 348625296y z + 43046721z } o5 : List

The extra work done by the default algorithm to ensure an optimal hsop is rewarded by needing to calculate a smaller collection of corresponding secondary invariants. In fact, it has proved quicker overall to calculate the invariant ring based on the optimal algorithm rather than the Dade algorithm.

 i6 : time secondaryInvariants(P1,C4xC2) -- used 0.106899 seconds 3 3 o6 = {1, x y - x*y } o6 : List i7 : time secondaryInvariants(P2,C4xC2) -- used 5.25737 seconds 2 2 2 4 2 2 2 2 2 2 3 3 4 4 6 2 4 o7 = {1, z , x + y , z , x z + y z , x y , x y - x*y , x + y , z , x z + ------------------------------------------------------------------------ 2 4 2 2 2 3 2 3 2 4 2 4 2 4 2 2 4 5 5 6 y z , x y z , x y*z - x*y z , x z + y z , x y + x y , x y - x*y , x ------------------------------------------------------------------------ 6 3 4 3 4 4 4 4 4 4 2 2 2 4 2 5 2 5 2 + y , x y*z - x*y z , x z + y z , x y z + x y z , x y*z - x*y z , ------------------------------------------------------------------------ 6 2 6 2 4 4 5 3 3 5 6 2 2 6 7 7 8 8 5 4 x z + y z , x y , x y - x y , x y + x y , x y - x*y , x + y , x y*z ------------------------------------------------------------------------ 5 4 6 4 6 4 4 4 2 5 3 2 3 5 2 6 2 2 2 6 2 7 2 - x*y z , x z + y z , x y z , x y z - x y z , x y z + x y z , x y*z ------------------------------------------------------------------------ 7 2 8 2 8 2 6 4 4 6 7 3 3 7 8 2 2 8 9 - x*y z , x z + y z , x y + x y , x y - x y , x y + x y , x y - ------------------------------------------------------------------------ 9 10 10 8 4 8 4 8 2 2 2 8 2 9 2 9 2 10 2 x*y , x + y , x z + y z , x y z + x y z , x y*z - x*y z , x z + ------------------------------------------------------------------------ 10 2 7 5 5 7 8 4 4 8 9 3 3 9 10 2 2 10 11 y z , x y - x y , x y + x y , x y - x y , x y + x y , x y - ------------------------------------------------------------------------ 11 12 12 10 2 2 2 10 2 11 2 11 2 12 2 12 2 x*y , x + y , x y z + x y z , x y*z - x*y z , x z + y z , ------------------------------------------------------------------------ 10 4 4 10 11 3 3 11 12 2 2 12 13 13 14 14 x y + x y , x y - x y , x y + x y , x y - x*y , x + y , ------------------------------------------------------------------------ 14 2 14 2 13 3 3 13 14 2 2 14 15 15 16 16 x z + y z , x y - x y , x y + x y , x y - x*y , x + y , ------------------------------------------------------------------------ 17 17 18 18 20 20 x y - x*y , x + y , x + y } o7 : List i8 : #oo o8 = 64

Of course, currently one advantage of the Dade algorithm is that it can calculate a hsop for the invariant ring when considering a finite field. Since |C4xC2|2=64, it is safe to consider the finite field with 101 elements.

 i9 : K=GF(101); i10 : C4xC2=finiteAction({A,B},K[x,y,z]) o10 = K[x..z] <- {| 0 -1 0 |, | 0 -1 0 |} | 1 0 0 | | 1 0 0 | | 0 0 -1 | | 0 0 1 | o10 : FiniteGroupAction i11 : primaryInvariants(C4xC2,Dade=>true) 8 7 6 2 5 3 4 4 3 5 2 6 7 o11 = {- 4x - 4x y - 36x y + 37x y + 50x y - 37x y - 36x y + 4x*y - ----------------------------------------------------------------------- 8 6 2 5 2 4 2 2 2 4 2 5 2 6 2 4y - 31x z + 35x y*z + 48x y z + 48x y z - 35x*y z - 31y z - ----------------------------------------------------------------------- 4 4 3 4 2 2 4 3 4 4 4 2 6 2 6 20x z - 21x y*z + 37x y z + 21x*y z - 20y z + 14x z + 14y z + ----------------------------------------------------------------------- 8 8 7 6 2 5 3 4 4 3 5 2 6 16z , - 49x + 14x y + 43x y + 23x y - 9x y - 23x y + 43x y - ----------------------------------------------------------------------- 7 8 6 2 5 2 4 2 2 2 4 2 5 2 14x*y - 49y - 39x z + 20x y*z - 5x y z - 5x y z - 20x*y z - ----------------------------------------------------------------------- 6 2 4 4 3 4 2 2 4 3 4 4 4 2 6 39y z - 38x z + 20x y*z + 36x y z - 20x*y z - 38y z + 2x z + ----------------------------------------------------------------------- 2 6 8 8 7 6 2 5 3 4 4 3 5 2 6 2y z + z , - 9x + 34x y - 29x y + 10x y - 29x y - 10x y - 29x y ----------------------------------------------------------------------- 7 8 6 2 5 2 4 2 2 2 4 2 5 2 - 34x*y - 9y + 27x z + 50x y*z - 45x y z - 45x y z - 50x*y z + ----------------------------------------------------------------------- 6 2 4 4 3 4 2 2 4 3 4 4 4 2 6 27y z + 8x z + 28x y*z + 2x y z - 28x*y z + 8y z + 46x z + ----------------------------------------------------------------------- 2 6 8 46y z + 25z } o11 : List

References

[DK] Derksen, H., Kemper, G. Computational Invariant Theory. Berlin Heidelberg New York: Springer-Verlag, 2002

[K] Kemper, G. An Algorithm to Calculate Optimal Homogeneous Systems of Parameters. J. Symbolic Computation 27 (1999), 171-184