A brief history of cohomCalg

The software is the result of a very rewarding research collaboration with my Munich colleagues Ralph Blumenhagen, Thorsten Rahn and Helmut Roschy. Following some of my earlier F-theory work1 we developed a new algorithm2 for the purpose of computing the dimensions of line bundle-valued sheaf cohomology groups on toric varieties. One of my parts was to developed a high-performance C++ implementation of the core algorithm, which resulted in the cohomCalg software. The optional cohomCalg Koszul extension, written by Thorsten, serves as a Mathematica 7 frontend and allows for the easy computation of hypersurface and complete intersection cohomologies.3

License: The entire package is published under the GNU GPL v3 License, as required by the included PolyLib component. This means that any derivative work also has to be published under the GPL v3 License or an equivalent license.

Development motivation

Given the generators of a Stanley-Reisner ideal and the gauged linear sigma-model (GLSM) charges / degrees of the homogeneous coordinates for a toric variety, the program computes the dimensions of the sheaf cohomology groups for the twisted holomorphic line bundle / structure sheaf O(D) on the variety. Those dimensions are required frequently for the computation of numerous physically relevant quantities.

The initial idea of counting monomials with integer exponents occurred to Ralph in the late 1990s during his own PhD time.

However, a closer inspection by us PhD students revealed the need for a refined definition of the multiplicity factors that are weighting the numbers of the rationoms. This lead to the algorithm conjecture in its final form 2 and the subsequent proof. The ease of usage for the computation of line bundle cohomology group dimensions provides a very efficient tool for string model building. Furthermore, the algorithm can easily be generalized to the computation of coset spaces (i.e. equivariant cohomology groups on the original space).

In comparison to our earlier algorithm implementation as a Mathematica 7 script, the C++ implementation cohomCalg provides a huge speedup by five to six orders of magnitude according to our measurements. For the actual geometries of interest to us, this effectivily means quasi-instantaneous computation time for all relevant examples.

Usage example

cohomCalg’s usage is extremely straightforward and intuitive: data input and output is provided via a text files in a rather human-readable format. For example, the input file for a geometry could be something like the following:

vertex u1 | GLSM:  ( 1,  0,  0,  1,  0,  0 );
vertex u2 | GLSM:  ( 1,  0,  1,  0,  1,  0 );
vertex u3 | GLSM:  ( 1,  1,  0,  0,  0,  0 );
vertex u4 | GLSM:  ( 0,  1,  0,  0,  1,  0 );
vertex u5 | GLSM:  ( 0,  0,  1,  0,  0,  0 );
vertex u6 | GLSM:  ( 0,  0,  0,  1,  0,  0 );
vertex u7 | GLSM:  ( 0,  0,  0,  0,  1,  1 );
vertex u8 | GLSM:  ( 0,  0,  0,  0,  0,  1 );

srideal [u1*u2,  u1*u3,  u1*u6,  u1*u7,  u1*u8,  u2*u3,  u2*u4,  u2*u5,  u2*u7,  u3*u4,  u3*u5,  u3*u8,  u4*u5,  u4*u6,  u4*u7,  u5*u6,  u5*u8,  u6*u7,  u6*u8,  u7*u8];

ambientcohom O( -2, -2, -2,  0, -2,  0 ); 
ambientcohom O( -1,  0,  0, -3, -1, -2 );
ambientcohom O(  2,  0,  1,  1,  1,  0 );

The output to the stdout pipe then is the following:

Cohomology dimensions:
======================
    dim H^i(A; O(  -2,  -2,  -2,   0,  -2,   0 )) = (   0,   3,   0 )
    dim H^i(A; O(  -1,   0,   0,  -3,  -1,  -2 )) = (   0,   5,   0 )
    dim H^i(A; O(   2,   0,   1,   1,   1,   0 )) = (   1,   1,   0 )

Application run took 0.20 seconds, more precisely
    0.12 seconds for the computation of the secondary cohomology
    0.08 seconds for the counting of rational functions

There are alternative output modes in a more structured form available. This allows for an easy integration into our day-to-day workflow. In case you are interested in some of the details of the implementation, take a look at the corresponding section in the manual contained in the package.

Referencing cohomCalg

If you are able to use the software for your research project, we would very much appreciate some attribution for our work. You can use the following two BibTeX entries:

@Article{Blumenhagen:2010pv,
   author    = "Blumenhagen, Ralph and Jurke, Benjamin 
                and Rahn, Thorsten and Roschy, Helmut",
   title     = "{Cohomology of Line Bundles: A Computational Algorithm}",
   journal   = "J. Math. Phys.",
   volume    = "51",
   pages     = "103525",
   issue     = "10",
   year      = "2010",
   doi       = "10.1063/1.3501132",
   eprint    = "1003.5217",
   archivePrefix = "arXiv",
   primaryClass  = "hep-th"}

@Misc{cohomCalg:Implementation,
   title     = "{cohomCalg package}",
   howpublished  = "Download link",
   url       = "https://github.com/BenjaminJurke/cohomCalg",
   note      = "High-performance line bundle cohomology computation based on \cite{Blumenhagen:2010pv}",
   year      = "2010"}

Known bugs & limitations

Certain invalid input data is not safely handled by the PolyLib component that efficiently counts relevant rationoms in the algorithm. In such cases (which caused crashes in the original version) you will see a message like:

Counting of the rationoms errorneous - is your input geometry valid?

So far, all those situations could be traced back to bad input data, i.e. invalid geometries. Further implementation-related and conceptual limitations are explained in the manual.

  1. The three F-theory publications are “F-theory uplifts and GUTs“, “Global F-theory GUTs” and “On Instanton Effects in F-theory“. ↩

  2. The first conjecture of the algorithm ist found in “Cohomology of Line Bundles: A Computational Algorithm“, though our later review “Computational Tools for Cohomology of Toric Varieties” is somewhat more readable and provides a cleaner presentation of the material. ↩ ↩2

  3. Details are presented in “Cohomology of Line Bundles: Applications“. ↩