Skip to content

commalg · CotangentComplexAmplitude

3 accepted declarations. Python and Rust forms, contracts, evidence, failure boundaries, and checked usages are kept together below.

Worked example

The complete checked program Differentiate exactly and distinguish a cusp's smooth and singular points uses this API directly.

# SPDX-License-Identifier: MIT
# Copyright (c) 2026 Benjamin Antieau and Deven Manam
"""Differentiate exactly and distinguish a cusp's smooth and singular points."""

from noether import Q
from noether.commalg import KahlerDifferentials, PolynomialRing


def main() -> None:
    ring = PolynomialRing(Q, ["x", "y"])
    x, y = ring.generators()
    relation = y**2 - x**3
    cusp = ring.quotient(ring.ideal([relation]))
    omega = cusp.kahler_differentials()

    assert isinstance(omega, KahlerDifferentials)
    dx = omega.differentiate(cusp(x))
    dy = omega.differentiate(cusp(y))
    assert omega.differentiate(cusp(x * y)) == dx * cusp(y) + dy * cusp(x)
    assert omega.differentiate(cusp(relation)).is_zero()

    singular = cusp.cotangent_space_at([0, 0])
    smooth = cusp.cotangent_space_at([1, 1])
    assert singular.embedding_dimension == 2
    assert smooth.embedding_dimension == 1
    assert singular.presentation_matrix == singular.evaluated_jacobian.transpose()

    complex = cusp.cotangent_complex()
    assert complex.codimension == 1
    assert (complex.amplitude.lowest_degree, complex.amplitude.highest_degree) == (-1, 0)
    assert complex.hypothesis.equation_count == 1
    complex.verify()

    print(
        "cusp cotangent dimensions: "
        f"singular={singular.embedding_dimension}, smooth={smooth.embedding_dimension}; "
        "complete-intersection amplitude=[-1,0]"
    )


if __name__ == "__main__":
    main()

Run it with .venv/bin/python examples/39_kahler_differentials.py.

commalg.CotangentComplexAmplitude

Sealed amplitude issued only by a verified cotangent-complex presentation.

class CotangentComplexAmplitude

noether::commalg::CotangentComplexAmplitude · Direct Rust declaration

pub struct CotangentComplexAmplitude { /* private fields */ }
Contract Value
Guarantee checked deterministic result
Determinism deterministic
Availability default CPU build
Domain implementation crates noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL attached / bounded

Executable usage: validation/unit/commalg/test_kahler_differentials.py:15 · validation/unit/commalg/test_kahler_differentials.py:157 · validation/unit/commalg/test_kahler_differentials.py:94

commalg.CotangentComplexAmplitude.highest_degree

Highest nonzero homological degree, always 0 in this lane.

Detailed contract

Highest cohomological degree that may be nonzero.

(self) -> int

noether::commalg::CotangentComplexAmplitude::highest_degree · Direct Rust declaration

pub const fn highest_degree(self) -> i8
Contract Value
Guarantee checked deterministic result
Determinism deterministic
Availability default CPU build
Domain implementation crates noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL attached / bounded

Executable usage: examples/39_kahler_differentials.py:30 · validation/unit/commalg/test_kahler_differentials.py:96

commalg.CotangentComplexAmplitude.lowest_degree

Lowest nonzero homological degree, always -1 in this lane.

Detailed contract

Lowest cohomological degree that may be nonzero.

(self) -> int

noether::commalg::CotangentComplexAmplitude::lowest_degree · Direct Rust declaration

pub const fn lowest_degree(self) -> i8
Contract Value
Guarantee checked deterministic result
Determinism deterministic
Availability default CPU build
Domain implementation crates noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL attached / bounded

Executable usage: examples/39_kahler_differentials.py:30 · validation/unit/commalg/test_kahler_differentials.py:96