Example RngOrdGal_GaloisGroups (H40E4)

> Z:= Integers();
> P<x>:= PolynomialRing(Z);
> G, R, S := GaloisGroup(x^6-108);
> G;
Permutation group G acting on a set of cardinality 6
Order = 6 = 2 * 3
    (1, 5, 3)(2, 6, 4)
    (1, 2)(3, 6)(4, 5)
> R;
[ -58648*$.1 + 53139 + O(11^5), 58648*$.1 - 19478 +
O(11^5), -43755*$.1 - 72617 + O(11^5), 58648*$.1 -
    53139 + O(11^5), -58648*$.1 + 19478 + O(11^5),
    43755*$.1 + 72617 + O(11^5) ]
> S;
GaloisData over Z_11

> time G, _, S := GaloisGroup(x^32-x^16+2);
Time: 65.760
> #G;
2048

> load galpols;
> f := PolynomialWithGaloisGroup(9, 14);
> G := GaloisGroup(f);
> TransitiveGroupIdentification(G);
14 9
> M := MaximalOrder(f);
> kM := FieldOfFractions(M);
> f:= Factorisation(Polynomial(kM, f))[2][1];
> f;
$.1^8 + (-2/1*kM.1 + kM.2)*$.1^7 + (-60/1*kM.1 -
    2/1*kM.2 + kM.3)*$.1^6 + (120/1*kM.1 - 60/1*kM.2 -
    2/1*kM.3 + kM.4)*$.1^5 + (980/1*kM.1 + 120/1*kM.2 -
    60/1*kM.3 - 2/1*kM.4 + kM.5)*$.1^4 + (-1808/1*kM.1
    + 980/1*kM.2 + 120/1*kM.3 - 60/1*kM.4 - 2/1*kM.5 +
    kM.6)*$.1^3 + (-4012/1*kM.1 - 1808/1*kM.2 +
    980/1*kM.3 + 120/1*kM.4 - 60/1*kM.5 - 2/1*kM.6 +
    kM.7)*$.1^2 + (4936/1*kM.1 - 4013/1*kM.2 -
    1809/1*kM.3 + 979/1*kM.4 + 118/1*kM.5 - 60/1*kM.6 -
    4/1*kM.7 + 3/1*kM.8)*$.1 - 208769062021/1*kM.1 +
    51146604497/1*kM.2 - 30878218588/1*kM.3 +
    50063809507/1*kM.4 - 52067647419/1*kM.5 -
    94281823910/1*kM.6 + 69906801827/1*kM.7 -
    182364865509/1*kM.8 + 214706745867/1*kM.9
> g, r, p:= GaloisGroup(f);
> TransitiveGroupIdentification(g);
5 8

