This package implements general simplicial complex software for the purpose of finding and studying pseudo cones.
Download the Java jar file from https://ken.baclawski.com/pc.jar. Run the jar file using this command:
java -jar pc.jarand the program will explain the command-line arguments.
The following are the command-line arguments:
Here is an example:
java -jar pc.jar 5 3 6 700 20000 results.csvThis will generate simplicial complexes with at most 5 vertices, with length 3, and with 3 maximal simplices. A total of 20,000 simplicial complexes will be generated with these properties. For each candidate for being a proper pseudo cone the program will try 700 times to find a pseudo cone structure before giving up. The statistics are printed both to the standard output and to the results.csv file.
If you prefer to use a Graphical User Interface rather than the command line, then use this link: https://ken.baclawski.com/nupcf/. It will run a Java applet. The web page as instructions. The source code for the applet is available at https://ken.baclawski.com/nupcf/PseudoConeApplet.java.
The {@link pc.SimplicialComplex} class provides general functionality for simplicial complexes. A simplex is specified using an integer in which the one bits are the vertices of the simplex. The number of vertices can be at most 31. A simplicial complex is specified by an array of maximal simplices. There are methods for testing whether a simplicial complex is connected, whether it has an even number of simplices, whether it is a cone (and returns a peak vertex if it is a cone), and whether it is a pseudo cone. Other useful methods are the computation of the link of a vertex and the subcomplex obtained by removing one vertex. There is also a method that tests whether there is a vertex that allows the simplicial complex to be link reduced.
The {@link pc.PseudoCone} class provides an abstraction for the pseudo cone concept. The constructor tries to find a bijection (Hasse diagram matching) by attempting to arrange the simplices in pairs. The vertices are examined starting with the empty simplex and then proceeding up from one length to the next. Within each length, the simplices are examined in a random order. Each simplex is matched with a randomly selected simplex that covers it and that is not yet matched.
Note that while the bijections are selected randomly, it would not be correct to say that they are selected uniformly at random. The fact that the simplices are matched by levels does have an effect on the probability distribution of the bijections. On the other hand, within each level, the simplices are tested in an order that is uniformly random.
As mentioned earlier, a simplex is specified using an integer in which the one bits are the vertices of the simplex. This limits the number of vertices to 32. The software actually limits the number to 31 to avoid problems with signs. One can increase the limit to 63 by using longs rather than ints.
Sets of simplices are implemented using hash sets. An alternative that was tried was to use bit sets. While bit sets improve performance somewhat, they use too much memory when the number of vertices is large. Since the improvement in speed is only about 10%, bit sets were not used.
Extensive profiling has shown that the main performance bottleneck is in the topological sort algorithm, not in the simplicial complex algorithms. So there is little to be gained by tuning the simplicial complex code.
The current implementation gives up the first time it is unable to continue adding to the matching. An alternative approach would be to use backtracking. However, this would essentially be searching the entire set of matchings, and the number of them increases very rapidly. Starting over each time searches the set of mappings more thoroughly.
See {@link pc.Copyright} for the copyright notice. The copyright is specified using a Java annotation.