invariants(...,Strategy=>...) -- choose the strategy for computing invariants

Description

The default strategy for computing invariants of a finite group action uses the Reynolds operator, however this may be slow for large groups. Using the option Strategy => "LinearAlgebra" uses the linear algebra method for computing invariants of a given degree by calling invariants(FiniteGroupAction,ZZ). This may provide a speedup at lower degrees, especially if the user-provided generating set for the group is small.

The following example computes the invariants of the symmetric group on 4 elements. Note that using different strategies may lead to different sets of generating invariants.

i1 : R = QQ[x_1..x_4]

o1 = R

o1 : PolynomialRing

i2 : L = apply({[2, 1, 3, 4], [2, 3, 4, 1]}, permutationMatrix);

i3 : S4 = finiteAction(L, R)

o3 = R <- <| 0 1 0 0 |, | 0 0 0 1 |>
           | 1 0 0 0 |  | 1 0 0 0 |
           | 0 0 1 0 |  | 0 1 0 0 |
           | 0 0 0 1 |  | 0 0 1 0 |

o3 : FiniteGroupAction

i4 : elapsedTime invariants S4
 -- .680574s elapsed

                          2    2    2    2   3    3    3    3   4    4    4  
o4 = {x  + x  + x  + x , x  + x  + x  + x , x  + x  + x  + x , x  + x  + x  +
       1    2    3    4   1    2    3    4   1    2    3    4   1    2    3  
     ------------------------------------------------------------------------
      4
     x }
      4

o4 : List

i5 : elapsedTime invariants(S4, Strategy => "LinearAlgebra")
 -- .124669s elapsed

o5 = {x  + x  + x  + x , x x  + x x  + x x  + x x  + x x  + x x , x x x  +
       1    2    3    4   1 2    1 3    2 3    1 4    2 4    3 4   1 2 3  
     ------------------------------------------------------------------------
     x x x  + x x x  + x x x , x x x x }
      1 2 4    1 3 4    2 3 4   1 2 3 4

o5 : List

Version 2.4 introduces a new algorithm to compute invariants of elementary abelian $p$-groups. As of version 2.5, this is the default strategy when applicable for a diagonal action, i.e., when there is no torus action, all cyclic factors have the same prime order, and the weight matrix has maximal rank. To call the older general-purpose algorithm, use the option Strategy=>"DerksenGandini"; see invariants(DiagonalAction) for an example.

Functions with optional argument named Strategy:

addHook(...,Strategy=>...) -- see addHook -- add a hook function to an object for later processing
annihilator(...,Strategy=>...) (missing documentation)
basis(...,Strategy=>...) -- see basis -- basis or generating set of all or part of a ring, ideal or module
mingens(...,Strategy=>...) -- see Complement -- a Strategy option value
trim(...,Strategy=>...) -- see Complement -- a Strategy option value
compose(Module,Module,Module,Strategy=>...) -- see compose -- composition as a pairing on Hom-modules
decompose(Ideal,Strategy=>...) (missing documentation)
determinant(...,Strategy=>...) -- choose between Bareiss, Cofactor and Dynamic algorithms
dual(MonomialIdeal,List,Strategy=>...) -- see dual(MonomialIdeal,Strategy=>...)
dual(MonomialIdeal,RingElement,Strategy=>...) -- see dual(MonomialIdeal,Strategy=>...)
dual(MonomialIdeal,Strategy=>...)
End(...,Strategy=>...) -- see End -- module of endomorphisms
epicResolutionMap(...,Strategy=>...) (missing documentation)
exteriorPower(...,Strategy=>...) -- choose between Bareiss, Cofactor and Dynamic algorithms
gb(...,Strategy=>...) -- see gb -- compute a Gröbner basis
GF(...,Strategy=>...) -- see GF -- make a finite field
groebnerBasis(...,Strategy=>...) -- see groebnerBasis -- Gröbner basis, as a matrix
hilbertFunction(...,Strategy=>...) (missing documentation)
Hom(...,Strategy=>...) -- see Hom -- module of homomorphisms
homomorphism'(...,Strategy=>...) -- see homomorphism' -- get the element of Hom from a homomorphism
hooks(...,Strategy=>...) -- see hooks -- list hooks attached to a key
intersect(Ideal,Ideal,Strategy=>...) -- see intersect(Ideal,Ideal) -- compute an intersection of a sequence of ideals or modules
intersect(Module,Module,Strategy=>...) -- see intersect(Ideal,Ideal) -- compute an intersection of a sequence of ideals or modules
invariantRing(...,Strategy=>...)
invariants(...,Strategy=>...) -- choose the strategy for computing invariants
isPrime(Ideal,Strategy=>...) (missing documentation)
kernel(...,Strategy=>...) -- strategy for Groebner Basis computations used in kernel computations
match(...,Strategy=>...) -- see match -- regular expression matching
minors(...,Strategy=>...) -- choose between Bareiss, Cofactor and Dynamic algorithms
normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
normalCone(Ideal,Strategy=>...) (missing documentation)
parallelApply(...,Strategy=>...) -- see parallelApply -- apply a function to each element in parallel
pruneComplex(...,Strategy=>...) -- Whether to use the methods in the package or C++ algorithms in the engine
pushForward(...,Strategy=>...) -- see pushForward(RingMap,Module) -- compute the pushforward of a module along a ring map
quotient'(...,Strategy=>...) (missing documentation)
quotient(...,Strategy=>...) (missing documentation)
resolutionMap(...,Strategy=>...) -- see resolutionMap -- map from a free resolution to the given complex
saturate(...,Strategy=>...) (missing documentation)
freeResolution(...,Strategy=>...) -- see Strategies for free resolutions -- overview of the different algorithms for computing free resolutions
syz(...,Strategy=>...) -- see syz(Matrix) -- compute the syzygy matrix

Further information

Default value: Default
Function: invariants -- computes the generating invariants of a group action
Option key: Strategy -- an optional argument

The source of this document is in InvariantRing/InvariantsDoc.m2:365:0.

invariants(...,Strategy=>...) -- choose the strategy for computing invariants

Description

See also

Functions with optional argument named Strategy:

Further information