> Subgroups(G:OrderEqual := #g);
Conjugacy classes of subgroups
------------------------------

[1]     Order 8            Length 9
        Permutation group acting on a set of
        cardinality 9
        Order = 8 = 2^3
            (2, 4, 5, 3)(6, 8, 7, 9)
            (2, 7, 5, 6)(3, 9, 4, 8)
            (2, 5)(3, 4)(6, 7)(8, 9)
> IsIsomorphic(g, $1[1]`subgroup);
true Homomorphism of GrpPerm: g, Degree 8, Order 2^3
into GrpPerm: $, Degree 9, Order 2^3 induced by
    (1, 2, 3, 8)(4, 5, 6, 7) |--> (2, 4, 5, 3)(6, 8, 7, 9)
    (1, 7, 3, 5)(2, 6, 8, 4) |--> (2, 7, 5, 6)(3, 9, 4, 8)

Straight-line Polynomials

One of the most important tools in the computational Galois theory are invariants, that is multivariate polynomials that are invariant under some permutation group. While invariant theory in general is a rich and classical branch of mathematics, and is supported by a powerful magma module, Chapter INVARIANT THEORY, the more specific needs in the Galois theory are best met with a different set of functions. Invariants, in this chapter are multivariate polynomials in straight-line representation, the polynomials are represented as programs without branches. The category of these polynomials is of type RngSLPol and its elements are of type RngSLPolElt. A consequence of this representation is that certain operations are very fast, while others are impossible - or at least very difficult. For example, representing (a - b)¹⁰⁰⁰(a + b)¹⁰⁰⁰ - (a² - b²)¹⁰⁰⁰ is trivial, this is a short program with just a few steps:

1

subtract b from a

2

raise to the 1000th power

3

add a and b

4

raise to the 1000th power

5

multiply the results of steps 2 and 4

6

subtract b² from a² and raise to the 1000th power

7

subtract the result of step 7 from 5

x * y : RngSLPolElt, RngSLPolElt -> RngSLPolElt

x + y : RngSLPolElt, RngSLPolElt -> RngSLPolElt

x - y : RngSLPolElt, RngSLPolElt -> RngSLPolElt

- x : RngSLPolElt -> RngSLPolElt

SLPolynomialRing(R, n) : Rng, RngIntElt -> RngSLPol

    Global: BoolElt                     Default: false

Creates the ring of multivariate straight-line polynomials over the ring R with n indeterminates. If Global is set to true then an existing straight-line polynomial ring will be returned if one has previously constructed.

Name(R, i) : RngSLPol, RngIntElt -> RngSLPolElt

R . i : RngSLPol, RngIntElt -> RngSLPolElt

Return the ith indeterminate of the SL-polynomial ring R.

ElementarySymmetricPolynomial(R, i) : RngSLPol, RngIntElt -> RngSLPolElt

The i-th elementary symmetric polynomial of the SL-polynomial ring R.

BaseRing(R) : RngSLPol -> Rng

CoefficientRing(R) : RngSLPol -> Rng

Return the coefficient ring of the SL-polynomial ring R.

Rank(R) : RngSLPol -> RngIntElt

Return the rank of the SL-polynomial ring R, ie the number of independent indeterminates over the coefficient ring.

SetEvaluationComparison(R, F, n) : RngSLPol, FldFin, RngIntElt ->

For a SL-polynomial ring R, prepare "probabilistic" comparison of straight-line polynomials, using evaluation at n tuples drawn at random from the finite field F.

In order to allow a probabilistic test for "equality" of SL-polynomials in places where a strict, deterministic test is not necessary, this allows comparison of SL-polynomials through their values at random evaluation points.

GetEvaluationComparison(R) : RngSLPol -> FldFin, RngIntElt

Return the finite field and the number of random samples used to compare polynomials of the SL-polynomial ring R. If SetEvaluationComparison has not been called, the 1st return value will be false while the second is undefined.

InitializeEvaluation(R, S) : RngSLPol, [RngElt] ->

Store the point to evaluate straight line polynomials with parent R to contain the elements of the sequence S whose length is the rank of R and whose elements are coercible into R.

Derivative(x, i) : RngSLPolElt, RngIntElt -> RngSLPolElt

The ith partial derivative of the SL-polynomial x.

Evaluate(f) : RngSLPolElt -> RngElt

Evaluate(f, S) : RngSLPolElt, [RngElt] -> RngElt

Evaluate(f, S, m) : RngSLPolElt, [RngElt], Map -> RngElt

Return the evaluation of the straight-line polynomial f at the elements of the sequence S where S contains the rank of the parent of f many elements coercible into the coefficient ring of f and if not given as an argument to this intrinsic is the sequence which was last input to InitializeEvaluation. The map m from the coefficient ring of f into the universe of S can be specified if required.

Invariants

At the core of the computation of Galois groups is the single Stauduhar step where, for a group G and a (maximal) subgroup U the programme decides if the Galois group is a subgroup of U - provided it was contained in G. This is achieved by evaluating a G-relative U-invariant polynomial f∈Z[x₁, ..., x_n] (or f ∈F_q[t][x₁, ..., x_n] when the characteristic of the coefficient ring of the input polynomial is prime). In this subsection several functions are collected that allow a user to access magma's internally used invariants. In what follows, an invariant is always a multivariate polynomial f in n indeterminates where n is the degree of G i.e. G<S_n. Invariants are represented as straight-line polynomials that allow the very compact representation and fast evaluation of polynomials.

GaloisGroupInvariant(G, H) : GrpPerm, GrpPerm -> RngSLPolElt

    DoCost: BoolElt                     Default: false

    Worklevel: RngIntElt                Default: -1

    SetVerbose("GaloisGroup", n):       Maximum: 3

For subgroups H<G of the symmetric group on n elements, where H is maximal in G and G is transitive, compute a G-relative H-invariant. This is done by carefully comparing certain group theoretical properties of the group pair in question to find invariant polynomials of special types that are easy to evaluate. If this fails, generic invariants will be used.

If DoCost is true, two values are returned: the first return value in this case is an estimate for the number of multiplications necessary to evaluate the invariant, while the second value is a function that can be evaluated without arguments to compute the invariant. This is done to allow to compare invariants by their computational complexity before actually committing and computing them explicitly as this can be very time consuming.

If Worklevel is set to an integer different from -1 only certain types of invariants are tested for suitability for this particular pair of groups. In this case a special return value of false indicates that Magma was unable to find an invariant at this level. Roughly speaking, the higher the Worklevel, the more time-consuming the invariant will be, both in terms of the time spend in finding as well as the time necessary to evaluate the invariant.

RelativeInvariant(G, H) : GrpPerm, GrpPerm -> RngSLPolElt

    IsMaximal: BoolElt                  Default: false

    Risk: BoolElt                       Default: false

    SetVerbose("Invariant", n):         Maximum: 3

For a pair of subgroups H<G of the symmetric group where H is not necessarily maximal in G, find a G-relative H-invariant polynomial. The computation splits into three phases:

- First, a subgroup chain between H and G is computed such that each step in the chain is a maximal subgroup.

- Second, for each pair U_i<U_{i + 1} of maximal subgroups one fixed invariant is computed

- Third, in the last step, the invariants are combined to produce a G-relative H-invariant.

If IsMaximal is set to true, Magma will not compute a subgroup chain but instead assume that H is a maximal subgroup of G. Otherwise Magma will compute all minimal overgroups of H in G and call GaloisGroupInvariant for each of them. Finally, Magma will combine these invariants to a relative one.

The parameter Risk refers to an old version of the function and does not have an effect.

CombineInvariants(R, G, H1, H2, H3) : Rng, GrpPerm, Tup<GrpPerm, RngSLPolElt>, Tup<GrpPerm, RngSLPolElt>, GrpPerm -> RngSLPolElt

Given a subgroup G<S_n and three maximal subgroups H₁, H₂ and H₃ of G two of which have already known invariants, try to derive an invariant for H₃ from the known ones over the ring R (usually Z). The input for H₁ and H₂ consists of a tuple with two (or three) entries, the first specifying the actual subgroup, the second the G-relative H_i-invariant and the optional third a Tschirnhaus transformation that should be done before the invariant is evaluated.

The typical situation in which this function is used is the case of H₁ and H₂ being index 2 subgroups of G. In this case elementary theory immediately guarantees a third subgroup H₃ of index 2. For this function to work, the core of H₁ ∩H₂ must be contained in H₃. This is only useful if the index of the core is not too large.

IsInvariant(F, p) : RngSLPolElt, GrpPermElt -> BoolElt

    Sign: BoolElt                       Default: false

For a multivariate polynomial F in straight-line representation and a permutation p this function tests if F^p = F with a high probability. In particular, this function will evaluate F at random elements in some large finite field, then permute the evaluation points by p and evaluate again. If the values agree, the polynomial is most likely invariant under p, if they disagree than the polynomial is definitely not invariant. The probability of failure is related to the probability of guessing a zero of a multivariate polynomial at random.

In order to get a proof for the invariants, one can convert F into a standard multivariate polynomial and check directly that this is invariant. However, for the invariants typically constructed in the Galois package, the conversion into a multivariate polynomial will not be possible due to the large degree of the polynomial and the resulting large number of terms.

If Sign is set to true, the function checks instead for F^p = - F.

Bound(I, B) : RngSLPolElt, RngIntElt -> RngIntElt

Given a multivariate polynomial I in straight-line representation and an integer B, compute an integer M such that |I(x₁, ..., x_n)|≤M for all complex numbers |x_i|≤B. This returns a bound for the size of an evaluation of I.

Bound(I, B) : RngSLPolElt, RngElt -> RngElt

Given a multivariate polynomial I in straight-line representation and B, a power series over the integers, compute a power series M such that for all choices of power series x_i such that the coefficients of x_i are bounded in absolute value by those of B we have that the power series I(x₁, ..., x_n) has coefficients bounded by those of M.

PrettyPrintInvariant(I) : RngSLPolElt -> MonStgElt

Prints the straight-line polynomial I into a string. The printing shows the way the polynomial is stored internally. E.g. the reuse of subexpressions gets visible.

Subfields and Subfield Towers

The result of a Galois group computation contains, in addition to the Galois group as an abstract group, the explicit action of the group on the roots of the underlying polynomial in some splitting field. This explicit action, together with the availability of invariants for group pairs, can be used to compute arbitrary subfields of the splitting field.

GaloisSubgroup(K, U) : FldNum, GrpPerm -> RngUPolElt, RngSLPolElt

GaloisSubgroup(S, U) : GaloisData, GrpPerm -> RngUPolElt, RngSLPolElt

GaloisSubgroup(f, U) : RngUPolElt, GrpPerm -> RngUPolElt, RngSLPolElt

    SetVerbose("Invariant", n):         Maximum: 2

Given either a polynomial f or number field K or a successful computation of a Galois group in S and a subgroup U<G where G is the Galois group, find a defining polynomial for the subfield of the splitting field that is fixed by U and return also a G-relative U-invariant.

GaloisQuotient(K, Q) : FldNum, GrpPerm -> SeqEnum[RngUPolElt]

GaloisQuotient(f, Q) : RngUPolElt, GrpPerm -> SeqEnum[RngUPolElt]

GaloisQuotient(S, Q) : GaloisData, GrpPerm -> SeqEnum[RngUPolElt]

    SetVerbose("Invariant", n):         Maximum: 2

Given either a polynomial f or number field K or a successful computation of a Galois group in S and a permutation group Q, find all subfields of the splitting field that have a Galois group isomorphic to Q. The defining polynomials of these subfields are returned. This is done by finding all subgroups U of the Galois group G such that the permutation action of G on the cosets G/U is isomorphic to Q.

GaloisSubfieldTower(S, L) : GaloisData, [GrpPerm] -> FldNum, [Tup<RngSLPolElt, RngUPolElt, [GrpPermElt]>], UserProgram, UserProgram

    Risk: BoolElt                       Default: false

    MinBound: RngIntElt                 Default: 1

    MaxBound: RngIntElt                 Default: ∞

    Inv: [RngSLPolElt]                  Default: false

    SetVerbose("GaloisTower", n):       Maximum: 2

For data computed as the third return value of GaloisGroup and a subgroup chain U₁ > U₂ > ... > U_s, compute the corresponding tower of fixed fields K_i that is fixed by the operation of U_i on the roots of f as ordered in S.

Currently, this function only works for polynomials defined over Q, F_q[t] or absolute extensions of Q.

The first return value is the largest number field in the tower, that is the field fixed by the smallest group in the chain as an extension of the fixed field of the second group which is an extension of the fixed field of the third group etc. The second return value is a sequence of tuples each containing the data used to generate one step:

- The first item is the invariant used in this step. This corresponds directly to the choice of the primitive element.

- The second item is the Tschirnhaus transformation on this level

- The third item is a transversal of U_i over U_{i + 1}, the fixed ordering of which gives the ordering of the "relative conjugates"

The third and fourth return values can be used to algebraically identify arbitrary elements of the splitting field that are defined by multivariate polynomials. The third is a function that takes a vector of p-adic conjugates and returns an algebraic representation of the element, the fourth takes an invariant and computes precision bounds for the precision necessary so that the algebraic recognition will work.

If Risk is set to true, then for non-maximal subgroup pairs U_i> U_{i + 1} the "risky" version of RelativeInvariant is used.

The parameter MinBound can be used to specify a minimal p-adic precision that should be used internally. This can be used to avoid the calculation of an increase in precision which can be costly. On the other hand, to work in larger precision than necessary also incurs a time penalty.

The parameter MaxBound can be used to limit the p-adic precision used internally. Especially when the chain get longer, the internally used precision estimates become more and more pessimistic thus forcing higher and higher precision. In certain cases when it is possible to verify the correctness of the result independently, a smaller precision can speed the computation up considerably.

If the parameter Inv is given it should contain a sequence of invariants, the i-th entry need be an U_i relative U_{i + 1} invariant. The invariants used correspond almost directly to the relative primitive elements computed at each step in the tower. This is useful in situation where either certain primitive elements are necessary or where certain invariants are known.

GaloisSplittingField(f) : RngUPolElt -> FldNum, [FldNumElt], GrpPerm, [[FldNumElt]]

    Galois: Tup<GrpPerm, [RngElt], GaloisData> Default: 

    Roots: BoolElt                      Default: true

    AllAuto: BoolElt                    Default: false

    Stab: BoolElt                       Default: true

    Chain: [GrpPerm]                    Default: false

    Inv: [RngSLPolElt]                  Default: false

    Name: MonStgElt                     Default: false

For a polynomial f in Z[t], Q[t] or over an absolute number field or F_q[t], this function computes the splitting field of f as a tower of fields. The various parameter can be used to force certain subfield towers and/ or compute additional data. By default Stab is set to true, which means that the splitting field will be the tower corresponding to the chain of stabilizers of {1}, {1, 2}, ..., {1, ..., n}. Also by default Roots is set to true, which means that the roots of f are expressed as elements of the splitting field. If Roots is set to false, only the field is computed and returned.

The third return value will be the Galois group, the optional fourth value the automorphisms.

If the parameter Galois is used, it should contain a list or triplet containing the output of GaloisGroup(f);.

If Chain is set to a sequence of subgroups, this chain is used to compute a subfield tower. In this case the first elements must be G, the full Galois group. If Chain is used, Inv can be used to provide the invariants as well.

If AllAuto is set to true, the full automorphism group of the splitting field is computed as a sequence of sequences giving the all the roots of the relative polynomials.

If Name is given, it should be set to a string. In this case the primitive element of the i-subfield in the tower will be called Name.i.

> P<x> := PolynomialRing(IntegerRing());
> f := x^3-2;
> GaloisSplittingField(f);
Number Field with defining polynomial $.1^2 +
    $.1*$.1 + $.1^2 over its ground field
[
    $.1,
    $.1,
    -$.1 - $.1
]
Symmetric group acting on a set of cardinality 3
Order = 6 = 2 * 3
    (1, 2, 3)
    (1, 2)
> K, R, G := $1;
> K:Maximal;

  K
  |
  |
  $1
  |
  |
  Q

K : $.1^2 + $.1*$.1 + $.1^2
$1 : x^3 - 2
> [x^3 : x in R];
[
    2,
    2,
    2
]

> GaloisSplittingField(f:Name := "K");
Number Field with defining polynomial K1^2 + K2*K1
    + K2^2 over its ground field
[
    K2,
    K1,
    -K1 - K2
]
Symmetric group G acting on a set of cardinality 3
Order = 6 = 2 * 3
    (1, 2, 3)
    (1, 2)
> (K where K := $1):Maximal;

  $1<K1>
    |
    |
  $2<K2>
    |
    |
    Q

$1 : K1^2 + K2*K1 + K2^2
$2 : x^3 - 2

> G, r, S := GaloisGroup(f);
> GaloisSplittingField(f:Galois := <G, r, S>, 
>     Chain := CompositionSeries(G), Name := "K", AllAuto);
Number Field with defining polynomial K1^3 - 2
over its ground field
[
    K1,
    1/6*K2*K1,
    1/6*(-K2 - 6)*K1
]
Symmetric group G acting on a set of cardinality 3
Order = 6 = 2 * 3
    (1, 2, 3)
    (1, 2)
[
    [
        K2,
        -K2 - 6
    ],
    [
        K1,
        1/6*K2*K1,
        1/6*(-K2 - 6)*K1
    ]
]
> (K where K := $1):Maximal;

  $1<K1>
    |
    |
  $2<K2>
    |
    |
    Q

$1 : K1^3 - 2
$2 : x^2 + 6*x + 36

> f := x^10 - 20*x^8 + 149*x^6 - 519*x^4 + 851*x^2 - 529;
> G, r, S := GaloisGroup(f);G,r,S;
> TransitiveGroupIdentification(G);
8 10
> TransitiveGroupDescription(G);
[2^4]5

> time _ := SplittingField(f);

> time K, R := GaloisSplittingField(f:Name := "K");
Time: 4.740
> K:Maximal;

  K<K1>
    |
    |
  $1<K2>
    |
    |
  $2<K3>
    |
    |
  $3<K4>
    |
    |
    Q

K : K1^2 + 1/23*(-12*K4^8 + 217*K4^6 - 1374*K4^4
    + 3606*K4^2 - 3381)
$1 : K2^2 + 1/23*(18*K4^8 - 314*K4^6 + 1877*K4^4 -
    4512*K4^2 + 3588)
$2 : K3^2 + 1/23*(-5*K4^8 + 77*K4^6 - 377*K4^4 +
    663*K4^2 - 437)
$3 : x^10 - 20*x^8 + 149*x^6 - 519*x^4 + 851*x^2 -
    529
> [ Evaluate(f, x) eq 0 : x in R];
[ true, true, true, true, true, true, true, true,
true, true ]

> A := NormalSubgroups(G:OrderEqual := 16)[1]`subgroup;
> GaloisSubgroup(S, A);
x^5 + 1682*x^4 + 715964*x^3 + 99797360*x^2 +
    5206504944*x + 88019915488
(x5 + x10)

> K, D, Reco, Bnd := GaloisSubfieldTower(S, [A, sub<G|>]);
> GK := GaloisGroup(K);
> #GK;
16
> AbelianInvariant(GK);
[ 2, 2, 2, 2 ]

> R := SLPolynomialRing(Integers(), 10);
> i := R.1;
> B := S`max_comp; 
> bound := Bnd(B);

> rt := [GaloisRoot(i, S:Bound := bound) : i in [1..10]];
> con := CartesianProduct(Reverse([x[3]: x in D]));
> gamma := [Evaluate(i, PermuteSequence(rt, &*p)) : p in con];
> im := Reco(gamma: Bound := B);
> time Evaluate(f, im) eq 0;

> i := D[1][1]; t := D[1][2];
> B := Bound(i, Evaluate(t, S`max_comp));
> bound := Bnd(B);
> rt := [GaloisRoot(i, S:Bound := bound) : i in [1..10]];
> rt := [Evaluate(t, x) : x in rt];
> gamma := [Evaluate(i, PermuteSequence(rt, &*p)) : p in con];
> im := Reco(gamma : Bound := B);
> im;
$.1
> im eq K.2;
true;

> rt := PermuteSequence(rt, Random(G));
> gamma := [Evaluate(i, PermuteSequence(rt, &*p)) : p in con];
> au := Reco(gamma : Bound := B);
> au;
1/92*(-9*$.1^4 + 386*$.1^3 - 5854*$.1^2 + 37120*$.1 - 82288)

    Prime: RngIntElt                    Default: false

    Name: MonStgElt                     Default: false

    Galois: Tup<GrpPerm, [RngElt], GaloisData> Default: 

    UseZeta_p: BoolElt                  Default: false

    MaxBound: RngIntElt                 Default: ∞

    SetVerbose("GaloisTower", n):       Maximum: 3

> P<x> := PolynomialRing(IntegerRing());
> f := x^6 - x^5 - 6*x^4 + 7*x^3 + 4*x^2 - 5*x + 1;
> K, R := SolveByRadicals(f:Name := "K.");
> K:Maximal;

   K<K.1>
     |
     |
  $1<K.2>
     |
     |
  $2<K.3>
     |
     |
  $3<K.4>
     |
     |
     Q

K : K.1^3 + 1/2*(3*K.4 - 11)*K.2 + 1/2*(-27*K.4 + 23)
$1 : K.2^2 - 5
$2 : K.3^3 - 228*K.4 + 532
$3 : K.4^2 + 3

