feat(matrix): extend exact determinant to order 64

Author: morluto

src/jacobian/contracts/matrix_operations.py

@@ -19,6 +19,7 @@
 from jacobian.contracts.results import ContractModel
 
 MAX_INPUT_SCALAR_DIGITS = 256
+MAX_DETERMINANT_MATRIX_DIMENSION = 64
 
 
 def _check_integer_digits(
@@ -74,23 +75,44 @@ def require_square(self) -> Self:
         return self
 
 
-class MatrixDeterminantRequest(ContractModel):
-    """One bounded square matrix whose exact determinant is requested."""
+class DeterminantRationalMatrix(ContractModel):
+    """One determinant-owned rational matrix bounded independently to order 64."""
 
-    matrix: RationalMatrix
+    matrix_schema_version: Literal["1"] = "1"
+    domain: Literal["QQ"] = "QQ"
+    entries: tuple[tuple[CanonicalRational, ...], ...] = Field(
+        min_length=1, max_length=MAX_DETERMINANT_MATRIX_DIMENSION
+    )
 
     @model_validator(mode="after")
-    def require_square(self) -> Self:
-        if len(self.matrix.entries) != len(self.matrix.entries[0]):
-            raise ValueError("determinant computation requires a square matrix")
+    def require_rectangular_nonempty_rows(self) -> Self:
+        column_count = len(self.entries[0])
+        if not 1 <= column_count <= MAX_DETERMINANT_MATRIX_DIMENSION:
+            raise ValueError(
+                "determinant matrix rows must contain between 1 and 64 entries"
+            )
+        if any(len(row) != column_count for row in self.entries):
+            raise ValueError("determinant matrix rows must all have the same length")
         require_matrix_scalar_digits(
-            self.matrix.entries,
+            self.entries,
             maximum=MAX_INPUT_SCALAR_DIGITS,
             label="determinant input",
         )
         return self
 
 
+class MatrixDeterminantRequest(ContractModel):
+    """One square rational matrix of order at most 64."""
+
+    matrix: DeterminantRationalMatrix
+
+    @model_validator(mode="after")
+    def require_square(self) -> Self:
+        if len(self.matrix.entries) != len(self.matrix.entries[0]):
+            raise ValueError("determinant computation requires a square matrix")
+        return self
+
+
 class MatrixRankRequest(ContractModel):
     """One bounded rectangular matrix whose exact rank is requested."""
 

src/jacobian/domains/matrix_lattice/capabilities.py

@@ -114,7 +114,7 @@ def implementation(request: RequestT) -> ResultT:
     matrix_operation(
         "matrix.determinant.compute",
         "Compute an exact rational matrix determinant",
-        "Compute the determinant of one square matrix over QQ with SymPy's exact Bareiss algorithm.",
+        "Compute the determinant of one square matrix over QQ through order 64 with SymPy's exact Bareiss algorithm.",
         MatrixDeterminantRequest,
         MatrixDeterminantResult,
         compute_determinant,
@@ -141,7 +141,7 @@ def implementation(request: RequestT) -> ResultT:
                 },
             ),
         ),
