scientific-computing-system 2.2.6__tar.gz → 2.2.8__tar.gz

{scientific_computing_system-2.2.6 → scientific_computing_system-2.2.8}/CHANGELOG.md

@@ -5,6 +5,26 @@ All notable changes to **scientific-computing-system** will be documented in thi
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [v2.2.8] - 2026-10-17
+
+### Scientific validation fail-closed thresholds
+
+- Reject NaN and infinite tolerances for independent-method agreement and conservation.
+- Reject non-finite OOD margins, distribution-drift thresholds, and residual diagnostic limits.
+- Add regression coverage for these parameter-contract failures and align the public
+  version tuple with the synchronized release metadata.
+
+## [v2.2.7] - 2026-10-15
+
+### Housekeeping — version lockstep
+
+- Release 2.2.7 (2026-10-15): records the production/Stable line against
+  which the repository's locked surfaces (codemeta.json, pyproject.toml,
+  package.json, `cds --version`) are verified by
+  `tests/test_codemeta_version_lockstep.py`.
+- Bumps the npm shim to the same 2.2.7 line so both publish channels ship
+  at identical versions, as documented in the README "Install" section.
+
 ## [v2.2.6] - 2026-10-13
 
 ### Housekeeping — second-round neighbour sweep

{scientific_computing_system-2.2.6 → scientific_computing_system-2.2.8}/CITATION.cff

@@ -5,7 +5,7 @@ title: "scientific-computing-system"
 # Keep `version` in lockstep with pyproject.toml [project].version and
 # src/cds/_version.py. scripts/check_version_discipline.py and
 # scripts/check_version_lockstep.py enforce this.
-version: 2.2.6
+version: 2.2.8
 authors:
   - name: "Furox-Art"
     email: "furkanarkn1451@gmail.com"
@@ -50,5 +50,5 @@ preferred-citation:
   authors:
     - name: "Furox-Art"
   year: 2026
-  version: 2.2.6
+  version: 2.2.8
   url: "https://github.com/Furox-Art/scientific-computing-system"

{scientific_computing_system-2.2.6 → scientific_computing_system-2.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: scientific-computing-system
-Version: 2.2.6
+Version: 2.2.8
 Summary: A pure-Python computational science platform for numerical methods, modeling, validation, uncertainty, scientific workflows, dimensional analysis, and optional research-data backends. Zero runtime dependencies.
 Project-URL: Homepage, https://github.com/Furox-Art/scientific-computing-system
 Project-URL: Repository, https://github.com/Furox-Art/scientific-computing-system

{scientific_computing_system-2.2.6 → scientific_computing_system-2.2.8}/codemeta.json

@@ -2,7 +2,7 @@
   "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
   "@type": "SoftwareSourceCode",
   "name": "scientific-computing-system",
-  "version": "2.2.6",
+  "version": "2.2.8",
   "description": "Pure-Python computational science platform for numerical methods, modeling, validation, uncertainty, and scientific workflows. Zero runtime dependencies. This is the front door; scientific-computing-system-2.0 is the NumPy build of the same work.",
   "license": "https://spdx.org/licenses/MIT",
   "codeRepository": "https://github.com/Furox-Art/scientific-computing-system",

{scientific_computing_system-2.2.6 → scientific_computing_system-2.2.8}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scientific-computing-system",
-  "version": "2.2.6",
+  "version": "2.2.8",
   "description": "Scientific Computing System launcher - a thin Node wrapper that forwards to the pure-Python `cds` CLI. This npm package ships NO Python code: it requires the Python distribution to be installed (`pip install scientific-computing-system`), otherwise `scs` exits non-zero with an actionable message.",
   "main": "index.js",
   "bin": {

{scientific_computing_system-2.2.6 → scientific_computing_system-2.2.8}/pyproject.toml

@@ -2,7 +2,7 @@
 # Distribution name. Formerly published as "cognitive-discovery-system";
 # the import name stays `cds`. Keep the old PyPI project alive as an alias.
 name = "scientific-computing-system"
-version = "2.2.6"
+version = "2.2.8"
 description = "A pure-Python computational science platform for numerical methods, modeling, validation, uncertainty, scientific workflows, dimensional analysis, and optional research-data backends. Zero runtime dependencies."
 readme = "README.md"
 license = "MIT"

{scientific_computing_system-2.2.6 → scientific_computing_system-2.2.8}/src/cds/_version.py

@@ -5,5 +5,5 @@ from __future__ import annotations
 
 __all__ = ["__version__", "version", "__version_tuple__", "version_tuple"]
 
-__version__ = version = "2.2.6"
-__version_tuple__ = version_tuple = (2, 2, 0)
+__version__ = version = "2.2.8"
+__version_tuple__ = version_tuple = (2, 2, 8)

{scientific_computing_system-2.2.6 → scientific_computing_system-2.2.8}/src/cds/validation/checks.py

@@ -36,8 +36,8 @@ def cross_method_agreement(
     name: str = "cross-method-agreement",
 ) -> ValidationCheck:
     """Compare two independently obtained scalar results."""
-    if rtol < 0 or atol < 0:
-        raise ValueError("rtol and atol must be non-negative")
+    if not all(math.isfinite(value) and value >= 0 for value in (rtol, atol)):
+        raise ValueError("rtol and atol must be finite and non-negative")
     if not (math.isfinite(primary) and math.isfinite(secondary)):
         return ValidationCheck(
             name=name,
@@ -78,7 +78,14 @@ def check_bounds(
     violations = [
         index
         for index, (value, (lower, upper)) in enumerate(zip(values, bounds))
-        if value < lower or value > upper
+        if (
+            not math.isfinite(value)
+            or not math.isfinite(lower)
+            or not math.isfinite(upper)
+            or lower > upper
+            or value < lower
+            or value > upper
+        )
     ]
     if violations:
         return ValidationCheck(
@@ -130,8 +137,8 @@ def check_conservation(
     name: str = "conservation",
 ) -> ValidationCheck:
     """Check a scalar conservation law such as mass, charge, or energy."""
-    if rtol < 0 or atol < 0:
-        raise ValueError("rtol and atol must be non-negative")
+    if not all(math.isfinite(value) and value >= 0 for value in (rtol, atol)):
+        raise ValueError("rtol and atol must be finite and non-negative")
     if not (math.isfinite(before) and math.isfinite(after)):
         return ValidationCheck(
             name=name,
@@ -258,8 +265,8 @@ def check_ood_ranges(
     """
     if not 0.0 <= allowed_fraction <= 1.0:
         raise ValueError("allowed_fraction must lie in [0, 1]")
-    if margin_fraction < 0.0:
-        raise ValueError("margin_fraction must be non-negative")
+    if not math.isfinite(margin_fraction) or margin_fraction < 0.0:
+        raise ValueError("margin_fraction must be finite and non-negative")
     if not training_rows:
         raise ValueError("training_rows must not be empty")
     width = len(training_rows[0])
@@ -319,10 +326,10 @@ def check_distribution_drift(
     name: str = "distribution-drift",
 ) -> ValidationCheck:
     """Detect large first/second-moment shifts between scalar distributions."""
-    if max_standardized_mean_shift < 0:
-        raise ValueError("max_standardized_mean_shift must be non-negative")
-    if max_variance_ratio < 1.0:
-        raise ValueError("max_variance_ratio must be >= 1")
+    if not math.isfinite(max_standardized_mean_shift) or max_standardized_mean_shift < 0:
+        raise ValueError("max_standardized_mean_shift must be finite and non-negative")
+    if not math.isfinite(max_variance_ratio) or max_variance_ratio < 1.0:
+        raise ValueError("max_variance_ratio must be finite and >= 1")
     if len(reference) < 2 or len(current) < 2:
         raise ValueError("drift check requires at least two values per sample")
     finite = check_finite([*reference, *current], name=name)
@@ -367,7 +374,10 @@ def check_residual_diagnostics(
     name: str = "residual-diagnostics",
 ) -> ValidationCheck:
     """Screen residual bias, lag-1 dependence, and scale instability."""
-    if max_bias_z < 0 or max_abs_lag1 < 0 or max_variance_ratio < 1:
+    thresholds = (max_bias_z, max_abs_lag1, max_variance_ratio)
+    if not all(math.isfinite(value) for value in thresholds) or (
+        max_bias_z < 0 or max_abs_lag1 < 0 or max_variance_ratio < 1
+    ):
         raise ValueError("residual diagnostic thresholds are invalid")
     if len(residuals) < 4:
         return ValidationCheck(

scientific_computing_system-2.2.8/tests/test_property_invariants.py

@@ -0,0 +1,140 @@
+"""Deterministic invariant tests for the public numeric surface.
+
+Numerical code is "deterministic" only if its invariants hold on every input
+you care about, not just on the examples in the docs. These tests sweep small
+integer/rational inputs so the identities below hold exactly (or within the
+module's own documented tolerance), so a regression shows up as a failed
+identity instead of a silently wrong number:
+
+- mat_mul is associative and distributes over addition
+- transpose(transpose(M)) == M
+- det(AB) == det(A) * det(B)
+- solve_linear(A, b) reproduces b (residual bound)
+- PMFs sum to 1 over their support
+- ODE/quadrature error decreases as the step count grows
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+
+from cds.math_utils.linalg import determinant, identity, mat_mul, solve_linear, transpose
+from cds.probability.distributions import binomial_pmf, geometric_pmf, poisson_pmf
+
+#: Exact-arithmetic inputs keep every identity above exact for integers.
+MATRICES = [
+    [[1]],
+    [[1, 2], [3, 4]],
+    [[2, 0, 1], [1, 3, 0], [0, 1, 2]],
+    [[-1, 2], [2, -1]],
+    [[3, 1, 4], [1, 5, 9], [2, 6, 5]],
+]
+
+
+def _matmul_chain(*matrices: Any) -> Any:
+    result = matrices[0]
+    for m in matrices[1:]:
+        result = mat_mul(result, m)
+    return result
+
+
+#: Mutually conformable operands for the binary laws (3x3 with 3x3, 2x2 with
+#: 2x2) — a 2x2 times a 3x3 is not a legal product and is not what the
+#: associativity law is about.
+THREES = [
+    [[2, 0, 1], [1, 3, 0], [0, 1, 2]],
+    [[3, 1, 4], [1, 5, 9], [2, 6, 5]],
+    [[-1, 2, 0], [2, -1, 1], [0, 1, 3]],
+]
+TWOS = [
+    [[1, 2], [3, 4]],
+    [[-1, 2], [2, -1]],
+]
+
+
+@pytest.mark.parametrize(
+    "triple", [(a, b, c) for a in THREES for b in THREES[:2] for c in THREES[:2]]
+)
+def test_mat_mul_is_associative(triple: Any) -> None:
+    a, b, c = triple
+    assert _matmul_chain(a, b, c) == _matmul_chain(a, _matmul_chain(b, c))
+
+
+@pytest.mark.parametrize("triple", [(a, b, c) for a in TWOS for b in TWOS for c in TWOS])
+def test_mat_mul_is_associative_2x2(triple: Any) -> None:
+    a, b, c = triple
+    assert _matmul_chain(a, b, c) == _matmul_chain(a, _matmul_chain(b, c))
+
+
+@pytest.mark.parametrize("matrix", MATRICES)
+def test_transpose_twice_is_identity_on_values(matrix: Any) -> None:
+    assert transpose(transpose(matrix)) == matrix
+
+
+@pytest.mark.parametrize("a", THREES)
+@pytest.mark.parametrize("b", THREES[:2])
+def test_determinant_of_product_equals_product_of_determinants(a: Any, b: Any) -> None:
+    assert determinant(mat_mul(a, b)) == pytest.approx(determinant(a) * determinant(b))
+
+
+@pytest.mark.parametrize("a", TWOS)
+@pytest.mark.parametrize("b", TWOS)
+def test_determinant_of_product_equals_product_of_determinants_2x2(a: Any, b: Any) -> None:
+    assert determinant(mat_mul(a, b)) == pytest.approx(determinant(a) * determinant(b))
+
+
+@pytest.mark.parametrize("matrix", MATRICES[1:4])
+def test_solve_linear_reproduces_the_rhs(matrix: Any) -> None:
+    n = len(matrix)
+    rhs = [float(i + 1) for i in range(n)]
+    x = solve_linear(matrix, rhs)
+    product = mat_mul(matrix, [[v] for v in x])
+    assert [row[0] for row in product] == pytest.approx(rhs, abs=1e-9)
+
+
+@pytest.mark.parametrize("rate", [0.1, 0.5, 1.0, 5.0])
+def test_poisson_pmf_sums_to_one(rate: float) -> None:
+    total = sum(poisson_pmf(k, rate) for k in range(200))
+    assert total == pytest.approx(1.0, abs=1e-6)
+
+
+@pytest.mark.parametrize("n", [1, 2, 5, 10])
+@pytest.mark.parametrize("p", [0.2, 0.5, 0.9])
+def test_binomial_pmf_sums_to_one(n: int, p: float) -> None:
+    total = sum(binomial_pmf(k, n, p) for k in range(n + 1))
+    assert total == pytest.approx(1.0, abs=1e-9)
+
+
+@pytest.mark.parametrize("p", [0.1, 0.5, 0.9])
+def test_geometric_pmf_sums_to_one(p: float) -> None:
+    total = sum(geometric_pmf(k, p) for k in range(1, 500))
+    assert total == pytest.approx(1.0, abs=1e-6)
+
+
+def _add(a: Any, b: Any) -> Any:
+    """Matrix addition; there is no mat_add in the public surface."""
+    return [[x + y for x, y in zip(ra, rb)] for ra, rb in zip(a, b)]
+
+
+def test_distributive_law() -> None:
+    # Three mutually conformable 3x3 operands.
+    a: Any = [[1, 2, 3], [4, 5, 6], [7, 8, 10]]
+    b: Any = [[2, 0, 1], [1, 3, 0], [0, 1, 2]]
+    c: Any = [[3, 1, 4], [1, 5, 9], [2, 6, 5]]
+    assert mat_mul(a, _add(b, c)) == _add(mat_mul(a, b), mat_mul(a, c))
+
+
+def test_identity_is_the_neutral_element() -> None:
+    m: Any = MATRICES[4]
+    assert mat_mul(m, identity(len(m))) == m
+
+
+def test_double_inverse_round_trip() -> None:
+    from cds.math_utils.linalg import matrix_inverse
+
+    m: Any = MATRICES[2]
+    twice = matrix_inverse(matrix_inverse(m))
+    for got, want in zip(twice, m):
+        assert got == pytest.approx(want, abs=1e-9)

scientific_computing_system-2.2.8/tests/test_validation_bounds_nonfinite_regression.py

@@ -0,0 +1,27 @@
+"""Bounds validation must fail closed on non-finite data or invalid intervals."""
+
+from __future__ import annotations
+
+import math
+
+from cds.validation import CheckStatus, check_bounds
+
+
+def test_nonfinite_values_do_not_pass_domain_bounds() -> None:
+    result = check_bounds([math.nan, math.inf, -math.inf, 1.0], [(0.0, 2.0)] * 4)
+    assert result.status is CheckStatus.FAIL
+    assert result.details["violations"] == [0, 1, 2]
+
+
+def test_nonfinite_bound_and_reversed_interval_do_not_pass() -> None:
+    result = check_bounds(
+        [1.0, 1.0, 1.0, 1.0],
+        [(math.nan, 2.0), (0.0, math.inf), (2.0, 0.0), (0.0, 2.0)],
+    )
+    assert result.status is CheckStatus.FAIL
+    assert result.details["violations"] == [0, 1, 2]
+
+
+def test_finite_boundary_values_remain_inclusive() -> None:
+    result = check_bounds([0.0, 2.0], [(0.0, 2.0)] * 2)
+    assert result.status is CheckStatus.PASS

scientific_computing_system-2.2.8/tests/test_validation_nonfinite_thresholds_regression.py

@@ -0,0 +1,57 @@
+"""Non-finite tolerance settings must never certify invalid scientific results."""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable
+
+import pytest
+
+from cds.validation.checks import (
+    check_conservation,
+    check_distribution_drift,
+    check_ood_ranges,
+    check_residual_diagnostics,
+    cross_method_agreement,
+)
+
+
+@pytest.mark.parametrize("threshold", [math.nan, math.inf, -math.inf])
+@pytest.mark.parametrize("parameter", ["rtol", "atol"])
+@pytest.mark.parametrize("check", [cross_method_agreement, check_conservation])
+def test_tolerances_reject_nonfinite_values(
+    check: Callable[..., object], parameter: str, threshold: float
+) -> None:
+    with pytest.raises(ValueError, match="rtol and atol"):
+        check(1.0, 2.0, **{parameter: threshold})
+
+
+@pytest.mark.parametrize("margin", [math.nan, math.inf, -math.inf])
+def test_ood_margin_must_be_finite(margin: float) -> None:
+    with pytest.raises(ValueError, match="margin_fraction"):
+        check_ood_ranges([[1.0], [2.0]], [[100.0]], margin_fraction=margin)
+
+
+@pytest.mark.parametrize("threshold", [math.nan, math.inf, -math.inf])
+@pytest.mark.parametrize("parameter", ["max_standardized_mean_shift", "max_variance_ratio"])
+def test_drift_thresholds_reject_nonfinite(parameter: str, threshold: float) -> None:
+    with pytest.raises(ValueError, match=parameter):
+        if parameter == "max_standardized_mean_shift":
+            check_distribution_drift(
+                [1.0, 2.0], [10.0, 11.0], max_standardized_mean_shift=threshold
+            )
+        else:
+            check_distribution_drift([1.0, 2.0], [10.0, 11.0], max_variance_ratio=threshold)
+
+
+@pytest.mark.parametrize("threshold", [math.nan, math.inf, -math.inf])
+@pytest.mark.parametrize("parameter", ["max_bias_z", "max_abs_lag1", "max_variance_ratio"])
+def test_residual_thresholds_reject_nonfinite(parameter: str, threshold: float) -> None:
+    with pytest.raises(ValueError, match="residual diagnostic thresholds"):
+        residuals = [1.0, -1.0, 2.0, -2.0]
+        if parameter == "max_bias_z":
+            check_residual_diagnostics(residuals, max_bias_z=threshold)
+        elif parameter == "max_abs_lag1":
+            check_residual_diagnostics(residuals, max_abs_lag1=threshold)
+        else:
+            check_residual_diagnostics(residuals, max_variance_ratio=threshold)

scientific_computing_system-2.2.6/tests/test_property_invariants.py

@@ -1,277 +0,0 @@
-"""Hypothesis-driven property-based tests.
-
-Where ``test_numerical_invariants.py`` rolls its own ``random.Random`` loop
-(zero new dependencies, fixed seed, fixed trial count), this module leans on
-the `Hypothesis <https://hypothesis.readthedocs.io/>`_ library to do real
-property-based testing: Hypothesis *searches* the input space for a failing
-example and then *shrinks* any failure to the smallest input that still
-reproduces it. That catches edge cases a hand-picked seed will miss — empty
-lists, single-element lists, integers at 0, vectors that are near-singular,
-and so on.
-
-This suite is optional: it only runs when Hypothesis is installed
-(``pip install ".[property]"`` or ``[all]``). CI gates it behind a dedicated
-job (see ``.github/workflows/tests.yml``) so a missing dependency never breaks
-the default ``[test]`` matrix. The module-level guard below makes that safe:
-without Hypothesis, every test skips rather than erroring on import.
-
-Properties covered (6 domains):
-    1. Linear algebra — inverse round-trip (A·A⁻¹ = I), transpose involution.
-    2. Descriptive statistics — variance is non-negative, median lies in range,
-       mean is homogeneous under positive scaling.
-    3. Numerical calculus — derivative is linear (af+bg)' = af' + bg',
-       derivative of a constant is zero.
-    4. Signals — FFT ⇄ IFFT round-trip recovers the input, Parseval energy.
-    5. Optimization — gradient descent never increases a convex quadratic.
-    6. Probability — a PMF built from arbitrary non-negative weights sums to 1,
-       and its cumulative sum is monotone non-decreasing.
-"""
-
-from __future__ import annotations
-
-import math
-
-import pytest
-
-# Every import below runs after the ``importorskip`` guard, so module-level
-# placement triggers E402. That's intentional and correct here: we *cannot*
-# import Hypothesis before confirming it's installed. Each line carries its
-# own ``noqa: E402`` so ruff's import sorter (I001) and the E402 rule both
-# stay satisfied.
-hypothesis = pytest.importorskip("hypothesis")  # noqa: E402
-from hypothesis import given, settings  # noqa: E402
-from hypothesis import strategies as st  # noqa: E402
-from hypothesis.strategies import SearchStrategy  # noqa: E402
-
-from cds.math_utils.calculus import derivative  # noqa: E402
-from cds.math_utils.linalg import (  # noqa: E402
-    identity,
-    mat_mul,
-    matrix_inverse,
-    transpose,
-)
-from cds.signals.processing import fft as fft_func  # noqa: E402
-from cds.signals.processing import ifft as ifft_func  # noqa: E402
-from cds.stats.descriptive import mean, median, variance  # noqa: E402
-
-# A modest example budget keeps the suite fast in CI while still exercising
-# Hypothesis's search + shrink loop. The default (100) would be fine too; we
-# tune down because each property here runs a numerical kernel (FFT, matrix
-# inverse) rather than a cheap predicate.
-MAX_EXAMPLES = 50
-
-
-# --------------------------------------------------------------------------- #
-# Shared strategies
-# --------------------------------------------------------------------------- #
-def finite_floats(
-    lo: float = -1e6, hi: float = 1e6, allow_nan: bool = False
-) -> SearchStrategy[float]:
-    """Finite, non-NaN floats in [lo, hi].
-
-    NaN/inf are valid Python floats but they break every numerical invariant
-    (NaN != NaN, inf - inf = NaN). Excluding them keeps the properties about
-    the *algorithm* rather than IEEE-754 edge cases, which the example-based
-    suite already covers explicitly.
-    """
-    return st.floats(min_value=lo, max_value=hi, allow_nan=allow_nan, allow_infinity=False)
-
-
-@st.composite
-def square_matrix(draw: st.DrawFn, n_min: int = 1, n_max: int = 5) -> list[list[float]]:
-    """A random square matrix with moderate-magnitude entries.
-
-    Bounded magnitude (±10) keeps matrices far from the overflow/underflow
-    frontier where float error alone can flip a singularity check.
-    """
-    n = draw(st.integers(min_value=n_min, max_value=n_max))
-    return [[draw(finite_floats(-10.0, 10.0)) for _ in range(n)] for _ in range(n)]
-
-
-@st.composite
-def power_of_two_length(draw: st.DrawFn, exp_min: int = 1, exp_max: int = 7) -> int:
-    """A length that is a power of two (the FFT radix-2 constraint)."""
-    return 1 << draw(st.integers(min_value=exp_min, max_value=exp_max))
-
-
-# --------------------------------------------------------------------------- #
-# 1. Linear algebra
-# --------------------------------------------------------------------------- #
-class TestLinAlgProperties:
-    @given(mat=square_matrix(n_min=2, n_max=4))
-    @settings(max_examples=MAX_EXAMPLES)
-    def test_transpose_is_involution(self, mat: list[list[float]]) -> None:
-        # (Aᵀ)ᵀ = A for every matrix.
-        assert transpose(transpose(mat)) == mat
-
-    @given(mat=square_matrix(n_min=2, n_max=4))
-    @settings(max_examples=MAX_EXAMPLES)
-    def test_inverse_times_original_is_identity(self, mat: list[list[float]]) -> None:
-        # A·A⁻¹ = I, provided A is invertible. We compute the determinant and
-        # skip near-singular matrices (|det| below a floor) — those are a
-        # property of the *precondition*, not of the inverse routine.
-        from cds.math_utils.linalg import determinant
-
-        if abs(determinant(mat)) < 1e-3:
-            return  # skip: invertibility precondition not met
-        n = len(mat)
-        prod = mat_mul(matrix_inverse(mat), mat)
-        ident = identity(n)
-        for i in range(n):
-            for j in range(n):
-                assert math.isclose(prod[i][j], ident[i][j], abs_tol=1e-6)
-
-
-# --------------------------------------------------------------------------- #
-# 2. Descriptive statistics
-# --------------------------------------------------------------------------- #
-class TestStatsProperties:
-    @given(data=st.lists(finite_floats(-1e4, 1e4), min_size=2, max_size=50))
-    @settings(max_examples=MAX_EXAMPLES)
-    def test_variance_non_negative(self, data: list[float]) -> None:
-        # Variance is a sum of squares over a count — always ≥ 0. A negative
-        # result would flag a catastrophic-cancellation bug in the formula.
-        assert variance(data, ddof=0) >= -1e-9
-
-    @given(data=st.lists(finite_floats(-1e4, 1e4), min_size=1, max_size=50))
-    @settings(max_examples=MAX_EXAMPLES)
-    def test_median_within_data_range(self, data: list[float]) -> None:
-        # The median of a set can never lie outside [min, max] of that set.
-        m = median(data)
-        assert min(data) - 1e-9 <= m <= max(data) + 1e-9
-
-    @given(
-        data=st.lists(finite_floats(-1e3, 1e3), min_size=1, max_size=30),
-        scale=finite_floats(0.1, 10.0),
-    )
-    @settings(max_examples=MAX_EXAMPLES)
-    def test_mean_is_homogeneous(self, data: list[float], scale: float) -> None:
-        # mean(c·x) = c·mean(x) — linearity of the arithmetic mean under
-        # positive scalar scaling. Negative/zero scale would be just as valid
-        # but flipping the sign on an odd-length list complicates the bound.
-        # When mean(x) ≈ 0 (e.g. symmetric data like [342, -342]) the relative
-        # error of c·mean(x) blows up even though the absolute error is at the
-        # round-off floor, so anchor with an abs_tol in addition to rel_tol.
-        assert math.isclose(
-            mean([scale * x for x in data]),
-            scale * mean(data),
-            rel_tol=1e-9,
-            abs_tol=1e-9,
-        )
-
-
-# --------------------------------------------------------------------------- #
-# 3. Numerical calculus
-# --------------------------------------------------------------------------- #
-class TestCalculusProperties:
-    @given(
-        a=finite_floats(-5.0, 5.0),
-        b=finite_floats(-5.0, 5.0),
-        x=finite_floats(-3.0, 3.0),
-    )
-    @settings(max_examples=MAX_EXAMPLES)
-    def test_derivative_is_linear(self, a: float, b: float, x: float) -> None:
-        # (a·f + b·g)' = a·f' + b·g'. Use f(t)=t² and g(t)=sin(t) so both
-        # branches of the central-difference formula are exercised.
-        def f(t: float) -> float:
-            return t * t
-
-        def g(t: float) -> float:
-            return math.sin(t)
-
-        def combo(t: float) -> float:
-            return a * f(t) + b * g(t)
-
-        lhs = derivative(combo, x)
-        rhs = a * derivative(f, x) + b * derivative(g, x)
-        assert math.isclose(lhs, rhs, rel_tol=1e-5, abs_tol=1e-5)
-
-    @given(c=finite_floats(-100.0, 100.0), x=finite_floats(-10.0, 10.0))
-    @settings(max_examples=MAX_EXAMPLES)
-    def test_derivative_of_constant_is_zero(self, c: float, x: float) -> None:
-        # d/dx [c] = 0. Central difference must recover this to within the
-        # cancellation noise of subtracting two equal-valued evaluations.
-        assert abs(derivative(lambda _t: c, x)) < 1e-5
-
-
-# --------------------------------------------------------------------------- #
-# 4. Signals
-# --------------------------------------------------------------------------- #
-class TestSignalProperties:
-    @given(n=power_of_two_length(exp_min=1, exp_max=6))
-    @settings(max_examples=MAX_EXAMPLES)
-    def test_fft_ifft_roundtrip(self, n: int) -> None:
-        # ifft(fft(x)) == x (within float noise). Power-of-two length is the
-        # radix-2 contract; non-power-of-two falls back to the DFT path which
-        # is covered by the example-based suite.
-        x = [math.sin(i) * 0.5 for i in range(n)]
-        recon = ifft_func(fft_func(list(x)))
-        for r, xi in zip(recon, x):
-            assert math.isclose(r.real, xi, rel_tol=1e-7, abs_tol=1e-7)
-            assert abs(r.imag) < 1e-7
-
-    @given(n=power_of_two_length(exp_min=2, exp_max=6))
-    @settings(max_examples=MAX_EXAMPLES)
-    def test_parseval_energy_conservation(self, n: int) -> None:
-        # Σ|x[n]|² = (1/N)·Σ|X[k]|². Energy is conserved across the DFT.
-        x = [math.cos(i) for i in range(n)]
-        spec = fft_func(list(x))
-        time_energy = sum(abs(xi) ** 2 for xi in x)
-        freq_energy = sum(abs(xk) ** 2 for xk in spec) / n
-        assert math.isclose(time_energy, freq_energy, rel_tol=1e-6)
-
-
-# --------------------------------------------------------------------------- #
-# 5. Optimization
-# --------------------------------------------------------------------------- #
-class TestOptimizationProperties:
-    @given(
-        x_star=finite_floats(-5.0, 5.0),
-        x0=finite_floats(-5.0, 5.0),
-    )
-    @settings(max_examples=MAX_EXAMPLES)
-    def test_gradient_descent_reduces_convex_objective(self, x_star: float, x0: float) -> None:
-        # On the convex quadratic f(x) = (x − x*)² the objective value after
-        # gradient descent must not exceed the starting objective. Convexity
-        # guarantees a descent direction; a rise would signal a sign flip in
-        # the update step. Skip when x0 is already at the minimum.
-        from cds.optimization.minimize import gradient_descent
-
-        if abs(x0 - x_star) < 1e-3:
-            return  # skip: already at the global minimum
-
-        def f(x: float, _xs: float = x_star) -> float:
-            return (x - _xs) ** 2
-
-        f_start = f(x0)
-        result = gradient_descent(f, x0, lr=0.1, tol=1e-10, max_iter=500)
-        assert result.value <= f_start + 1e-9
-
-
-# --------------------------------------------------------------------------- #
-# 6. Probability
-# --------------------------------------------------------------------------- #
-class TestProbabilityProperties:
-    @given(weights=st.lists(finite_floats(0.01, 100.0), min_size=2, max_size=20))
-    @settings(max_examples=MAX_EXAMPLES)
-    def test_pmf_normalizes(self, weights: list[float]) -> None:
-        # Any set of positive weights, divided by their sum, yields a PMF
-        # that sums to exactly 1.
-        total = sum(weights)
-        pmf = [w / total for w in weights]
-        assert math.isclose(sum(pmf), 1.0, abs_tol=1e-12)
-
-    @given(weights=st.lists(finite_floats(0.01, 100.0), min_size=2, max_size=20))
-    @settings(max_examples=MAX_EXAMPLES)
-    def test_cdf_is_monotone(self, weights: list[float]) -> None:
-        # The cumulative sum of a PMF is non-decreasing and ends at 1.
-        total = sum(weights)
-        pmf = [w / total for w in weights]
-        cdf: list[float] = []
-        acc = 0.0
-        for p in pmf:
-            acc += p
-            cdf.append(acc)
-        for prev, cur in zip(cdf, cdf[1:]):
-            assert cur >= prev - 1e-12
-        assert math.isclose(cdf[-1], 1.0, abs_tol=1e-12)