Skip to content

commalg · CotangentComplexPresentation

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

Worked example

The complete checked program Compute in an exterior algebra and induce a linear map on two-forms uses this API directly.

# SPDX-License-Identifier: MIT
# Copyright (c) 2026 Benjamin Antieau and Deven Manam
"""Compute in an exterior algebra and induce a linear map on two-forms."""

from noether import Q
from noether.commalg import PolynomialRing
from noether.homalg import FreeModule, ModuleElement, ModuleHomomorphism
from noether.linalg import Matrix, Vector


def main() -> None:
    ring = PolynomialRing(Q, ["t"])
    module = FreeModule(ring, 3, basis_labels=["e0", "e1", "e2"])
    exterior = module.exterior_algebra()
    e0, e1, e2 = [exterior.generator(position) for position in range(3)]

    volume = e0 * e1 * e2
    assert volume == exterior.alternating_product(
        [
            ModuleElement(module, Vector.from_values(ring, [1, 0, 0])),
            ModuleElement(module, Vector.from_values(ring, [0, 1, 0])),
            ModuleElement(module, Vector.from_values(ring, [0, 0, 1])),
        ]
    )
    assert e1 * e0 == -(e0 * e1)
    assert e0 * e0 == exterior.zero()

    e0_dual = ModuleElement(module.dual(), Vector.from_values(ring, [1, 0, 0]))
    assert volume.contract(e0_dual) == e1 * e2

    linear_map = ModuleHomomorphism(
        module,
        module,
        Matrix.from_rows(ring, [[1, 1, 0], [0, 1, 0], [0, 0, 2]]),
    )
    on_two_forms = linear_map.exterior_power(2)
    on_two_forms.verify()
    assert on_two_forms.apply_exterior(e1 * e2) == 2 * (e0 * e2 + e1 * e2)
    print(
        "Λ² has basis",
        exterior.basis(2),
        "and the induced map sends e1∧e2 to",
        on_two_forms.apply_exterior(e1 * e2).terms,
    )


if __name__ == "__main__":
    main()

Run it with .venv/bin/python examples/40_exterior_algebra.py.

commalg.CotangentComplexPresentation

Honest two-term cotangent complex in the proved complete-intersection lane.

class CotangentComplexPresentation

noether::commalg::CotangentComplexPresentation · Direct Rust declaration

