The programs
Typically, you would:
- Run SAGE, import a script, and use its methods to get GAP to produce some files.
- Use these files with the rep program.
- Use the output from rep with the program hom.
- In case of success, and if the cohomology is generated by Stiefel-Whitney classes, you can use the results with the program milnor.
These steps are documented below.
The SAGE script
You can download the script here. CD where the script is and run SAGE. Type in:
sage: from sw_sage_module import *
Then pick a GAP group, eg:
sage: G= gap("SmallGroup(8,4)")
Then you set things up with:
sage: info= rep_info(G)
You start the various computations with:
sage: info.write_complex_repring()
sage: info.write_real_repring()
(some output)
sage: info.restrictions_elemab()
A base name will be chosen automatically for the files, of the form gpN_K where N is the order of G and K its number in the Small Groups Library. The files created are
- gpN_K.gaprep
- gpN_K.gaprep.real
- gpN_K.res.elemab
Note: G must be a group for which the IdGroup() method works! Most (all?) groups in the Small Groups Library will be fine. If something went wrong, try:
sage: G.IdGroup()
Check whether you get an error message. If so, you can edit the script and change the lines 54-57. It is self explanatory, really: just set self.name to anything. Sorry about this.
The C++ program rep
(rep is for representation ring, not a very good name...)
Usage: ./rep 'name' [options]
Options:
- -quiet: displays less messages
- -silent: displays no messages at all.
This program computes the formal ring of Stiefel-Whitney classes of a
given group.
It expects a name on the command line, which will be used as
a prefix for all the names of input and output files. Say you want to
work with the quaternion group of order 8. Since its GAP number is 4,
you can for example use 'gp8_4' as a base name, and use:
./sw gp8_4
Input files:
rep looks for three files, all
of them presumably produced by GAP (see corresponding documentation):
- name.gaprep (eg gp8_4.gaprep)
- name.gaprep.real (eg gp8_4.gaprep.real)
- name.res.elemab (eg gp8_4.res.elemab)
The first, resp second, describes the complex, resp real,
representation ring. The third file describes the restriction of these
representation rings to elementary abelian subgroups.
Also, rep needs a bunch of files called
elemab-ranki.gaprep.real for various integers i between 1 and the
2-rank of the group under consideration (eg elemab-rank3.gaprep.real). It is a good idea to place
all the files elemab-ranki.gaprep.real for, say, 1<= i <= 6 once
and for all in the folder where rep is, if you are studying
groups whose order divides 26.
Output files:
Then rep produces four files:
- name.W (eg gp8_4.W) This file describes the formal
ring of Stiefel-Whitney classes. More precisely, this file
contains a object of class UnstableAlgebra.
- name.W.res.elemab (eg gp8_4.W.res.elemab) This
file contains a translation of the restrictions to elementary
abelian subgroups, in terms of Stiefel-Whitney classes. More
precisely, the file contains:
- an integer giving the number of subgroups considered,
- for each subgroup, an integer giving the rank, followed by an
AffineHomomorphism< F_2 >. Its source is supposed to be the
algebra given by the previous file, and its target is the
cohomology of an elementary abelian subgroup.
- name.gaprep.chern (eg gp8_4.chern) This gives the
values of the Chern classes in the formal ring. More
precisely, this file contains a GradedAlgebra< F_2 > which is
a polynomial ring on all the Chern classes, followed by an
AffineHomomorphism< F_2 > from this graded algebra to the
formal ring.
- name.gaprep.sw (eg gp8_4.sw) This expresses the
remaining Stiefel-Whitney classes in the formal ring (which has a
presentation in terms of some of these
classes). More precisely, this file contains an
UnstableAlgebra followed by an AffineHomomorphism< F_2
>.
The C++ program hom
(hom is for homomorphisms)
Usage: ./hom 'name' [options]
Options:
- -quiet: displays less messages
- -silent: displays no messages at all.
- -brute: use the "variant" algorithm (see paper).
This program finds all the well-defined homomorphisms between the
formal ring of Stiefel-Whitney classes (computed by the
program rep) and the mod 2 cohomology of the group. Then it
checks whether there is "essentially" only one homomorphism, up to
some reasonable equivalence.
When this is the case, hom goes on to add the minimum number
of variables to the formal ring in order to make the homomorphism
surjective, and compute its kernel. It also checks that this new
kernel does not depend on the homomorphism taken in the unique
equivalence class, and some other details. When everything is well, it
returns 0, meaning that the computation is complete.
It expects a name on the command line, which will be used as
a prefix for all the names of input and output files. Say you want to
work with the quaternion group of order 8. Since its GAP number is 4,
you can for example use 'gp8_4' as a base name, and use:
./hom gp8_4
Input files: The program needs the following files:
- name.cohomology.mod2 (eg gp8_4.cohomology.mod2)
This is the mod 2 cohomology of the group, eg as downloaded from
Carlson's webpage. More precisely, this file is expected to
contain a GradedAlgebra< F_2 >.
- name.W ( eg gp8_4.W ) This is the formal ring
computed by rep. More precisely, this file is
expected to contain an UnstableAlgebra.
- name.W.res.elemab (eg gp8_4.W.res.elemab) This is
produced by rep, see above.
Output files: The following files are produced:
- name.final (eg gp8_4.final) This file is produced
when the computation is complete (exit code 0). It contains the
cohomology of the group, presented in terms of Stiefel-Whitney
classes, together with information on the Steenrod
operations. More precisely, this file contains
- an UnstableAlgebra. If some of the variables have names which
are not of the form w_i(r_j), then the Steenrod operations on these
are not correct. These are not Stiefel-Whitney
classes.
- an AffineHomomorphism< F_2 > which gives the map between
the formal ring (file name.W) and the above UnstableAlgebra
- an AffineHomomorphism< F_2 > giving a representative
homomorphism between the above UnstableAlgebra and the mod 2
cohomology.
- name.solutions (eg gp8_4.solutions) The first part
of the computation, ie looking for all well-defined homomorphisms,
is very time-consuming. When it is completed, the results are saved
in this file. It is possible, if the program is interrupted, to
start it again with the same 'name': it will look for the file
name.solutions and resume the computation from there. More
precisely, the file contains an integer giving the number of
homomorphisms, and then it contains a sequence of
AffineHomomorphism< F_2 >.
The C++ program milnor
(milnor suggests the algebra of "Milnor constants")
Usage: ./milnor 'name' [options]
Options:
- -quiet: displays less messages
- -silent: displays no messages at all.
This program computes the algebra of Milnor constants, that is, even-degree elements which are killed by the Milnor derivations.
It expects a name on the command line, which will be used as
a prefix for all the names of input and output files. Say you want to
work with the quaternion group of order 8. Since its GAP number is 4,
you can for example use 'gp8_4' as a base name, and use:
./milnor gp8_4
Input files: The program needs the following file:
- name.final (eg gp8_4.final)
Produced by hom, see above.
Output files: The following file is produced:
- name.milnor (eg gp8_4.milnor) This file contains a minimal list of generators for the Milnor constants. More precisely, this file contains
- a GradedAlgebra< F_2 >. This is just a polynomial algebra.
- an AffineHomomorphism< F_2 > which gives a map between
this polynomial ring and the cohomology (as read from name.final). The images of the variables are generators for the Milnor invariants.