### A.6.1 GIT-Fans

Dolgachev/Hu and Thaddeus assigned to an algebraic variety with the action of an algebraic group the GIT-fan, a polyhedral fan enumerating the GIT-quotients in the sense of Mumford. The case of the action of an algebraic torus H on an ane variety X has been treated by Berchtold/Hausen. Based on their construction, an algorithm to compute the GIT-fan in this setting has been proposed be Keicher. Note that this setting is essential for many applications, since the torus case can be used to investigate the GIT-variation of the action of a connected reductive group G. In many important examples, X is symmetric under the action of a fnite group which either is known directly from its geometry or can be computed. A prominent instance is the Deligne-Mumford compactification M06bar of the moduli space of 6-pointed stable curves of genus zero, which has a natural action of the symmetric group S6. The library gitfan.lib implements an efficient algorithm for computing GIT-fans, which makes use of symmetries. We have applied this algorithm to determine the Mori chamber decomposition of the cone of movable divisor classes of M06bar. Each cone is represented by a single integer. The algorithm relies on Groebner basis techniques, convex geometry and actions of finite symmetry groups. It demonstrates the strength of cross-boarder methods in computer algebra, and the efficiency of the algorithms implemented in all involved areas. The algorithm is also suitable for parallel computations.

As an example we address in the following the computation of the GIT-Fan of M05bar.

We first compute the GIT-fan using the single line command provided by the library:

      LIB "gitfan.lib";
      setcores(4);
      ring R = 0,T(1..10),wp(1,1,1,1,1,1,1,1,1,1);
      ideal J =
        T(5)*T(10)-T(6)*T(9)+T(7)*T(8),
        T(1)*T(9)-T(2)*T(7)+T(4)*T(5),
        T(1)*T(8)-T(2)*T(6)+T(3)*T(5),
        T(1)*T(10)-T(3)*T(7)+T(4)*T(6),
        T(2)*T(10)-T(3)*T(9)+T(4)*T(8);
      intmat Q[5][10] =
        1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
        1, 0, 0, 0, 1, 1, 1, 0, 0, 0,
        0, 1, 1, 0, 0, 0, -1, 1, 0, 0,
        0, 1, 0, 1, 0, -1, 0, 0, 1, 0,
        0, 0, 1, 1, -1, 0, 0, 0, 0, 1;
      fan GIT = GITfan(J,Q);
      fVector(GIT);

The GIT-Fan can be computed using symmetries as follows:

      LIB "gitfan.lib";
      setcores(4);
      ring R = 0,T(1..10),wp(1,1,1,1,1,1,1,1,1,1);
      ideal J =
        T(5)*T(10)-T(6)*T(9)+T(7)*T(8),
        T(1)*T(9)-T(2)*T(7)+T(4)*T(5),
        T(1)*T(8)-T(2)*T(6)+T(3)*T(5),
        T(1)*T(10)-T(3)*T(7)+T(4)*T(6),
        T(2)*T(10)-T(3)*T(9)+T(4)*T(8);
      intmat Q[5][10] =
        1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
        1, 0, 0, 0, 1, 1, 1, 0, 0, 0,
        0, 1, 1, 0, 0, 0, -1, 1, 0, 0,
        0, 1, 0, 1, 0, -1, 0, 0, 1, 0,
        0, 0, 1, 1, -1, 0, 0, 0, 0, 1;
      list simplexSymmetryGroup = G25Action();
      fan GIT2 = GITfan(J,Q,simplexSymmetryGroup);
      GIT2;

Although we provide a procedure to compute the orbit decomposition of the group action on the simplex of variables this is not fast in Singular. In the following we describe how to use GAP to obtain the orbit decomposition and then continue with this data in Singular. This is particularly useful for more complicated examples.

The file orbits.gp in the directory doc of the Singular source tree contains GAP code to do this computation. This result is provided in the file doc/simplexOrbitRepresentativesG25.sing.

The file doc/simplexSymmetryGroupG25.sing contains the symmetry group (which here is S5).

Moreover the file doc/elementsInTermsOfGeneratorsG25.sing contains a representation of the elements of the symmetry group in terms of generators.

    LIB "gitfan.lib";
    setcores(4);
    ring R = 0,T(1..10),wp(1,1,1,1,1,1,1,1,1,1);
    ideal J =
      T(5)*T(10)-T(6)*T(9)+T(7)*T(8),
      T(1)*T(9)-T(2)*T(7)+T(4)*T(5),
      T(1)*T(8)-T(2)*T(6)+T(3)*T(5),
      T(1)*T(10)-T(3)*T(7)+T(4)*T(6),
      T(2)*T(10)-T(3)*T(9)+T(4)*T(8);
    intmat Q[5][10] =
      1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
      1, 0, 0, 0, 1, 1, 1, 0, 0, 0,
      0, 1, 1, 0, 0, 0, -1, 1, 0, 0,
      0, 1, 0, 1, 0, -1, 0, 0, 1, 0,
      0, 0, 1, 1, -1, 0, 0, 0, 0, 1;
    intmat Qt = transpose(Q);
    <"doc/simplexOrbitRepresentativesG25.sing";
    list afaceOrbitRepresentatives=afaces(J,simplexOrbitRepresentatives);
    <"doc/simplexSymmetryGroupG25.sing";
    list fulldimAfaceOrbitRepresentatives=fullDimImages(afaceOrbitRepresentatives,Q);
    list afaceOrbits=computeAfaceOrbits(fulldimAfaceOrbitRepresentatives,simplexSymmetryGroup);
    apply(afaceOrbits,size);
    list minAfaceOrbits = minimalAfaceOrbits(afaceOrbits);
    apply(minAfaceOrbits,size);
    list listOfOrbitConeOrbits = orbitConeOrbits(minAfaceOrbits,Q);
    apply(listOfOrbitConeOrbits,size);
    list listOfMinimalOrbitConeOrbits = minimalOrbitConeOrbits(listOfOrbitConeOrbits);
    size(listOfMinimalOrbitConeOrbits);
    cone mov = coneViaPoints(transpose(Q));
    mov = canonicalizeCone(mov);
    list OC =  listOfOrbitConeOrbits;
    <"doc/elementsInTermsOfGeneratorsG25.sing";
    list Asigmagens = groupActionOnQImage(generatorsG,Q);
    list actionOnOrbitconeIndicesForGenerators = groupActionOnHashes(Asigmagens,OC);
    list actionOnOrbitconeIndices;
    for (int i =1; i<=size(elementsInTermsOfGenerators);i++)
    {
      actionOnOrbitconeIndices[i]=evaluateProduct(actionOnOrbitconeIndicesForGenerators, elementsInTermsOfGenerators[i]);
    }
    list OClist = OC[1];
    for (i =2;i<=size(OC);i++)
    {
    OClist = OClist + OC[i];
    }
    list SigmaHashes = GITfanParallelSymmetric(OClist, Q, mov, actionOnOrbitconeIndices);
    SigmaHashes;
    fan Sigma = hashesToFan(SigmaHashes,OClist);

Note that the result is not the complete fan but only the fan generated by a minimal set of representatives of maximal cones for the group action (by the group generated by Asigmagens).

User manual for Singular version 4.4.1, 2025, generated by texi2html.