pub struct CotangentComplexPresentation<C: Field> { /* 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
Semantic ID noether/commalg/CotangentComplexPresentation@1

Executable usage: validation/unit/commalg/test_kahler_differentials.py:147 · validation/unit/commalg/test_kahler_differentials.py:155 · validation/unit/commalg/test_kahler_differentials.py:17 · validation/unit/commalg/test_kahler_differentials.py:93

commalg.CotangentComplexPresentation.algebra

The complete-intersection algebra represented by this two-term complex.

Detailed contract

Exact affine algebra represented by this complex.

(self) -> QuotientRing[D]

noether::commalg::CotangentComplexPresentation::algebra · Direct Rust declaration

pub fn algebra(&self) -> &QuotientRing<PolynomialRing<C>>
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
Semantic ID noether/commalg/CotangentComplexPresentation@1

Executable usage: examples/40_exterior_algebra.py:3 · examples/distributed/f2_linear_algebra.py:3 · validation/unit/commalg/test_acceptance_workload.py:3 · validation/unit/commalg/test_construction_algebras.py:41 · validation/unit/commalg/test_construction_algebras.py:71 · validation/unit/commalg/test_construction_algebras.py:72

commalg.CotangentComplexPresentation.ambient_differentials

The degree 0 term Omega_{P/k} tensor_P A.

Detailed contract

Free degree-zero term Omega_{C[x]/C} tensor A.

(self) -> PresentedModule[QuotientRing[RationalField]] | PresentedModule[QuotientRing[FiniteField]]

noether::commalg::CotangentComplexPresentation::ambient_differentials · Direct Rust declaration

pub fn ambient_differentials( &self, ) -> &PresentedModule<QuotientRing<PolynomialRing<C>>>
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
Semantic ID noether/commalg/CotangentComplexPresentation@1

commalg.CotangentComplexPresentation.amplitude

Sealed amplitude [-1, 0], issued only by the verified constructor.

Detailed contract

Proved cohomological amplitude [-1, 0].

(self) -> CotangentComplexAmplitude

noether::commalg::CotangentComplexPresentation::amplitude · Direct Rust declaration

pub const fn amplitude(&self) -> CotangentComplexAmplitude
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
Semantic ID noether/commalg/CotangentComplexPresentation@1

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

commalg.CotangentComplexPresentation.codimension

Proven codimension of the quotient in its ambient polynomial algebra.

Detailed contract

Complete-intersection codimension and rank of I/I^2.

(self) -> int

noether::commalg::CotangentComplexPresentation::codimension · Direct Rust declaration

pub fn codimension(&self) -> usize
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
Semantic ID noether/commalg/CotangentComplexPresentation@1

Executable usage: examples/39_kahler_differentials.py:29 · validation/unit/commalg/test_intersection_theory.py:31 · validation/unit/commalg/test_intersection_theory.py:32 · validation/unit/commalg/test_intersection_theory.py:50 · validation/unit/commalg/test_kahler_differentials.py:100 · validation/unit/commalg/test_kahler_differentials.py:121

commalg.CotangentComplexPresentation.conormal_module

The degree -1 term I/I^2.

Detailed contract

Presented degree--1 term I/I^2.

(self) -> PresentedModule[QuotientRing[RationalField]] | PresentedModule[QuotientRing[FiniteField]]

noether::commalg::CotangentComplexPresentation::conormal_module · Direct Rust declaration

pub fn conormal_module( &self, ) -> &PresentedModule<QuotientRing<PolynomialRing<C>>>
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
Semantic ID noether/commalg/CotangentComplexPresentation@1

Executable usage: validation/unit/commalg/test_kahler_differentials.py:119 · validation/unit/commalg/test_kahler_differentials.py:66

commalg.CotangentComplexPresentation.differential

The Jacobian/conormal differential from degree -1 to degree 0.

Detailed contract

Differential from degree -1 to degree 0.

(self) -> PresentedModuleHomomorphism[QuotientRing[RationalField]] | PresentedModuleHomomorphism[QuotientRing[FiniteField]]

noether::commalg::CotangentComplexPresentation::differential · Direct Rust declaration

pub fn differential( &self, ) -> &PresentedModuleHomomorphism<QuotientRing<PolynomialRing<C>>>
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
Semantic ID noether/commalg/CotangentComplexPresentation@1

Executable usage: validation/unit/commalg/test_kahler_differentials.py:142 · validation/unit/commalg/test_kahler_differentials.py:143 · validation/unit/homalg/test_chain_complex.py:27 · validation/unit/homalg/test_chain_complex.py:28 · validation/unit/homalg/test_module_facade.py:425 · validation/unit/homalg/test_module_facade.py:426

commalg.CotangentComplexPresentation.evidence

Replayable conormal sequence and exact Jacobian evidence.

Detailed contract

Chosen regular-sequence equations and exact conormal evidence.

(self) -> ConormalSequenceEvidence[D]

noether::commalg::CotangentComplexPresentation::evidence · Direct Rust declaration

pub fn evidence(&self) -> &ConormalSequenceEvidence<C>
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
Semantic ID noether/commalg/CotangentComplexPresentation@1

Executable usage: examples/32_poset_core_and_morse.py:3 · examples/36_affine_normalization.py:3 · validation/unit/commalg/test_affine_normalization_facade.py:3 · validation/unit/commalg/test_kahler_differentials.py:3 · validation/unit/commalg/test_kahler_differentials.py:62 · validation/unit/commalg/test_kahler_differentials.py:63

commalg.CotangentComplexPresentation.from_json

Deserialize and re-prove the complete-intersection presentation.

Detailed contract

Deserialize and reprove the complete-intersection lane.

(cls, value: str) -> CotangentComplexPresentation[RationalField] | CotangentComplexPresentation[FiniteField]

noether::commalg::CotangentComplexPresentation::from_json · Direct Rust declaration

pub fn from_json(value: &str) -> Result<Self, NoetherError>where C: for<'de> Deserialize<'de>, C::Element: for<'de> Deserialize<'de>,
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 released
Semantic ID noether/commalg/CotangentComplexPresentation@1

Executable usage: validation/unit/category/test_category.py:14 · validation/unit/combin/test_acceptance_workload.py:65 · validation/unit/combin/test_acceptance_workload.py:86 · validation/unit/combin/test_graph_facade.py:106 · validation/unit/combin/test_graph_facade.py:25 · validation/unit/combinatorics/test_kashiwara_crystal.py:32

commalg.CotangentComplexPresentation.hypothesis

Sealed complete-intersection hypothesis and exact dimension calculation.

Detailed contract

Exact complete-intersection hypothesis established by construction.

(self) -> CotangentComplexHypothesis

noether::commalg::CotangentComplexPresentation::hypothesis · Direct Rust declaration

pub const fn hypothesis(&self) -> CotangentComplexHypothesis
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
Semantic ID noether/commalg/CotangentComplexPresentation@1

Executable usage: examples/39_kahler_differentials.py:31 · validation/unit/commalg/test_intersection_theory.py:87 · validation/unit/commalg/test_intersection_theory.py:89 · validation/unit/commalg/test_kahler_differentials.py:10 · validation/unit/commalg/test_kahler_differentials.py:100 · validation/unit/commalg/test_kahler_differentials.py:101

commalg.CotangentComplexPresentation.to_json

Serialize the verified presentation as canonical typed JSON.

Detailed contract

Serialize the exact chosen presentation; deserialization reverifies it.

(self) -> str

noether::commalg::CotangentComplexPresentation::to_json · Direct Rust declaration

pub fn to_json(&self) -> Result<String, NoetherError>where C: Serialize, C::Element: Serialize,
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
Semantic ID noether/commalg/CotangentComplexPresentation@1

Executable usage: validation/unit/category/test_category.py:14 · validation/unit/category/test_category.py:15 · validation/unit/combin/test_acceptance_workload.py:30 · validation/unit/combin/test_acceptance_workload.py:65 · validation/unit/combin/test_acceptance_workload.py:86 · validation/unit/combin/test_graph_facade.py:106

commalg.CotangentComplexPresentation.verify

Replay the conormal evidence and complete-intersection proof.

Detailed contract

Recompute both the conormal evidence and complete-intersection proof.

(self) -> None

noether::commalg::CotangentComplexPresentation::verify · Direct Rust declaration

pub fn verify(&self) -> Result<(), KahlerDifferentialError>
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 released
Semantic ID noether/commalg/CotangentComplexPresentation@1

Executable usage: examples/01_bezout_certificates.py:10 · examples/01_bezout_certificates.py:3 · examples/03_exact_linear_systems.py:13 · examples/03_exact_linear_systems.py:3 · examples/04_smith_normal_form.py:12 · examples/06_shortest_lattice_vectors.py:12