-        version="2",
+        version="3",
     ),
     matrix_operation(
         "matrix.rank.compute",

src/jacobian/domains/matrix_lattice/conversions.py

@@ -7,6 +7,7 @@
 from jacobian.canonical import format_canonical_integer, parse_canonical_integer
 from jacobian.contracts.exact import CanonicalRational
 from jacobian.contracts.matrices import IntegerMatrix, RationalMatrix
+from jacobian.contracts.matrix_operations import DeterminantRationalMatrix
 
 __all__ = [
     "integer_matrix_from_sympy",
@@ -30,7 +31,9 @@ def rational_from_sympy(value: Any) -> CanonicalRational:
     )
 
 
-def rational_matrix_to_sympy(matrix: RationalMatrix) -> Any:
+def rational_matrix_to_sympy(
+    matrix: RationalMatrix | DeterminantRationalMatrix,
+) -> Any:
     import sympy
 
     return sympy.Matrix(

src/jacobian/math/matrices/_sympy.py

@@ -8,11 +8,18 @@
 from sympy.matrices.matrixbase import MatrixBase
 
 
-def exact_matrix(value: MatrixBase) -> MatrixBase:
+def exact_matrix(
+    value: MatrixBase, *, maximum_dimension: int = 32
+) -> MatrixBase:
     if not isinstance(value, MatrixBase):
         raise TypeError("matrix must be a SymPy MatrixBase")
-    if not 1 <= value.rows <= 32 or not 1 <= value.cols <= 32:
-        raise ValueError("matrix dimensions must be between 1 and 32")
+    if (
+        not 1 <= value.rows <= maximum_dimension
+        or not 1 <= value.cols <= maximum_dimension
+    ):
+        raise ValueError(
+            f"matrix dimensions must be between 1 and {maximum_dimension}"
+        )
     if any(not entry.is_number or entry.is_finite is not True for entry in value):
         raise ValueError("matrix entries must be finite exact numbers")
     if any(entry.has(sympy.Float) for entry in value):
@@ -53,7 +60,7 @@ def characteristic_polynomial(matrix: MatrixBase, variable: str) -> Any:
 
 
 def determinant(matrix: MatrixBase) -> Any:
-    source = exact_matrix(matrix)
+    source = exact_matrix(matrix, maximum_dimension=64)
     if source.rows != source.cols:
         raise ValueError("determinant requires a square matrix")
     return source.det(method="bareiss")

src/jacobian_checkers/exact_domain_operations.py

@@ -27,6 +27,7 @@
 _MAX_RESIDUE_ASSIGNMENTS = 4_096
 _MAX_RESIDUE_MODULUS = 1_000_000
 _MAX_MATRIX_DIMENSION = 32
+_MAX_DETERMINANT_MATRIX_DIMENSION = 64
 _MAX_MATRIX_INPUT_DIGITS = 256
 _MAX_MATRIX_OUTPUT_DIGITS = 32_768
 
@@ -100,6 +101,18 @@ def _q(value: object) -> fmpq:
     return fmpq(numerator, denominator)
 
 
+def _bounded_q(value: object, *, maximum_digits: int) -> fmpq:
+    if not isinstance(value, dict) or set(value) != {"num", "den"}:
+        raise ValueError("bounded rational is malformed")
+    for component in (value["num"], value["den"]):
+        if (
+            not isinstance(component, str)
+            or len(component.lstrip("-")) > maximum_digits
+        ):
+            raise ValueError("bounded rational exceeds the checker digit limit")
+    return _q(value)
+
+
 def _polynomial(value: object) -> fmpq_poly:
     if (
         not isinstance(value, dict)
@@ -213,15 +226,20 @@ def _integer_matrix(value: object) -> fmpz_mat:
     return fmpz_mat([[_integer(item) for item in row] for row in entries])
 
 
-def _bounded_rational_matrix(value: object, *, maximum_digits: int) -> fmpq_mat:
+def _bounded_rational_matrix(
+    value: object,
+    *,
+    maximum_digits: int,
+    maximum_dimension: int = _MAX_MATRIX_DIMENSION,
+) -> fmpq_mat:
     if not isinstance(value, dict):
         raise ValueError("rational matrix is malformed")
     entries = value.get("entries")
     if (
         not isinstance(entries, list)
-        or not 1 <= len(entries) <= _MAX_MATRIX_DIMENSION
+        or not 1 <= len(entries) <= maximum_dimension
         or not isinstance(entries[0], list)
-        or not 1 <= len(entries[0]) <= _MAX_MATRIX_DIMENSION
+        or not 1 <= len(entries[0]) <= maximum_dimension
     ):
         raise ValueError("rational matrix exceeds the checker dimension bound")
     for row in entries:
@@ -1008,10 +1026,19 @@ def _matrix_determinant(source: dict[str, Any], result: dict[str, Any]) -> bool:
         "FRACTION_FREE_BAREISS"
     ):
         return False
-    matrix = _matrix_source(source)
+    if set(source) != {"matrix"}:
+        return False
+    matrix = _bounded_rational_matrix(
+        source["matrix"],
+        maximum_digits=_MAX_MATRIX_INPUT_DIGITS,
+        maximum_dimension=_MAX_DETERMINANT_MATRIX_DIMENSION,
+    )
     if matrix.nrows() != matrix.ncols():
         return False
-    return bool(_q(result["determinant"]) == matrix.det())
+    declared = _bounded_q(
+        result["determinant"], maximum_digits=_MAX_MATRIX_OUTPUT_DIGITS
+    )
+    return bool(declared == matrix.det())
 
 
 def check_matrix_determinant(request: dict[str, Any]) -> dict[str, Any]:

tests/domain/matrix/test_determinant_order_64.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from pathlib import Path
+
+import pytest
+from tests.support.exact_domain import open_exact_domain_services
+from tests.support.services import DomainTestServices
+
+from jacobian.contracts.capabilities import CapabilityRequest
+from jacobian.contracts.results import ExecutionStatus
+from jacobian.domains.matrix_lattice import build_matrix_bundle
+
+
+def _q(value: int) -> dict[str, str]:
+    return {"num": str(value), "den": "1"}
+
+
+def _matrix(entries: list[list[int]]) -> dict[str, object]:
+    return {"entries": [[_q(value) for value in row] for row in entries]}
+
+
+def _truncated_legendre_matrix(prime: int) -> dict[str, object]:
+    order = (prime - 5) // 2
+
+    def entry(row: int, column: int) -> int:
+        residue = (row - column) % prime
+        if residue == 0:
+            character = 0
+        else:
+            character = (
+                1 if pow(residue, (prime - 1) // 2, prime) == 1 else -1
+            )
+        return 1 + character
+
+    return _matrix(
+        [[entry(row, column) for column in range(order)] for row in range(order)]
+    )
+
+
+@pytest.fixture
+def matrix_services(tmp_path: Path) -> Iterator[DomainTestServices]:
+    with open_exact_domain_services(
+        tmp_path / "state", build_matrix_bundle()
+    ) as services:
+        yield services
+
+
+def test_order_33_determinant_computes_and_verifies(
+    matrix_services: DomainTestServices,
+) -> None:
+    payload = {"matrix": _truncated_legendre_matrix(71)}
+    computed = matrix_services.core.capabilities.invoke(
+        CapabilityRequest(capability_id="matrix.determinant.compute", input=payload)
+    )
+    verified = matrix_services.core.capabilities.invoke(
+        CapabilityRequest(
+            capability_id="matrix.determinant.verify",
+            input={"input": payload, "candidate": computed.output["result"]},
+        )
+    )
+    assert computed.execution.status is ExecutionStatus.COMPLETED
+    assert computed.output["result"]["determinant"] == _q(529)
+    assert verified.execution.status is ExecutionStatus.COMPLETED
+    assert verified.output["status"] == "VERIFIED"
+    assert verified.verification_record_uri is not None
+
+
+def test_determinant_rejects_order_above_64(
+    matrix_services: DomainTestServices,
+) -> None:
+    matrix = _matrix(
+        [
+            [1 if row == column else 0 for column in range(65)]
+            for row in range(65)
+        ]
+    )
+    result = matrix_services.core.capabilities.invoke(
+        CapabilityRequest(
+            capability_id="matrix.determinant.compute",
+            input={"matrix": matrix},
+        )
+    )
+    assert result.execution.status is ExecutionStatus.ERROR
+    assert result.artifact_uris == ()

tests/unit/contracts/test_determinant_contract.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from jacobian.contracts.matrix_operations import MatrixDeterminantRequest
+from jacobian.schema_registry import model_schema
+
+
+def test_determinant_schema_publishes_64_by_64_input_bound() -> None:
+    schema = model_schema(MatrixDeterminantRequest)
+    matrix = schema["$defs"]["DeterminantRationalMatrix"]
+    assert matrix["properties"]["entries"]["maxItems"] == 64
+    row = matrix["properties"]["entries"]["items"]
+    assert row["maxItems"] == 64