polynomial: bound canonical input accumulation

Author: kaoru0822-kitauji

docs/reference/evaluations/canonical-input-recovery-pr1.md

@@ -108,12 +108,15 @@ canonicalization-plus-recovery condition.
 ## Engineering closeout
 
 The accepted canonicalization mechanism was rebased without an experimental
-rerun onto upstream `519dd7b9e34b641dcc138e03af6ffc6e3ed736af`. Review hardening
-now validates a canonical-support representative of the complete typed request
-before duplicate-coefficient accumulation, caps each coefficient involved in an
-accumulation at 256 digits, and validates the exact combined request again. This
-preserves canonical candidate and artifact identity while failing closed before
-expensive arithmetic for invalid cross-field requests.
+rerun onto upstream `71fa917c289c6214733d369b3dce35904ff47c18`. Review hardening
+now validates an inverse-verification structural representative of the complete
+typed request before duplicate-coefficient accumulation, caps each coefficient
+involved in an accumulation at 256 digits, caps each duplicate group at 64
+terms, and validates the exact combined request again. The dedicated preflight
+checks ordered-ring alignment without applying composition budgets to supports
+that exact cancellation may remove. This preserves canonical candidate and
+artifact identity, accepts representations whose out-of-budget terms cancel,
+and fails closed before unbounded duplicate arithmetic or artifact writes.
 
 The final-tree focused lane passed 48 contract, inverse-composition, and identity
 boundary tests in tmux session `jac-pr920-review-hardening-r3`. `make check`
@@ -125,3 +128,17 @@ restack, the same 48-test lane passed again in `jac-pr920-latest-final`, and
 `make check` passed 884 unit tests plus lint, format, and type checking in
 `jac-pr920-latest-check`. The final checker-seam restack passed the 48 focused
 tests and `make check` with 854 unit tests in `jac-pr920-main519-final`.
+After rebasing onto `71fa917c`, the two final review findings were reproduced and
+covered by the focused lane: cancelled degree-33 terms no longer trigger the
+degree-32 operation budget, and a 65-term duplicate group is rejected before
+coefficient accumulation. The final focused lane contains 56 tests, including
+the interval-verification seam exposed by the broad gate; no model rollout was
+rerun.
+
+The final `make test-changed BASE=origin/main` run passed unit, domain,
+composition, storage, process, MCP, end-to-end, static, build, and documentation
+lanes. Its component lane had one unrelated macOS timeout-marker failure in
+`test_carcara_timeout_fails_closed`; the branch does not change that checker or
+test, and the same environment race also reproduced in the isolated DRAT timeout
+test. This is retained as an upstream/environment obligation rather than folded
+into the canonicalization change.

src/jacobian/polynomials/_support.py

@@ -36,6 +36,7 @@
     PolynomialMapEvaluation,
     PolynomialMapInverseSynthesisRequest,
     PolynomialMapInverseVerifyRequest,
+    PolynomialVariable,
     RationalPolynomialMap,
     RationalPolynomialPoint,
     RationalPolynomialTerm,
@@ -57,6 +58,7 @@
 
 _INVERSE_SOLVER_SHUTDOWN_TIMEOUT_SECONDS = 1.0
 _MAX_CANONICALIZATION_COEFFICIENT_DIGITS = 256
+_MAX_CANONICALIZATION_DUPLICATE_TERMS = 64
 
 
 class _SparsePolynomialInputTerm(ContractModel):
@@ -89,12 +91,40 @@ class _SparsePolynomialInput(ContractModel):
     )
 
 
+class _PolynomialMapInverseVerifyInput(ContractModel):
+    """Inverse-check request shape without composition operation budgets."""
+
+    forward_map: RationalPolynomialMap
+    inverse_map: RationalPolynomialMap
+    source_variables: tuple[PolynomialVariable, ...] = Field(min_length=1, max_length=4)
+    target_variables: tuple[PolynomialVariable, ...] = Field(min_length=1, max_length=4)
+
+    @model_validator(mode="after")
+    def require_compatible_ordered_rings(self) -> Self:
+        if self.forward_map.variables != self.source_variables:
+            raise ValueError("forward map variables must equal source_variables")
+        if self.inverse_map.variables != self.target_variables:
+            raise ValueError("inverse map variables must equal target_variables")
+        if len(self.source_variables) != len(self.target_variables):
+            raise ValueError("source and target dimensions must agree")
+        if len(self.forward_map.coordinates) != len(self.target_variables):
+            raise ValueError("forward map coordinate count must match target_variables")
+        if len(self.inverse_map.coordinates) != len(self.source_variables):
+            raise ValueError("inverse map coordinate count must match source_variables")
+        return self
+
+
 def _require_bounded_duplicate_accumulation(
     parsed: _SparsePolynomialInput,
 ) -> None:
     counts: dict[tuple[int, ...], int] = {}
     for term in parsed.terms:
         counts[term.exponents] = counts.get(term.exponents, 0) + 1
+    if any(count > _MAX_CANONICALIZATION_DUPLICATE_TERMS for count in counts.values()):
+        raise ValueError(
+            "duplicate-term canonicalization exceeds the "
+            f"{_MAX_CANONICALIZATION_DUPLICATE_TERMS}-term accumulation budget"
+        )
     for term in parsed.terms:
         if counts[term.exponents] > 1:
             require_bounded_rational(
@@ -107,7 +137,7 @@ def _require_bounded_duplicate_accumulation(
 def _structural_sparse_polynomial(
     value: object,
 ) -> SparseRationalPolynomial:
-    """Build a cheap canonical support representative without coefficient sums."""
+    """Build a cheap shape representative without applying operation budgets."""
 
     parsed = _SparsePolynomialInput.model_validate(value)
     _require_bounded_duplicate_accumulation(parsed)
@@ -601,11 +631,12 @@ def _validate_request[RequestModel: ContractModel](
     error_factory: Callable[[str, str, str], CapabilityInvocationError] | None = None,
 ) -> RequestModel:
     try:
-        structural_payload = _normalize_sparse_polynomial_inputs(
-            payload,
-            normalize=_structural_sparse_polynomial,
-        )
-        model.model_validate(structural_payload)
+        if model is PolynomialMapInverseVerifyRequest:
+            structural_payload = _normalize_sparse_polynomial_inputs(
+                payload,
+                normalize=_structural_sparse_polynomial,
+            )
+            _PolynomialMapInverseVerifyInput.model_validate(structural_payload)
         canonical_payload = _normalize_sparse_polynomial_inputs(
             payload,
             normalize=_canonical_sparse_polynomial,

tests/composition/runtime/test_polynomial_map_inverse_verify.py

@@ -228,6 +228,65 @@ def test_duplicate_accumulation_rejects_oversized_coefficients(
     assert result.artifact_uris == ()
 
 
+def test_duplicate_accumulation_rejects_oversized_groups(
+    authorized_complete_runtime,
+) -> None:
+    forward, inverse = _triangular_maps()
+    forward["coordinates"][0]["terms"] = [
+        _term(1, [1, 0])
+        for _ in range(polynomial_support._MAX_CANONICALIZATION_DUPLICATE_TERMS + 1)
+    ]
+
+    result = authorized_complete_runtime.core.capabilities.invoke(
+        _request(forward, inverse)
+    )
+
+    assert result.execution.status is ExecutionStatus.ERROR
+    assert result.output["error"]["code"] == "INVALID_POLYNOMIAL_MAP_INVERSE_REQUEST"
+    assert result.artifact_uris == ()
+
+
+def test_cancelled_high_degree_terms_do_not_apply_operation_budget(
+    authorized_complete_runtime,
+) -> None:
+    forward = {
+        "map_schema_version": "1",
+        "domain": "QQ",
+        "variables": ["x"],
+        "coordinates": [
+            {
+                "terms": [
+                    _term(1, [33]),
+                    _term(-1, [33]),
+                    _term(1, [1]),
+                ]
+            }
+        ],
+    }
+    inverse = {
+        "map_schema_version": "1",
+        "domain": "QQ",
+        "variables": ["u"],
+        "coordinates": [{"terms": [_term(1, [1])]}],
+    }
+
+    result = authorized_complete_runtime.core.capabilities.invoke(
+        CapabilityRequest(
+            capability_id="polynomial.map.inverse.verify",
+            mode=CapabilityMode.VERIFY,
+            input={
+                "forward_map": forward,
+                "inverse_map": inverse,
+                "source_variables": ["x"],
+                "target_variables": ["u"],
+            },
+        )
+    )
+
+    assert result.output["inverse_verified"] is True
+    assert result.assurance.level is CapabilityAssuranceLevel.VERIFIED
+
+
 def test_overlapping_variable_names_use_simultaneous_composition(
     authorized_complete_runtime,
 ) -> None: