Skip to main content

MultiDegree

Using MultiDegree, you can efficiently compute cohomology of some Sullivan algebras.

Mathematical explanation​

Usually, Sullivan algebras are Z\Z-graded. But, in some case, the grading can be extended to a larger group.

For example, the Sullivan model (∧(x,y),d)(\wedge(x,y), d) of the even dimensional sphere S2nS^{2n} can be (Z⊕Z)(\Z\oplus\Z)-graded since it has nn as a "parameter". More precisely, the degrees ∣x∣=2n|x|=2n and ∣y∣=4n−1|y|=4n-1 can be considered as elements of Z⊕Z=Z{1,n}\Z\oplus\Z=\Z\{1,n\} (i.e. {1,n}\{1, n\} is the basis of Z⊕Z\Z\oplus\Z).

kohomology supports computation of cohomology with (Z⊕Z)(\Z\oplus\Z)-grading (or (Z⊕⋯⊕Z)(\Z\oplus\cdots\oplus\Z)-grading), which is faster than the usual one.

Usage​

First you need to define degreeGroup.

MultiDegree.kt
val sphereDim = 2
val degreeGroup = MultiDegreeGroup(
    listOf(
        DegreeIndeterminate("n", sphereDim / 2),
        DegreeIndeterminate("m", sphereDim / 2),
    )
)
val (n, m) = degreeGroup.generatorList

Then you can define a Sullivan algebra using the above degreeGroup.

MultiDegree.kt
val indeterminateList = degreeGroup.context.run {
    listOf(
        Indeterminate("x", 2 * n),
        Indeterminate("y", 4 * n - 1),
        Indeterminate("a", 2 * m),
        Indeterminate("b", 4 * m - 1),
    )
}
val matrixSpace = SparseMatrixSpaceOverRational
val sphere = FreeDGAlgebra.fromMap(matrixSpace, degreeGroup, indeterminateList) { (x, y, a, b) ->
    mapOf(
        y to x.pow(2),
        b to a.pow(2),
    )
}

Its cohomology can be computed as follows:

MultiDegree.kt
degreeGroup.context.run {
    println(sphere.cohomology.getBasis(0))
    println(sphere.cohomology.getBasis(2 * n))
    println(sphere.cohomology.getBasis(2 * m))
    println(sphere.cohomology.getBasisForAugmentedDegree(sphereDim))
}

Performance​

If applicable, computations with MultiDegree are much faster than those with IntDegree (usual Z\Z-grading). This page contains benchmark for the case of the free loop space of S2S^2.