> [ Evaluate(f, x) eq 0 : x in R];
[ true, true, true, true, true, true ]

    Proof: BoolElt                      Default: true

    Galois: Tup<GrpPerm, [RngElt], GaloisData> Default: 

    UseAction: BoolElt                  Default: false

    UseLLL: BoolElt                     Default: true

    Power: RngIntElt                    Default: 1

    kMax: RngIntElt                     Default: ∞

    LogLambdaMax: RngIntElt             Default: ∞

    Proof: BoolElt                      Default: true

    Galois: Tup<GrpPerm, [RngElt], GaloisData> Default: 

    UseAction: BoolElt                  Default: false

    UseLLL: BoolElt                     Default: true

    Power: RngIntElt                    Default: 1

    kMax: RngIntElt                     Default: ∞

    LogLambdaMax: RngIntElt             Default: ∞

    Galois: Tup<GrpPerm, [RngElt], GaloisData> Default: 

    kMax: RngIntElt                     Default: ∞

> ST := ShephardTodd(8);
> R := InvariantRing(ST);
> p := PrimaryInvariants(R);
> p;
[
    x1^8 + (-4*i - 4)*x1^7*x2 + 14*i*x1^6*x2^2 + (-14*i + 
        14)*x1^5*x2^3 - 21*x1^4*x2^4 + (14*i + 14)*x1^3*x2^5
        - 14*i*x1^2*x2^6 + (4*i - 4)*x1*x2^7 + x2^8,
    x1^12 + (-6*i - 6)*x1^11*x2 + 33*i*x1^10*x2^2 + (-55*i +
        55)*x1^9*x2^3 - 231/2*x1^8*x2^4 + (66*i + 
        66)*x1^7*x2^5 + (-66*i + 66)*x1^5*x2^7 - 
        231/2*x1^4*x2^8 + (55*i + 55)*x1^3*x2^9 - 
        33*i*x1^2*x2^10 + (6*i - 6)*x1*x2^11 + x2^12
]
> res := Resultant(p[1]-2, p[2]-3, 2);
> f4  := Polynomial(Rationals(), UnivariatePolynomial(res));
> bool, f := IsPower(f4, 4);
> bool, f;
true 
27/4*x^24 - 135*x^16 + 405*x^12 - 405*x^8 + 162*x^4 - 1
> G, R, S := GaloisGroup(f);
> #G;
192
> rel := LinearRelations(f : Galois := <G, R, S>);
> #rel;
20

> v := rel[3];
> v;
[ 0, 0, 0, -1, 0, -1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
> IR := SLPolynomialRing(Integers(), 24);
> r := &+ [v[i]*IR.i : i in [1..24]];
> r;
(x7 + ((-1 * x4) + (-1 * x6)))
> VerifyRelation(f, r : Galois := <G, R, S>);
true

> I := &+ [ (e[n]-1)*IR.n : n in [1..24]] where e is Eltseq(Random(Sym(24)));
> Iorbit := [Apply(g, I) : g in G];
> #{Evaluate(i, R) : i in Iorbit};
192

> time #LinearRelations(f, Iorbit : Galois := <G, R, S>, Proof := false);
188
Time: 645.450

> exists(n){n : n in [1..24] | #Orbit(G, [1,n]) eq 192}; n;
true
2
> I := IR.1 + IR.n^2;
> Iorbit := [Apply(g, I) : g in G];
> #{Evaluate(i, R) : i in Iorbit};
192
> time #LinearRelations(f, Iorbit : Galois := <G, R, S>, Proof := false);
182
Time: 816.120