
A.6.1 GITFans
Dolgachev/Hu and Thaddeus assigned to an algebraic variety with the action of
an algebraic group the GITfan, a polyhedral fan enumerating the GITquotients 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 GITfan 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 GITvariation 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 DeligneMumford compactification M06bar of the moduli space of 6pointed
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 GITfans, 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 crossboarder 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 GITFan of M05bar.
We first compute the GITfan 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 GITFan 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 particularily 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).
