This C++ program accompanies the paper [GZ18]. It implements and combines a subset of the features of the following two pre-existing pieces of code:
- The (unpublished) C program described by T. Chinburg, C. Escher and W. Ziller in Topological properties of Eschenburg spaces and 3-Sasakian manifolds ([CEZ07]), which generates lists of pairs of Eschenburg spaces whose "basic polynomial invariants" (
r,sandp₁) agree. - The Maple program for computing invariants of Eschenburg spaces, also mentioned in [CEZ07] and available on W. Ziller's homepage.
In [GZ18], the program is used to find pairs of positively curved Eschenburg spaces which are homotopy equivalent but not tangentially homotopy equivalent, and to find pairs of such spaces which are tangentially homotopy equivalent but non-homeomorphic.
Two precompiled binaries are available with the latest release:
esch -- an executable file for 64 bit Linux systems
esch.exe -- an executable file for 64 bit Windows systems
Both have been compiled on Ubuntu 14.04, using gcc and mingw, respectively. With a bit of luck, one of these will run on your system. In this case, simply download the respective file to a folder of your choice.
If these binaries do not work for you, you will need to download/clone the complete repository and compile from scratch. Call make win or make nix to compile using the supplied Makefiles. You will likely need to adapt the Makefiles to suit your system. Your may also need to download and install some boost libraries.
There appear to be precompiled versions of MinGW, the GNU C compiler for Windows, in which the boost libraries are already included:
nuwen.net/mingw.html (no warranty).
Once installed, the program can be run from the command line: simply navigate to the directory in which the program is installed and call ./esch (on Linux) or esch.exe (on Windows). Starting the program like this, without any additional parameters, will display some short usage instructions.
To analyse the Eschenburg space E defined by the parameters (k,l) = (k₁,k₂,k₃,l₁,l₂,l₃), enter one of
./esch [k₁,k₂,k₃,l₁,l₂,l₃]
./esch "[k₁, k₂, k₃, l₁, l₂, l₃]"
For details on the invariants computed, see the Mathematical background below.
With the default configuration, the output of the program should be reliable for parameters kᵢ and lᵢ of absolute values up to 1500 (see docs/limits.pdf and Configuration below).
To count the number of various 'isomorphism' classes of positively curved Eschenburg spaces in a certain range, say with r < 5000, enter:
./esch r=5000
(or esch.exe r=5000 on Windows). Output will be written to the following files in the same directory:
list1-he.txt |
homotopy classes |
list2-the.txt |
tangential homotopy classes |
list3-homeo.txt |
homeomorphism classes |
In addition to the counting statistics, these files will contain lists of tuples that specify the same isomorphism class.
See the examples files in the folder sample-results. Note that, unless you rename them, the files will be overwritten the next time the program is run. To limit the maximum file size, the maximum number of tuples listed in each file can be controlled with the command-line option print = XXX, e.g.
./esch r=5000 print=10000
The default value is controlled by the configuration variable DEFAULT_MAX_TUPLES_PER_TUPLE_SIZE_PER_FILE, which can only be set at compile time (current value is 1010).
With the default configuration for the data types used, results should be reliable up to values of r ≤ 600.000 (see docs/limits.pdf and Configuration below).
For background on Eschenburg spaces, see [GZ18] or [CEZ07]. Here we just summarize some of the key points. The spaces were first introduced and studied in [Esch82]. Each Eschenburg space is a (bi)quotient of SU(3) by an action of S¹. Following [CEZ07], we specify this action of S¹ and the resulting Eschenburg space E = E(k,l) by a six-tuple of integer parameters (k,l) = (k₁,k₂,k₃,l₁,l₂,l₃), which we refer to as the parameter vector of E. The parameters need to satisfy k₁+k₂+k₃ = l₁+l₂+l₃, and some further conditions that ensure that the S¹-action is free, see [CEZ07, (1.1)].
Eschenburg defines a torus-invariant metric on a compact Lie group to be a left-invariant metric which is bi-invariant with respect to some maximal torus [Esch84, §34]. Let us define a left Eschenburg metric on an Eschenburg space E(k,l) to be a quotient metric of a metric on SU(3) that is torus-invariant and invariant with respect to the S¹-action specified by the parameter vector (k,l). An Eschenburg space is said to be positively curved if it has positive sectional curvature with respect to some left Eschenburg metric. This positive curvature condition translates into a simple condition on the parameters, see [Esch84, Satz 414] or [CEZ07, (1.2)].
The diffeomorphism class of an Eschenburg space E = E(k,l) is invariant under the following transformations of its parameter vector (cf. [CEZ07, above Lemma 1.4]):
- Permute the parameters (k₁,k₂,k₃), or permute the parameters (l₁,l₂,l₃).
- Simultaneously switch the signs of all parameters.
- Simultaneously add a fixed integer n to each parameter.
Moreover, the positive curvature condition is also unaffected by these changes. It follows that any positively curved Eschenburg space is diffeomorphic to an Eschenburg space E = E(k,l) with
k₁ ≥ k₂ > l₁ ≥ l₂ ≥ l₃ = 0 (*)
[CEZ07, Lemma 1.4]. More precisely, whenever E(k',l') is positively curved, we can find a parameter vector (k,l) satisfying (*) and left Eschenburg metrics g and g' such that (E(k',l'),g') and (E(k,l),g) are isometric and have positive sectional curvature. We call parameter vectors satisfying (*) normalized. All parameter vectors generated by the program when in “counting mode” are normalized in this sense.
The invariants computed by the program are:
| range | [CEZ07] | [Mil00] | definition/interpretation | |
|---|---|---|---|---|
r |
∈ ℕ | r = |r(k,l)| | L₂ | |σ₂(k) - σ₂(l)| = order of H⁴(E) |
s |
∈ (-r/2, r/2) ∩ ℤ |
s | L₃ | representative of σ₃(k) - σ₃(l) ∈ ℤ/r (determines linking form) |
Σ |
∈ {-1, 0, 1} | – | r | representative of σ₁(l) ∈ ℤ/3 |
p₁ |
∈ {0, ..., r-1} |
p₁ | – | representative of first Pontryagin class ∈ H⁴(E) = ℤ/r |
s₂ |
∈ (-1/2, 1/2] | s₂ | – | representative of KS-invariant s₂ ∈ ℚ/ℤ |
s₂₂ |
∈ (-1/2, 1/2] | s₂₂ | – | representative of KS-invariant s₂₂ ∈ ℚ/ℤ |
Here, the left column denotes the notation for the various invariants used by the program;
the third and fourth columns indicate the notation used in the literature.
Evidently, we are trying to follow the notation of [CEZ07] as closely as possible.
Note that the invariants s₂ and s₂₂ can only be computed when the parameters (k₁,k₂,k₃,l₁,l₂,l₃) satisfy a certain (weak) condition called "condition C" [CEZ07, §2]. For a translation between the parametrization of Eschenburg spaces used in [Mil00] and the parametrization used here, see [Sha02, end of §2].
The table below summarizes which invariants need to agree in order for two Eschenburg spaces satisfying condition C to have the same homotopy type/homeomorphism type etc.
For example, the first line says that, according [Kru98], two Eschenburg spaces are homotopy equivalent through an orientation-preserving homotopy equivalence if and only if their invariants r, s, and s₂₂ agree.
| invariants … agree | ⇔ | spaces agree up to … | References |
|---|---|---|---|
r, s, s₂₂ |
⇔ | oriented homotopy equivalence | [Kru98] |
r, s, s₂₂, p₁ |
⇔ | oriented tangential homotopy equivalence | [GZ18] |
r, s, s₂, p₁ |
⇔ | oriented homeomorphism | [Kru05] [CEZ07, Thm 2.3] |
r, |s|, |s₂₂|, sign(s)·sign(s₂₂) |
⇔ | homotopy equivalence | [Mil00] [Kru98] |
r, |s|, |s₂₂|, sign(s)·sign(s₂₂), p₁ |
⇔ | tangential homotopy equivalence | [GZ18] |
|r|, |s|, |s₂|, sign(s)·sign(s₂), p₁ |
⇔ | homeomorphism | [Kru05] [CEZ07, Thm 2.3] |
In the second half of the table, the sign of an invariant is defined as one of the values +1, 0, -1 in the evident way. The sign of s₂ is 0 if and only if s₂ = 0 or s₂ = 1/2 (since 1/2 = -1/2 in ℚ/ℤ), and likewise for s₂₂.
The code is structured as follows:
esch_space.h implement class Space
esch_space.cpp
All code for computing the above invariants is contained in this class. The class also contains comparison functions that determine whether two spaces are homotopy equivalent/tangentially homotopy equivalent/homeomorphic.
esch_tuples.h implement class SpaceTuple
esch_tuples.cpp class SpaceTupleList
esch_generate.cpp
The class SpaceTuple is a simple wrapper around std::deque< Space >. The class SpaceTupleList is a wrapper around std::deque < SpaceTuple > with two interesting constructors:
One constructor, implemented separately in esch_generate.cpp, first generates a list of all positively curved Eschenburg spaces with r bounded by a given integer. (More precisely, it generates a list of parameter values (k₁,k₂,k₃,l₁,l₂,l₃) that specify an Eschenburg space with r bounded by this integer.) It then uses Milgram's homotopy invariants to find tuples of homotopy equivalent spaces on this list. See docs/esch_generate.md for further details.
The other constructor takes an existing list of tuples and a "filter" as input. Possible "filters" are "tangential homotopy class" or "homeomorphism class". The constructor looks for (sub-)tuples of spaces in the given list of tuples that fall into the same isomorphism class according to the "filter".
The interface of these classes is demonstrated in esch.cpp.
When compiling from scratch, the data types used in the computations and a few other options can be set in config.h. See docs/limits.pdf.