cdclkit 0.1.4__tar.gz → 0.1.6__tar.gz

{cdclkit-0.1.4 → cdclkit-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdclkit
-Version: 0.1.4
+Version: 0.1.6
 Summary: A CDCL SAT solver, preprocessor, encoding library and modelling layer, written from scratch in readable Python. Every answer comes with a certificate.
 Author: Carlo Perassi
 License-Expression: Apache-2.0
@@ -17,6 +17,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Rust
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Requires-Python: >=3.10
@@ -24,7 +25,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: dratify>=0.1.7
 Provides-Extra: native
-Requires-Dist: cdclkit-native==0.1.4; extra == "native"
+Requires-Dist: cdclkit-native==0.1.6; extra == "native"
 Dynamic: license-file
 
 # cdclkit

{cdclkit-0.1.4 → cdclkit-0.1.6}/cdclkit/__init__.py

@@ -52,7 +52,7 @@ from .preprocess import Preprocessor, preprocess
 from dratify.proof import DRATChecker, MemoryProof, ProofWriter, check_proof
 from .solver import Config, SAT, Solver, Stats, UNKNOWN, UNSAT
 
-__version__ = "0.1.4"
+__version__ = "0.1.6"
 
 __all__ = [
     "CNF",

{cdclkit-0.1.4 → cdclkit-0.1.6}/cdclkit/cli.py

@@ -47,6 +47,26 @@ def _native_ok() -> bool:
     return native.available()
 
 
+def _pick_engine() -> str | None:
+    """The engine for `--adaptive` and `-j`; None after printing an error.
+
+    Native when it is installed: it is bit-exact with Python, so this changes
+    the speed and not the answer. CDCLKIT_ENGINE overrides it, which is how to
+    rule the native engine in or out of a suspect result. The plain sequential
+    path is always Python.
+    """
+    from . import native
+
+    try:
+        engine = native.engine_requested(
+            default="native" if _native_ok() else "python")
+    except RuntimeError as e:
+        print(f"c error: {e}", file=sys.stderr)
+        return None
+    print(f"c engine: {engine}")
+    return engine
+
+
 EXIT_SAT = 10
 EXIT_UNSAT = 20
 EXIT_UNKNOWN = 0
@@ -115,9 +135,12 @@ def cmd_solve(args) -> int:
                   "(workers race and their steps interleave); drop -j or drop "
                   "--proof/--self-check")
             return EXIT_ERROR
+        engine = _pick_engine()
+        if engine is None:
+            return EXIT_ERROR
         pr = solve_adaptive(
             f,
-            engine="native" if _native_ok() else "python",
+            engine=engine,
             config=cfg,
             jobs=jobs,
             proof=proof_sink,
@@ -146,7 +169,11 @@ def cmd_solve(args) -> int:
         # Parallel portfolio.  Only the winning worker's proof exists, and
         # because workers share no clauses it is a complete refutation on its
         # own -- see cdclkit/portfolio.py.
-        pr = solve_portfolio(f, jobs=jobs, want_proof=proof_sink is not None)
+        engine = _pick_engine()
+        if engine is None:
+            return EXIT_ERROR
+        pr = solve_portfolio(f, jobs=jobs, engine=engine,
+                             want_proof=proof_sink is not None)
         if not pr.finished:
             print("s UNKNOWN")
             return EXIT_UNKNOWN

{cdclkit-0.1.4 → cdclkit-0.1.6}/cdclkit/native.py

@@ -13,10 +13,13 @@ The contract, in both directions:
   full under a plain `python3` with no Rust toolchain anywhere. That property
   is tested, not assumed -- it is what lets the port proceed in small commits
   without the repo ever being in a broken state.
-* **If it is present, it is opt-in.** Nothing selects the native path on its
-  own. A caller asks for it explicitly (`--engine native`, or
-  `CDCLKIT_ENGINE=native`), because a silent switch between two implementations
-  is how differential bugs hide.
+* **If it is present, the plain solver still does not use it.** `Solver`,
+  `solve()` and `cdclkit solve` are Python. `solve_adaptive()`,
+  `solve_portfolio()` and `cdclkit solve --adaptive` / `-j N` use it when it is
+  installed. That is safe only because the two engines are bit-exact and tested
+  to stay that way. A silent switch between two implementations is how
+  differential bugs hide, so the CLI prints which engine ran and
+  `CDCLKIT_ENGINE` (read by `engine_requested()`) overrides the choice.
 
 Building it::
 
@@ -54,8 +57,7 @@ else:  # pragma: no cover - depends on whether the module was built
     #
     # This is not the silent engine switch the rest of this module warns about.
     # Two checkers must agree by construction -- if they ever disagree that is
-    # a bug worth surfacing, not a difference worth preserving. The solver is
-    # the thing that stays explicitly opt-in.
+    # a bug worth surfacing, not a difference worth preserving.
     try:
         import dratify as _dratify
         _dratify.register_native(_native)

{cdclkit-0.1.4 → cdclkit-0.1.6}/cdclkit/pyeq.py

@@ -198,8 +198,11 @@ class BitVec:
         return self.enc.and_gate(same)
 
     def slt(self, other: "BitVec") -> int:
-        """Signed less-than, via the sign of the difference with overflow
-        correction: a < b iff (a-b) is negative, XOR the signed-overflow flag."""
+        """Signed less-than: a < b iff a - b is negative.
+
+        Both operands are sign-extended by one bit before subtracting, so the
+        difference of two w-bit values always fits in w+1 bits and cannot
+        overflow. Its top bit is then the answer, with no overflow flag."""
         enc = self.enc
         w = max(self.width, other.width) + 1  # one extra bit kills the overflow case
         a, b = self.extend(w), other.extend(w)
@@ -451,10 +454,12 @@ class _Compiler(ast.NodeVisitor):
         self._fail(node, type(node).__name__)
 
     def assign(self, name: str, value: BitVec) -> None:
-        """Assign under the current path condition.
+        """Bind `name` to `value` in the current environment, unconditionally.
 
-        Inside a branch the assignment is conditional, so the variable becomes
-        a select between the new value and whatever it held before.
+        Branches stay correct without a select here: an `if` runs each arm on
+        its own copy of the environment and merges them afterwards, with one
+        select per variable that differs between the arms (see the `ast.If`
+        case of `stmt`).
         """
         self.env[name] = value
 

{cdclkit-0.1.4 → cdclkit-0.1.6}/cdclkit/solver.py

@@ -392,6 +392,11 @@ class Solver:
         #: depth. Only meaningful when cfg.target_phase is on.
         self._target = bytearray()
         self._target_size = 0
+        #: how much of the current trail the target already records: for every
+        #: i < _target_synced, _target holds trail[i]'s value. The trail only
+        #: grows by appending and only shrinks in _cancel_until, so a prefix
+        #: that has been copied stays copied until a backtrack cuts into it.
+        self._target_synced = 0
         self._walk_best = 1 << 30
         self._walk_stale = 0
         self.frozen = bytearray()  # variables excluded from decisions
@@ -605,6 +610,8 @@ class Solver:
         del trail[bound:]
         del self.trail_lim[level:]
         self.qhead = len(trail)
+        if self._target_synced > bound:
+            self._target_synced = bound
 
     # ------------------------------------------------------------ propagation
 
@@ -1154,6 +1161,7 @@ class Solver:
         self._target[:] = best
         self.polarity[:] = best
         self._target_size = 0   # the target now describes the walk, not a trail
+        self._target_synced = 0
 
     # -------------------------------------------------------------- restarts
 
@@ -1229,13 +1237,21 @@ class Solver:
                     self._reduce_db()
             else:
                 # A new deepest conflict-free trail: remember the assignment
-                # that reached it. Copying costs O(|trail|), but only on a
-                # strict improvement, and improvements become rare quickly.
+                # that reached it -- copying only what the target does not
+                # already hold. This used to copy the whole trail on every
+                # improvement, on the theory that improvements become rare
+                # quickly. They do once conflicts start; a search that makes
+                # many decisions without one improves on every decision, and
+                # n of them cost O(n^2) (tests/test_target_scaling.py). The
+                # target ends up byte-for-byte what the full copy produced.
                 if self.cfg.target_phase and len(self.trail) > self._target_size:
-                    self._target_size = len(self.trail)
+                    trail = self.trail
+                    self._target_size = len(trail)
                     target = self._target
-                    for t in self.trail:
+                    for i in range(self._target_synced, len(trail)):
+                        t = trail[i]
                         target[t >> 1] = 0 if (t & 1) else 1
+                    self._target_synced = len(trail)
 
                 if max_conflicts is not None and conflicts >= max_conflicts:
                     self._cancel_until(len(self.assumptions_applied))

{cdclkit-0.1.4 → cdclkit-0.1.6}/cdclkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdclkit
-Version: 0.1.4
+Version: 0.1.6
 Summary: A CDCL SAT solver, preprocessor, encoding library and modelling layer, written from scratch in readable Python. Every answer comes with a certificate.
 Author: Carlo Perassi
 License-Expression: Apache-2.0
@@ -17,6 +17,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Rust
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Requires-Python: >=3.10
@@ -24,7 +25,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: dratify>=0.1.7
 Provides-Extra: native
-Requires-Dist: cdclkit-native==0.1.4; extra == "native"
+Requires-Dist: cdclkit-native==0.1.6; extra == "native"
 Dynamic: license-file
 
 # cdclkit

{cdclkit-0.1.4 → cdclkit-0.1.6}/cdclkit.egg-info/SOURCES.txt

@@ -39,4 +39,5 @@ tests/test_preprocess.py
 tests/test_proof.py
 tests/test_pyeq.py
 tests/test_readme.py
-tests/test_solver.py
+tests/test_solver.py
+tests/test_target_scaling.py

{cdclkit-0.1.4 → cdclkit-0.1.6}/cdclkit.egg-info/requires.txt

@@ -1,4 +1,4 @@
 dratify>=0.1.7
 
 [native]
-cdclkit-native==0.1.4
+cdclkit-native==0.1.6

{cdclkit-0.1.4 → cdclkit-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cdclkit"
-version = "0.1.4"
+version = "0.1.6"
 description = "A CDCL SAT solver, preprocessor, encoding library and modelling layer, written from scratch in readable Python. Every answer comes with a certificate."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -22,6 +22,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "Programming Language :: Rust",
     "Topic :: Scientific/Engineering :: Mathematics",
 ]
@@ -35,7 +36,7 @@ dependencies = ["dratify>=0.1.7"]
 # The Rust accelerator, as abi3 wheels for Linux and macOS. Pinned exactly:
 # the two are bit-exact by construction and a mismatched pair is a divergence
 # nobody would look for. tests/test_packaging.py enforces the pin.
-native = ["cdclkit-native==0.1.4"]
+native = ["cdclkit-native==0.1.6"]
 
 [project.scripts]
 cdclkit = "cdclkit.__main__:main"

{cdclkit-0.1.4 → cdclkit-0.1.6}/tests/test_adaptive_proof.py

@@ -113,11 +113,14 @@ class TestAdaptiveEmitsACheckableProof(unittest.TestCase):
 class TestAdaptiveCLI(unittest.TestCase):
     """End to end, because the bug was in the wiring rather than the pipeline."""
 
-    def _cli(self, *args):
+    def _cli(self, *args, engine=None):
         root = pathlib.Path(__file__).resolve().parent.parent
         import os
 
         env = dict(os.environ)
+        env.pop("CDCLKIT_ENGINE", None)
+        if engine is not None:
+            env["CDCLKIT_ENGINE"] = engine
         # prepend, do not replace: a pure-Python checkout finds dratify on the
         # inherited path, and clobbering it made these fail for the wrong reason
         env["PYTHONPATH"] = os.pathsep.join(
@@ -156,6 +159,47 @@ class TestAdaptiveCLI(unittest.TestCase):
         self.assertEqual(r.returncode, 1)
         self.assertIn("interleave", r.stdout)
 
+    # AGENTS.md said CDCLKIT_ENGINE selected the engine. Nothing read it, and
+    # `--adaptive` picked native on its own whenever it was installed.
+
+    def _php(self, engine=None):
+        with tempfile.TemporaryDirectory() as d:
+            cnf = pathlib.Path(d) / "php.cnf"
+            cnf.write_text(PHP)
+            return self._cli("solve", str(cnf), "--adaptive", engine=engine)
+
+    def test_adaptive_uses_native_when_installed(self):
+        r = self._php()
+        self.assertEqual(r.returncode, 20, r.stdout + r.stderr)
+        want = "native" if native.available() else "python"
+        self.assertIn(f"c engine: {want}", r.stdout)
+
+    def test_cdclkit_engine_python_overrides_adaptive(self):
+        r = self._php(engine="python")
+        self.assertEqual(r.returncode, 20, r.stdout + r.stderr)
+        self.assertIn("c engine: python", r.stdout)
+
+    def test_cdclkit_engine_native_without_the_build_is_an_error(self):
+        if native.available():
+            self.skipTest("native engine is built here")
+        r = self._php(engine="native")
+        self.assertEqual(r.returncode, 1, r.stdout + r.stderr)
+        self.assertIn("CDCLKIT_ENGINE=native", r.stderr)
+        self.assertNotIn("Traceback", r.stderr)
+
+    def test_portfolio_honours_cdclkit_engine_too(self):
+        with tempfile.TemporaryDirectory() as d:
+            cnf = pathlib.Path(d) / "php.cnf"
+            cnf.write_text(PHP)
+            r = self._cli("solve", str(cnf), "-j", "2", engine="python")
+        self.assertEqual(r.returncode, 20, r.stdout + r.stderr)
+        self.assertIn("c engine: python", r.stdout)
+
+    def test_unknown_cdclkit_engine_is_an_error(self):
+        r = self._php(engine="quantum")
+        self.assertEqual(r.returncode, 1, r.stdout + r.stderr)
+        self.assertIn("unknown CDCLKIT_ENGINE", r.stderr)
+
 
 if __name__ == "__main__":
     unittest.main()

{cdclkit-0.1.4 → cdclkit-0.1.6}/tests/test_portfolio.py

@@ -151,6 +151,12 @@ class TestEngineSelection(unittest.TestCase):
     """The portfolio can run native workers; correctness must not depend on it."""
 
     def test_python_and_native_engines_agree(self):
+        from cdclkit import native
+
+        if not native.available():
+            # engine="native" falls back to Python, so this would compare
+            # Python against Python and pass
+            self.skipTest("native engine not built")
         rng = random.Random(fuzz_seed(13))
         for _ in range(15):
             f = random_cnf(rng, max_vars=9, ratio=4.8)

cdclkit-0.1.6/tests/test_target_scaling.py

@@ -0,0 +1,78 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (c) 2026 Carlo Perassi. Licensed under the Apache License 2.0.
+"""Target phases must not make the search quadratic in the number of variables.
+
+With target phases on (the default), each time the trail reached a new depth
+the solver copied the whole trail into the target. The comment beside it said
+improvements "become rare quickly". That holds only once conflicts happen. A
+search that makes many decisions without a conflict improves on every one, so
+n decisions copied 1, 2, ..., n entries.
+
+Measured on the Python engine, solving one unit clause in a formula that
+declares n variables: 4,096 took 0.8 s, 16,384 took 10.6 s and 65,536 took
+144 s -- each 4x costing about 13x. Turning target phases off made 16,384
+take 0.11 s. Since dratify 0.1.7 a header may declare up to 2^20 variables
+from a file of any length, so a 22-byte file cost hours of CPU.
+
+The test compares scaling rather than absolute time, which shared CI runners
+cannot be trusted with: quadrupling the variables should cost about 4x when
+the search is linear and about 16x when it is quadratic. The threshold sits
+between them, and each size takes the best of three runs to damp noise.
+"""
+
+from __future__ import annotations
+
+import time
+import unittest
+
+from cdclkit import native
+from cdclkit.solver import Solver
+
+
+def _solve(nvars: int, engine: str) -> bool:
+    """One unit clause, `nvars` declared: every other variable is a decision."""
+    if engine == "native":
+        s = native.require().Solver(nvars)   # defaults match Config
+    else:
+        s = Solver(nvars)
+    s.add_clause([0])
+    return s.solve()
+
+
+def _seconds(nvars: int, engine: str) -> float:
+    best = float("inf")
+    for _ in range(3):
+        t0 = time.perf_counter()
+        sat = _solve(nvars, engine)
+        best = min(best, time.perf_counter() - t0)
+        assert sat
+    return best
+
+
+class TestUnusedVariablesCostLinearTime(unittest.TestCase):
+    #: quadrupling: ~4x if linear, ~16x if quadratic
+    LIMIT = 8.0
+
+    def _check(self, engine: str, small: int):
+        t_small = _seconds(small, engine)
+        t_large = _seconds(4 * small, engine)
+        ratio = t_large / max(t_small, 1e-4)
+        self.assertLess(
+            ratio, self.LIMIT,
+            f"{engine}: {small:,} vars took {t_small:.3f}s and "
+            f"{4 * small:,} took {t_large:.3f}s, a {ratio:.1f}x increase for "
+            f"4x the variables. Linear is ~4x; this is closer to quadratic.")
+
+    def test_python_engine(self):
+        self._check("python", 4096)
+
+    @unittest.skipUnless(native.available(),
+                         "native engine not built for this interpreter")
+    def test_native_engine(self):
+        # Rust is fast enough that the quadratic term only dominates at
+        # larger sizes.
+        self._check("native", 32768)
+
+
+if __name__ == "__main__":
+    unittest.main()