cdclkit 0.1.2__tar.gz → 0.1.3__tar.gz

{cdclkit-0.1.2 → cdclkit-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdclkit
-Version: 0.1.2
+Version: 0.1.3
 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
@@ -22,9 +22,9 @@ Classifier: Topic :: Scientific/Engineering :: Mathematics
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: dratify>=0.1.1
+Requires-Dist: dratify>=0.1.4
 Provides-Extra: native
-Requires-Dist: cdclkit-native==0.1.2; extra == "native"
+Requires-Dist: cdclkit-native==0.1.3; extra == "native"
 Dynamic: license-file
 
 # cdclkit
@@ -36,7 +36,7 @@ Every answer comes with a certificate, and the certificate gets checked.
 
 ```bash
 pip install cdclkit              # pure Python
-pip install "cdclkit[native]"    # plus the Rust engine, ~18x faster
+pip install "cdclkit[native]"    # plus the Rust engine, ~20x faster
 ```
 
 Three packages, and no third-party code:
@@ -59,6 +59,56 @@ A solver that says "unsatisfiable" and offers nothing else is asking to be
 trusted. This one hands you the proof — and the checker that reads it shares no
 code with the solver that wrote it.
 
+## Why you would want this
+
+**Use this if:**
+
+- ✅ You have constraints and need any assignment satisfying all of them
+- ✅ You need to know **why** something is infeasible, not just that it is
+- ✅ You need to *verify* an "impossible" answer rather than trust it
+- ✅ You want to read the solver, or teach how CDCL works
+- ✅ You want zero third-party dependencies
+
+**Use something else if:**
+
+- ❌ You need raw speed on industrial instances → [PySAT](https://pypi.org/project/python-sat/) ships kissat and CaDiCaL
+- ❌ Your problem is numeric optimisation over real numbers → an LP or MIP solver
+- ❌ You need Windows → never tested here, and the classifiers say so
+
+---
+
+You have a pile of constraints and need any assignment satisfying all of them:
+
+- **Rostering and scheduling** — six nurses, three shifts, nobody works two
+  nights running, everyone gets a weekend off a month.
+- **Configuration** — which package versions can coexist, which hardware
+  options are compatible.
+- **Assignment** — exams to rooms and slots with no clashes, frequencies to
+  transmitters that must not interfere.
+- **Puzzles** — Sudoku, nonograms, the zebra puzzle. Genuinely the same shape
+  as the three above.
+
+The alternative is writing backtracking search yourself. That is slow to write,
+and what you produce in an afternoon will be far slower than a solver with
+thirty years of engineering in the same loop.
+
+Two things you get that a hand-rolled search does not:
+
+- **When there is no solution, you learn why.** A minimal unsatisfiable subset
+  names the handful of constraints that actually conflict, instead of reporting
+  "infeasible" and leaving you to bisect a thousand of them.
+- **When it says "no", you can check it.** A "yes" verifies itself in linear
+  time; a "no" is an assertion about every one of 2^n assignments. This one
+  hands you a proof.
+
+**When not to.** Numeric optimisation over real numbers wants an LP or MIP
+solver, not this. Raw throughput on millions of clauses wants
+[PySAT](https://pypi.org/project/python-sat/), which ships kissat and CaDiCaL
+as binary wheels and will be much faster.
+
+New to this? [docs/tutorial/](docs/tutorial/) starts from boolean logic and
+assumes nothing else.
+
 ## Quick start
 
 ```python
@@ -73,7 +123,8 @@ Note the shape: `solve()` returns a **tuple**, so `if solve(f):` is always
 true. Unpack it.
 
 Worked examples live in `examples/` — Sudoku with a uniqueness proof, the zebra
-puzzle, graph colouring, bounded model checking, circuit equivalence.
+puzzle, graph colouring, bounded model checking, circuit equivalence, and
+checking a refactored Python function against the original.
 
 ## What's in it
 
@@ -88,9 +139,12 @@ puzzle, graph colouring, bounded model checking, circuit equivalence.
 | `pyeq` | **experimental** — bounded equivalence of two Python integer functions |
 
 An optional Rust engine ([`cdclkit-native`](https://pypi.org/project/cdclkit-native/))
-is roughly 18x faster
-and **bit-exact** with the Python one: identical conflicts, decisions and
-propagations on every instance. The pure-Python path has zero third-party
+is **bit-exact** with the Python one — identical conflicts, decisions and
+propagations on every instance — and about **20x faster**: the geometric mean
+of per-instance ratios over the 17 benchmark instances is 20.1x, ranging from
+11x to 51x. Regenerate it with `make history` (the `python` and `native`
+checkpoints in `bench/history.jsonl`); see [BENCHMARKS.md](BENCHMARKS.md) for
+the method. The pure-Python path has zero third-party
 dependencies and is the one that must never break.
 
 ## Relationship to dratify
@@ -122,13 +176,18 @@ of what is being measured.
 
 If you need raw speed, install [PySAT](https://pypi.org/project/python-sat/):
 it ships kissat, CaDiCaL and Glucose as binary wheels on every platform. This
-project is not trying to beat them. It is trying to be a complete, readable,
-self-checking implementation you can audit.
+project is not trying to beat them, and will lose badly on large instances.
+
+The difference worth naming is narrower than "readable": PySAT can emit DRUP
+proofs and ships nothing to check them, and its solvers are third-party C++ in
+a compiled extension. Here the proof gets checked by default, by a package you
+can read. That matters if you are about to act on "no solution exists", and not
+otherwise.
 
 ## Honest limitations
 
 - **No Windows.** Never tested; the classifiers say so rather than implying support.
-- Pure Python is ~18x slower than its own Rust port, which is itself far from
+- Pure Python is ~20x slower than its own Rust port, which is itself far from
   kissat. Not a tool for competition-scale instances.
 - No inprocessing, no XOR/Gaussian reasoning. Parity families are a known
   weakness and `bench/` includes one to keep that visible.
@@ -140,12 +199,20 @@ self-checking implementation you can audit.
 
 ## Documentation
 
+- [docs/tutorial/](docs/tutorial/) — **start here if you are new to SAT.** A
+  tutorial for a working programmer who knows boolean logic and has never used
+  a solver: the theory you need, then Python, then Rust. Every example runs.
 - [docs/ALGORITHMS.md](docs/ALGORITHMS.md) — the mathematics, from resolution
   through first-UIP, LBD, DRAT, encodings and preprocessing, including a
   section on what is deliberately absent.
 - [docs/ROADMAP.md](docs/ROADMAP.md) — what is planned, in sprints.
 - [docs/RELEASING.md](docs/RELEASING.md) — the release checklist.
 
+## Generating code against this?
+
+[AGENTS.md](AGENTS.md) lists the API's sharp edges — the mistakes that have
+actually been made, not hypothetical ones. Worth reading before writing a line.
+
 ## Licence
 
 Apache-2.0. See [LICENSE](LICENSE).

{cdclkit-0.1.2 → cdclkit-0.1.3}/README.md

@@ -7,7 +7,7 @@ Every answer comes with a certificate, and the certificate gets checked.
 
 ```bash
 pip install cdclkit              # pure Python
-pip install "cdclkit[native]"    # plus the Rust engine, ~18x faster
+pip install "cdclkit[native]"    # plus the Rust engine, ~20x faster
 ```
 
 Three packages, and no third-party code:
@@ -30,6 +30,56 @@ A solver that says "unsatisfiable" and offers nothing else is asking to be
 trusted. This one hands you the proof — and the checker that reads it shares no
 code with the solver that wrote it.
 
+## Why you would want this
+
+**Use this if:**
+
+- ✅ You have constraints and need any assignment satisfying all of them
+- ✅ You need to know **why** something is infeasible, not just that it is
+- ✅ You need to *verify* an "impossible" answer rather than trust it
+- ✅ You want to read the solver, or teach how CDCL works
+- ✅ You want zero third-party dependencies
+
+**Use something else if:**
+
+- ❌ You need raw speed on industrial instances → [PySAT](https://pypi.org/project/python-sat/) ships kissat and CaDiCaL
+- ❌ Your problem is numeric optimisation over real numbers → an LP or MIP solver
+- ❌ You need Windows → never tested here, and the classifiers say so
+
+---
+
+You have a pile of constraints and need any assignment satisfying all of them:
+
+- **Rostering and scheduling** — six nurses, three shifts, nobody works two
+  nights running, everyone gets a weekend off a month.
+- **Configuration** — which package versions can coexist, which hardware
+  options are compatible.
+- **Assignment** — exams to rooms and slots with no clashes, frequencies to
+  transmitters that must not interfere.
+- **Puzzles** — Sudoku, nonograms, the zebra puzzle. Genuinely the same shape
+  as the three above.
+
+The alternative is writing backtracking search yourself. That is slow to write,
+and what you produce in an afternoon will be far slower than a solver with
+thirty years of engineering in the same loop.
+
+Two things you get that a hand-rolled search does not:
+
+- **When there is no solution, you learn why.** A minimal unsatisfiable subset
+  names the handful of constraints that actually conflict, instead of reporting
+  "infeasible" and leaving you to bisect a thousand of them.
+- **When it says "no", you can check it.** A "yes" verifies itself in linear
+  time; a "no" is an assertion about every one of 2^n assignments. This one
+  hands you a proof.
+
+**When not to.** Numeric optimisation over real numbers wants an LP or MIP
+solver, not this. Raw throughput on millions of clauses wants
+[PySAT](https://pypi.org/project/python-sat/), which ships kissat and CaDiCaL
+as binary wheels and will be much faster.
+
+New to this? [docs/tutorial/](docs/tutorial/) starts from boolean logic and
+assumes nothing else.
+
 ## Quick start
 
 ```python
@@ -44,7 +94,8 @@ Note the shape: `solve()` returns a **tuple**, so `if solve(f):` is always
 true. Unpack it.
 
 Worked examples live in `examples/` — Sudoku with a uniqueness proof, the zebra
-puzzle, graph colouring, bounded model checking, circuit equivalence.
+puzzle, graph colouring, bounded model checking, circuit equivalence, and
+checking a refactored Python function against the original.
 
 ## What's in it
 
@@ -59,9 +110,12 @@ puzzle, graph colouring, bounded model checking, circuit equivalence.
 | `pyeq` | **experimental** — bounded equivalence of two Python integer functions |
 
 An optional Rust engine ([`cdclkit-native`](https://pypi.org/project/cdclkit-native/))
-is roughly 18x faster
-and **bit-exact** with the Python one: identical conflicts, decisions and
-propagations on every instance. The pure-Python path has zero third-party
+is **bit-exact** with the Python one — identical conflicts, decisions and
+propagations on every instance — and about **20x faster**: the geometric mean
+of per-instance ratios over the 17 benchmark instances is 20.1x, ranging from
+11x to 51x. Regenerate it with `make history` (the `python` and `native`
+checkpoints in `bench/history.jsonl`); see [BENCHMARKS.md](BENCHMARKS.md) for
+the method. The pure-Python path has zero third-party
 dependencies and is the one that must never break.
 
 ## Relationship to dratify
@@ -93,13 +147,18 @@ of what is being measured.
 
 If you need raw speed, install [PySAT](https://pypi.org/project/python-sat/):
 it ships kissat, CaDiCaL and Glucose as binary wheels on every platform. This
-project is not trying to beat them. It is trying to be a complete, readable,
-self-checking implementation you can audit.
+project is not trying to beat them, and will lose badly on large instances.
+
+The difference worth naming is narrower than "readable": PySAT can emit DRUP
+proofs and ships nothing to check them, and its solvers are third-party C++ in
+a compiled extension. Here the proof gets checked by default, by a package you
+can read. That matters if you are about to act on "no solution exists", and not
+otherwise.
 
 ## Honest limitations
 
 - **No Windows.** Never tested; the classifiers say so rather than implying support.
-- Pure Python is ~18x slower than its own Rust port, which is itself far from
+- Pure Python is ~20x slower than its own Rust port, which is itself far from
   kissat. Not a tool for competition-scale instances.
 - No inprocessing, no XOR/Gaussian reasoning. Parity families are a known
   weakness and `bench/` includes one to keep that visible.
@@ -111,12 +170,20 @@ self-checking implementation you can audit.
 
 ## Documentation
 
+- [docs/tutorial/](docs/tutorial/) — **start here if you are new to SAT.** A
+  tutorial for a working programmer who knows boolean logic and has never used
+  a solver: the theory you need, then Python, then Rust. Every example runs.
 - [docs/ALGORITHMS.md](docs/ALGORITHMS.md) — the mathematics, from resolution
   through first-UIP, LBD, DRAT, encodings and preprocessing, including a
   section on what is deliberately absent.
 - [docs/ROADMAP.md](docs/ROADMAP.md) — what is planned, in sprints.
 - [docs/RELEASING.md](docs/RELEASING.md) — the release checklist.
 
+## Generating code against this?
+
+[AGENTS.md](AGENTS.md) lists the API's sharp edges — the mistakes that have
+actually been made, not hypothetical ones. Worth reading before writing a line.
+
 ## Licence
 
 Apache-2.0. See [LICENSE](LICENSE).

{cdclkit-0.1.2 → cdclkit-0.1.3}/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.2"
+__version__ = "0.1.3"
 
 __all__ = [
     "CNF",

{cdclkit-0.1.2 → cdclkit-0.1.3}/cdclkit/brute.py

@@ -112,6 +112,11 @@ def dpll(f: CNF, max_steps: int = 2_000_000) -> list[bool] | None:
         steps[0] += 1
         if steps[0] > max_steps:
             raise RuntimeError("DPLL step budget exhausted")
+        # An empty clause cannot be satisfied by anything. `simplify` catches
+        # the ones this search *creates*, but one present in the input reached
+        # the split below and indexed cs[0][0] on an empty list.
+        if any(not c for c in cs):
+            return None
         # unit propagation
         while True:
             unit = next((c[0] for c in cs if len(c) == 1), None)

{cdclkit-0.1.2 → cdclkit-0.1.3}/cdclkit/cli.py

@@ -105,7 +105,23 @@ def cmd_solve(args) -> int:
     if getattr(args, "adaptive", False):
         from .pipeline import solve_adaptive
 
-        pr = solve_adaptive(f, engine="native" if _native_ok() else "python")
+        # Everything below used to be dropped here: cfg, the proof sink and the
+        # conflict budget were all built above and none reached the pipeline.
+        # `--adaptive --self-check` printed "s UNSATISFIABLE" and checked
+        # nothing, which is the one thing this project claims not to do.
+        jobs = getattr(args, "jobs", None) or 1
+        if proof_sink is not None and jobs > 1:
+            print("c error: a proof cannot be logged from a parallel portfolio "
+                  "(workers race and their steps interleave); drop -j or drop "
+                  "--proof/--self-check")
+            return EXIT_ERROR
+        pr = solve_adaptive(
+            f,
+            engine="native" if _native_ok() else "python",
+            config=cfg,
+            jobs=jobs,
+            proof=proof_sink,
+        )
         print(pr.report())
         print(f"c {pr.conflicts} conflicts in {pr.seconds:.3f}s")
         if pr.sat:
@@ -120,7 +136,10 @@ def cmd_solve(args) -> int:
                 _emit_model(pr.model)
             return EXIT_SAT
         print("s UNSATISFIABLE")
-        return EXIT_UNSAT
+        # The proof covers preprocessing *and* the search, so it is checked
+        # against the original formula, not the reduced one.
+        return _finish_unsat(args, original if original is not None else f,
+                             mem_proof, proof_sink)
 
     jobs = args.jobs
     if jobs is not None and jobs > 1:
@@ -167,9 +186,23 @@ def cmd_solve(args) -> int:
         return EXIT_SAT
 
     print("s UNSATISFIABLE")
+    return _finish_unsat(args, original, mem_proof, proof_sink)
+
+
+def _finish_unsat(args, formula, mem_proof, proof_sink) -> int:
+    """Self-check or write out the proof, then report.
+
+    Shared by the ordinary and the adaptive paths. It was inline in one of
+    them, which is how the adaptive path came to skip it entirely: the flag
+    was accepted, the branch returned early, and nothing said so.
+
+    `formula` is the *original* input. When the adaptive pipeline
+    preprocesses, its steps are logged first, so the combined proof is a
+    refutation of what the user handed in rather than of the reduced formula.
+    """
     if mem_proof is not None:
         t0 = time.perf_counter()
-        res = check_proof(original, mem_proof)
+        res = check_proof(formula, mem_proof)
         print(f"c proof self-check took {time.perf_counter()-t0:.3f}s "
               f"({len(mem_proof.steps)} steps)")
         for line in res.report().splitlines():
@@ -405,12 +438,20 @@ def build_parser() -> argparse.ArgumentParser:
                         "turns out to be hard enough to repay it")
     s.add_argument("--prep-rounds", type=int, default=3)
     s.add_argument("--conflicts", type=int, default=None, help="conflict budget")
-    s.add_argument("--restart", default="glucose", choices=["glucose", "luby", "none"])
-    s.add_argument("--var-decay", type=float, default=0.8)
-    s.add_argument("--ccmin", default="deep", choices=["deep", "basic", "none"])
-    s.add_argument("--no-phase-saving", action="store_true")
-    s.add_argument("--rnd-freq", type=float, default=0.0)
-    s.add_argument("--seed", type=int, default=91648253)
+    # Every search default comes from Config() rather than a literal. They were
+    # literals, and --restart drifted to "glucose" while the library moved to
+    # "luby" -- so the CLI quietly ran the policy the CHANGELOG says was
+    # replaced, and the headline measurement did not describe `cdclkit solve`.
+    _d = Config()
+    s.add_argument("--restart", default=_d.restart,
+                   choices=["glucose", "luby", "none"])
+    s.add_argument("--var-decay", type=float, default=_d.var_decay)
+    s.add_argument("--ccmin", default=_d.ccmin, choices=["deep", "basic", "none"])
+    s.add_argument("--no-phase-saving", action="store_true",
+                   help="phase saving is on by default"
+                        if _d.phase_saving else "phase saving is off by default")
+    s.add_argument("--rnd-freq", type=float, default=_d.rnd_freq)
+    s.add_argument("--seed", type=int, default=_d.rnd_seed)
     s.add_argument("--no-model", action="store_true", help="suppress the v lines")
     s.add_argument("--jobs", "-j", type=int, default=None,
                    metavar="N",

{cdclkit-0.1.2 → cdclkit-0.1.3}/cdclkit/encodings.py

@@ -103,12 +103,12 @@ class Encoder:
     are also used to *define* variables the caller may reference either way.
     """
 
-    #: Cap on :meth:`xor_direct`, which emits 2^(k-1) clauses.  16 inputs is
+    #: Cap on direct XOR expansion, which emits 2^(k-1) clauses.  16 inputs is
     #: 32768 clauses -- large but survivable, and the point of the direct form
     #: is to cross-check the chain on small arities, not to replace it.
     MAX_DIRECT_XOR_ARITY = 16
 
-    #: Cap on :meth:`assert_expr_expanded`, which enumerates 2^v rows over the
+    #: Cap on expanded truth-table assertion, which enumerates 2^v rows over the
     #: v variables an expression mentions.  12 is 4096 rows per conjunct.
     MAX_EXPAND_ARITY = 12
 

{cdclkit-0.1.2 → cdclkit-0.1.3}/cdclkit/pipeline.py

@@ -31,6 +31,7 @@ import time
 from typing import Sequence
 
 from dratify.cnf import CNF
+from dratify.lits import from_dimacs
 from .solver import Config, Solver
 
 __all__ = ["solve_adaptive", "PipelineResult"]
@@ -74,8 +75,27 @@ def _native_available() -> bool:
     return native.available()
 
 
+def _drain_native_proof(obj, proof) -> None:
+    """Copy a native stage's logged steps into `proof`, in order.
+
+    Both the native Solver and the native Preprocessor accumulate steps and
+    hand them over at the end, where the Python versions write to a sink as
+    they go. Concatenating them preserves DRAT's only ordering requirement:
+    a clause must be justified by what precedes it, and preprocessing precedes
+    the search.
+    """
+    if proof is None:
+        return
+    for kind, lits in obj.proof_steps():
+        internal = [from_dimacs(d) for d in lits]
+        if kind == "d":
+            proof.delete(internal)
+        else:
+            proof.add(internal)
+
+
 def _solve(f: CNF, cfg: Config, budget: int | None, engine: str,
-           seconds: float | None = None):
+           seconds: float | None = None, proof=None):
     """Returns (status, model, conflicts).  status None means budget exhausted."""
     if engine == "native":
         from . import native
@@ -94,15 +114,20 @@ def _solve(f: CNF, cfg: Config, budget: int | None, engine: str,
             glue_keep=cfg.glue_keep, block_restart=cfg.block_restart,
             rnd_freq=cfg.rnd_freq, rnd_seed=cfg.rnd_seed,
         )
+        if proof is not None:
+            s.enable_proof()  # must precede the first clause
         for c in f.clauses:
             if not s.add_clause(list(c)):
+                _drain_native_proof(s, proof)
                 return False, None, s.conflicts
         res = s.solve(budget, seconds)
         if res is None:
             return None, None, s.conflicts
+        if not res:
+            _drain_native_proof(s, proof)
         return res, (list(s.model) if res else None), s.conflicts
 
-    s = Solver(f.nvars, config=cfg)
+    s = Solver(f.nvars, config=cfg, proof=proof)
     if not s.add_cnf(f):
         return False, None, s.stats.conflicts
     res = s.solve(max_conflicts=budget, deadline=(
@@ -112,17 +137,22 @@ def _solve(f: CNF, cfg: Config, budget: int | None, engine: str,
     return res, (list(s.model) if res else None), s.stats.conflicts
 
 
-def _preprocess(f: CNF, engine: str):
+def _preprocess(f: CNF, engine: str, proof=None):
     """Returns (reduced_formula, unsat, reconstruct_fn, seconds)."""
     t0 = time.perf_counter()
     if engine == "native" and _native_available():
         from . import native
 
         n = native.require()
-        p = n.Preprocessor(f.nvars)
+        # with_proof is off by default; without it the native
+        # preprocessor logs nothing and the solver's proof ends up
+        # being about the *reduced* formula, which does not check
+        # against the original.
+        p = n.Preprocessor(f.nvars, with_proof=proof is not None)
         for c in f.clauses:
             p.add_clause(list(c))
         p.run(3)
+        _drain_native_proof(p, proof)
         red = CNF(f.nvars)
         for c in p.reduced():
             red.add(c)
@@ -131,7 +161,7 @@ def _preprocess(f: CNF, engine: str):
 
     from .preprocess import Preprocessor
 
-    p = Preprocessor(f)
+    p = Preprocessor(f, proof=proof)
     red = p.run()
     return red, p.unsat, p.reconstruct, time.perf_counter() - t0
 
@@ -145,6 +175,7 @@ def solve_adaptive(
     never_preprocess: bool = False,
     jobs: int = 1,
     seconds: float | None = None,
+    proof=None,
 ) -> PipelineResult:
     """Solve `f`, preprocessing only when a short probe says it is worth it.
 
@@ -162,13 +193,22 @@ def solve_adaptive(
     cfg = config or Config()
     if engine == "native" and not _native_available():
         engine = "python"
+    if proof is not None and jobs > 1:
+        # Portfolio workers race; whichever finishes first is the one whose
+        # refutation is returned, and the others' steps would interleave into
+        # a stream that justifies nothing. Refuse rather than emit a proof
+        # that will not check.
+        raise ValueError(
+            "a proof cannot be logged from a parallel portfolio: workers race "
+            "and their steps would interleave. Use jobs=1 when proof is set.")
 
     r = PipelineResult()
     r.clauses_before = f.nclauses
     t_start = time.perf_counter()
 
     if not never_preprocess and not always_preprocess:
-        status, model, conflicts = _solve(f, cfg, probe, engine)
+        # The probe is a real solve and may refute outright, so it logs too.
+        status, model, conflicts = _solve(f, cfg, probe, engine, proof=proof)
         r.probe_conflicts = conflicts
         if status is not None:
             r.sat, r.model, r.conflicts = status, model, conflicts
@@ -177,13 +217,14 @@ def solve_adaptive(
             return r
 
     if never_preprocess:
-        status, model, conflicts = _solve(f, cfg, None, engine, seconds)
+        status, model, conflicts = _solve(f, cfg, None, engine, seconds,
+                                          proof=proof)
         r.sat, r.model, r.conflicts = status, model, conflicts
         r.seconds = time.perf_counter() - t_start
         r.clauses_after = f.nclauses
         return r
 
-    red, unsat, reconstruct, prep_s = _preprocess(f, engine)
+    red, unsat, reconstruct, prep_s = _preprocess(f, engine, proof=proof)
     r.preprocessed = True
     r.prep_seconds = prep_s
     r.clauses_after = red.nclauses
@@ -199,12 +240,14 @@ def solve_adaptive(
         # preprocess_workers=0 because this formula is *already* preprocessed;
         # asking for preprocessing workers here would both redo the work and
         # force the process-based path, paying ~60 ms of startup for nothing
-        pr = solve_portfolio(red, jobs=jobs, engine=engine, preprocess_workers=0)
+        pr = solve_portfolio(red, jobs=jobs, engine=engine,
+                             preprocess_workers=0, timeout=seconds)
         status = pr.sat
         model = pr.model
         conflicts = pr.stats.get("conflicts", 0)
     else:
-        status, model, conflicts = _solve(red, cfg, None, engine, seconds)
+        status, model, conflicts = _solve(red, cfg, None, engine, seconds,
+                                          proof=proof)
     r.conflicts = conflicts + r.probe_conflicts
     r.sat = status
     if status: